public delegate void Int32Action ( int value);

public class Delegates
{
public void RandomRob( int value)
{
Console . WriteLine( "Delegate implementation: { 0} " , value);
}

//static means related to the type rather than any specific instance of the type
public static void StaticRob( int value)
{
Console . WriteLine( "Static method: { 0} " , value);
}
}

[ Test ]
public void SimpleDelegateFromMethod()
{
Delegates target = new Delegates ();
//C#1 syntax
Int32Action action = new Int32Action (target . RandomRob);

//same.. calling the delegate which has been setup to be target.RandomRob
action . Invoke( 5 );
action( 6 );
}

[ Test ]
public void DelegateFromStaticMethod()
{
Int32Action action = new Int32Action ( Delegates . StaticRob);
action . Invoke( 7 );
}

[ TestFixture ]
public class FakeEventRaiserTest
{
private void ReportToConsole( string text)
{
Console . WriteLine( "Called: { 0} " , text);
}

[ Test ]
public void RaiseEvents()
{
//C#1
//FakeEventHandler handler = new FakeEventHandler(ReportToConsole);
//C#2 - implicit method group conversions
FakeEventHandler handler = ReportToConsole;

FakeEventRaiser raiser = new FakeEventRaiser ();
raiser . DoSomething( "Not subscribed" );

raiser . AddHandler(handler);
raiser . DoSomething( "Subscribed" );

raiser . AddHandler(handler);
raiser . DoSomething( "Subscribed twice" );

raiser . RemoveHandler(handler);
raiser . RemoveHandler(handler);
raiser . DoSomething( "Unsubscribed" );
}
}

public class FakeEventRaiser
{
private FakeEventHandler currentHandler = null ;

public void AddHandler( FakeEventHandler handler)
{
currentHandler = currentHandler + handler;
}

public void RemoveHandler( FakeEventHandler handler)
{
currentHandler = currentHandler - handler;
}

public void DoSomething( string text)
{
FakeEventHandler tmp = currentHandler;
if (tmp != null )
tmp . Invoke(text);
}
}

[ TestFixture ]
public class LonghandEventRaiserTest
{
private void ReportToConsole( object sender, EventArgs e)
{
Console . WriteLine( "ReportToConsole was called" );
}

[ Test ]
public void RaiseEvents()
{
//C#1
//FakeEventHandler handler = new FakeEventHandler(ReportToConsole);
//C#2 - implicit method group conversions
ClickHandler handler = ReportToConsole;

var raiser = new LonghandEventRaiser ();
raiser . OnClick( "Not subscribed" );

raiser . Click += handler;
raiser . OnClick( "Subscribed" );

raiser . Click += handler;
raiser . OnClick( "Subscribed twice" );

raiser . Click -= handler;
raiser . Click -= handler;
raiser . OnClick( "Unsubscribed" );
}
}

namespace MasteringCSharp . Tests
{
public delegate void ClickHandler ( object sender, EventArgs e);

public class LonghandEventRaiser
{
private ClickHandler currentHandler = null ;

private void AddHandler( ClickHandler handler)
{
currentHandler = currentHandler + handler;
}

private void RemoveHandler( ClickHandler handler)
{
currentHandler = currentHandler - handler;
}

public void OnClick( string text)
{
ClickHandler tmp = currentHandler;
if (tmp != null )
tmp . Invoke( this , EventArgs . Empty);
}

public event ClickHandler Click
{
add { AddHandler( value );}
remove {RemoveHandler( value );}
}
}
}

public delegate void ClickHandler ( object sender, EventArgs e);

public class LonghandEventRaiser
{
private ClickHandler currentHandler = null ;

public void OnClick( string text)
{
ClickHandler tmp = currentHandler;
if (tmp != null )
tmp . Invoke( this , EventArgs . Empty);
}

public event ClickHandler Click
{
add { currentHandler += value ; }
remove {currentHandler -= value ;}
}
}

public void OnClick( string text)
{
//Click refers to the field which is auto genned
ClickHandler tmp = Click;
if (tmp != null )
tmp . Invoke( this , EventArgs . Empty);
}

//declared with a field like event
public event ClickHandler Click;

class Program
{
static void Main( string [] args)
{
MyClass mc = new MyClass ();
string result = mc . Process();
Console . WriteLine(result);
}
}

public class MyClass
{
public string Process()
{
return "In Process" ;
}
}

class Program
{
private delegate void LogDelegate ( string s);

static void Main( string [] args)
{
LogDelegate consoleLog = new LogDelegate (ConsoleLoggerFunction);
consoleLog . Invoke( "hello world" );
consoleLog( "Another way" );
}

static void ConsoleLoggerFunction( string s)
{
Console . WriteLine( "Message is: { 0} " , s);
}
}

class Program
{
static void Main( string [] args)
{
Person p = new Person ();
Person . LogDelegate logger = new Person . LogDelegate (Logger);
//implicit method group conversion
//Person.LogDelegate logger = Logger;
p . Process(logger);
}

private static void Logger( string message)
{
Console . WriteLine(message);
}
}

public class Person
{
public delegate void LogDelegate ( string message);

public void Process( LogDelegate logDelegate)
{
if (logDelegate != null )
logDelegate . Invoke( "Doing stuff" );
}
}

[ Test ]
public void Process_WhenCalled_ShouldWriteToLogPassedIntoDelegate()
{
Person p = new Person ();
Person . LogDelegate logDelegate = new Person . LogDelegate (FakeLogger);

p . Process(logDelegate);

}

private void FakeLogger( string message)
{
Console . WriteLine( "FakeLogger: { 0} " , message);
}

internal class MyClass
{
//takes a single string parameter and no return type
public delegate void LogHandler ( string message);

public void Process( LogHandler lh)
{
if (lh != null )
lh( "Process() begin" );
if (lh != null )
lh( "Process() end" );
}
}

// The FileLogger class merely encapsulates the file I/O
public class FileLogger
{
FileStream fileStream;
StreamWriter streamWriter;

// Constructor
public FileLogger( string filename)
{
fileStream = new FileStream (filename, FileMode . Create);
streamWriter = new StreamWriter (fileStream);
}

// Member Function which is used in the Delegate
public void Logger( string s)
{
streamWriter . WriteLine(s);
}

public void Close()
{
streamWriter . Close();
fileStream . Close();
}
}

public class TestApplication
{
static void Main( string [] args)
{
FileLogger fl = new FileLogger ( "process.log" );
MyClass mc = new MyClass ();

MyClass . LogHandler myLogger = new MyClass . LogHandler (fl . Logger);
mc . Process(myLogger);
fl . Close();
}
}

public class Person
{
//takes a single string parameter and no return type
public delegate void LogHandler ( string message);

// Define an Event based on the above Delegate
public event LogHandler Log;

//call the event using OnXXX where XXX is the name of the event
public void Process()
{
OnLog( "Process() begin" );
OnLog( "Process() end" );
}

protected void OnLog( string message)
{
if (Log != null )
Log(message);
}
}

public class FileLogger
{
FileStream fileStream;
StreamWriter streamWriter;

public FileLogger( string filename)
{
fileStream = new FileStream (filename, FileMode . Create);
streamWriter = new StreamWriter (fileStream);
}

// Member Function which is used in the Delegate
public void Logger( string s)
{
streamWriter . WriteLine(s);
}

public void Close()
{
streamWriter . Close();
fileStream . Close();
}
}

public class TestApplication
{
static void ConsoleLogger( string s)
{
Console . WriteLine(s);
}

static void Main( string [] args)
{
FileLogger fl = new FileLogger ( "process.log" );
Person person = new Person ();

// Subscribe the Functions ConsoleLogger and fl.ConsoleLogger
person . Log += new Person . LogHandler (ConsoleLogger);
person . Log += new Person . LogHandler (fl . Logger);

person . Process();

fl . Close();
}
}

public delegate void FakeEventHandler ( string reason);

public class FakeEventRaiser
{
private FakeEventHandler currentHandler = null ;

public void AddHandler( FakeEventHandler handler)
{
currentHandler = currentHandler + handler;
}

public void RemoveHandler( FakeEventHandler handler)
{
currentHandler = currentHandler - handler;
}

public void DoSomething( string text)
{
FakeEventHandler tmp = currentHandler;
if (tmp != null )
tmp . Invoke(text);
}
}

//interaction tests!
[ Test ]
public void Add_EmptyString_CallsTheLogger()
{
FakeLogger fakeLog = new FakeLogger ();
StringCalculator sc = new StringCalculator (fakeLog);

sc . Add( "" );

StringAssert . Contains( "empty" , fakeLog . WrittenWith);
}

public class StringCalculator
{
private readonly ILogger logger;

public StringCalculator( ILogger logger)
{
this . logger = logger;
}

public int Add( string numbers)
{
LogNumbers(numbers);
if (IsEmpty(numbers))
{
return DefaultEmptyResult();
}
return AllOtherValues(numbers);
}

private void LogNumbers( string numbers)
{
if (IsEmpty(numbers))
logger . Write( "empty" );
else
logger . Write(numbers);
}

private bool IsEmpty( string numbers)
{
return string . IsNullOrEmpty(numbers);
}

private static int AllOtherValues( string numbers)
{
return int . Parse(numbers);
}

private static int DefaultEmptyResult()
{
return 0 ;
}

[ TestCase ( "1" )]
[ TestCase ( "2" )]
[ TestCase ( "333" )]
public void Logging_SingleNumberAndFirstLoggerIsFull_SecondaryLoggerIsCalled( string number)
{
FakeLogger firstLogger = new FakeLogger ();
FakeLogger secondLogger = new FakeLogger ();

firstLogger . WillThrow = new Exception ( "out of space" );
StringCalculator sc = new StringCalculator (firstLogger);
sc . SecondaryLogger = secondLogger;

sc . Add(number);

//secondaryLogger is the mock object
StringAssert . Contains(number, secondLogger . WrittenWith);
}

public int Add( string numbers)
{
LogNumbers(numbers);
if (IsEmpty(numbers))
{
return DefaultEmptyResult();
}
return AllOtherValues(numbers);
}

private void LogNumbers( string numbers)
{
try
{
if (IsEmpty(numbers))
logger . Write( "empty" );
else
logger . Write(numbers);
}
catch ( Exception e)
{
SecondaryLogger . Write(numbers);
}
}

[ TestFixture ]
public class MyCalculatorTests
{
[ Test ]
public void Add_TwoNumbers_ReturnsTheSum()
{
MyCalculator c = GetNewCalc();

int result = c . Add( 1 , 2 );

Assert . AreEqual( 3 , result);
}

private static MyCalculator GetNewCalc()
{
return new MyCalculator ();
}
}

[ Test ]
//[ExpectedException(typeof(Exception))]
public void Add_FirstParamNegative_Throw()
{
MyCalculator c = GetNewCalc();

int ANY_POSITIVE = 1 ;

//c.Add(-1, ANY_POSITIVE);

//parameter is a delegate to a method here
//but would have same problem as putting in an attribute
//ie wouldn't know that GetNewCalc didn't fire an exception
//any line of Code could throw an exception
//Assert.Throws<Exception>(Code);

//anonymous delegate or anonymous method
//even though its in the scope on an anon method
//it knows about c
Assert . Throws < Exception > ( delegate
{
c . Add( - 1 , ANY_POSITIVE);
});

//lambda expression - shorter delegate notation
//method doesn't have any name.
//after => body of method only has one line
//Assert.Throws<Exception>(() => c.Add(-1, ANY_POSITIVE));
}

private void Code()
{
//c.Add(-1, ANY_POSITIVE);
}

[ Test ]
public void ResultMemory_CallingAdd_ResultIsSavedForLater()
{
MyCalculator c = GetNewCalc();
int result = c . AddPositives( 1 , 2 );
Assert . AreEqual( 3 , c . LastResult );
}

//a backing field
private int _lastResult;
//property (not an auto property)
public int LastResult
{
get { return 3 ; }
set { _lastResult = value ; }
}

[ TestCase ( 1 , 2 , 3 )]
public void ResultMemory_CallingAdd_ResultIsSavedForLater( int a, int b, int expected)
{
MyCalculator c = GetNewCalc();
int result = c . AddPositives(a, b);
Assert . AreEqual(expected, c . LastResult);
}

public partial class Form1 : Form {
GumballMachine gumballMachine;
public Form1() {
InitializeComponent();
gumballMachine = new GumballMachine ( 5 );
var output = gumballMachine . MachineStateHeader();
output = PutInLineFeeds(output);
txtOutput . Text = output;
}

private void btnInsertQuarter_Click( object sender, EventArgs e) {
var output = gumballMachine . InsertQuarter();
output += gumballMachine . MachineStateHeader();
output = PutInLineFeeds(output);
txtOutput . Text = output;
}

private void txtTurnCrank_Click( object sender, EventArgs e) {
var output = gumballMachine . TurnCrank();
output += gumballMachine . MachineStateHeader();
output = PutInLineFeeds(output);
txtOutput . Text = output;
}

private void btnRefill_Click( object sender, EventArgs e) {
var output = gumballMachine . Refill( 3 );
output += gumballMachine . MachineStateHeader();
output = PutInLineFeeds(output);
txtOutput . Text = output;
}

private static string PutInLineFeeds( string output) {
output = output . Replace( "\n" , "\r\n" );
return output;
}
}

public class GumballMachine {
IState soldOutState;
IState noQuarterState;
IState hasQuarterState;
IState soldState;
IState winnerState;

IState state;

int count = 0 ;

public int Count { get { return count; } set { count = value ; } }

public GumballMachine( int numberGumballs) {
//creating the state instances - one of each
noQuarterState = new NoQuarterState ( this );
hasQuarterState = new HasQuarterState ( this );
soldState = new SoldState ( this );
soldOutState = new SoldOutState ( this );
winnerState = new WinnerState ( this );
this . count = numberGumballs;
if (numberGumballs > 0 )
state = noQuarterState;
else
state = soldOutState;
}

public string InsertQuarter() {
return state . InsertQuarter();
}

public string EjectQuarter() {
return state . EjectQuarter();
}

public string TurnCrank() {
var output = state . TurnCrank();
output += state . Dispense();
return output;
}

public string Refill( int i) {
return state . Refill(i);
}

public void SetState( IState state) {
this . state = state;
}

public IState GetState() {
return state;
}

public IState GetNoQuarterState() {
return noQuarterState;
}

public IState GetHasQuarterState() {
return hasQuarterState;
}

public IState GetSoldState() {
return soldState;
}

public IState GetSoldOutState() {
return soldOutState;
}

public IState GetWinnerState() {
return winnerState;
}

public string ReleaseBall() {
if (count != 0 )
count -- ;
return ( "A gumball comes rolling out the slot...\n\n" );
}

public string MachineStateHeader() {
var result = new StringBuilder ();
result . Append( "Mighty Gumball, Inc." );
result . Append( "\nC# Enabled Standing Gumball Model #2005\n" );
result . Append( "Inventory: " + count + " gumball" );
if (count != 1 ) {
result . Append( "s" );
}
result . Append( "\nMachine is " + state . ToString());

return result . ToString();
}
}

public class NoQuarterState : IState {
//a reference to the gumballMachine
GumballMachine gumballMachine;

public NoQuarterState( GumballMachine gumballMachine) {
this . gumballMachine = gumballMachine;
}

public string InsertQuarter() {
gumballMachine . SetState(gumballMachine . GetHasQuarterState());
return ( "You inserted a quarter" );
}

public string EjectQuarter() {
return "You haven't inserted a quarter\n" ;
}

public string TurnCrank() {
return "You turned but there's no quarter\n" ;
}

public string Dispense() {
return "You need to pay first\n" ;
}

public override string ToString() {
return "State: NoQuarter.\n Waiting for quarter\n" ;
}

public string Refill( int i) {
gumballMachine . Count += i;
gumballMachine . SetState(gumballMachine . GetNoQuarterState());
return "filled her up" ;
}
}

public class HasQuarterState : IState {
GumballMachine gumballMachine;
Random randomWinner = new Random ();

public HasQuarterState( GumballMachine gumballMachine) {
this . gumballMachine = gumballMachine;
}

public string InsertQuarter() {
return "You can't insert another quarter\n" ;
}

public string EjectQuarter() {
gumballMachine . SetState(gumballMachine . GetNoQuarterState());
return "Quarter returned\n" ;
}

public string TurnCrank() {
string output;
output = "You turned...\n" ;

//int winner = randomWinner.Next(10);
//if (winner == 0 && gumballMachine.Count > 1) {
if (gumballMachine . Count == 10 ) {
gumballMachine . SetState(gumballMachine . GetWinnerState());
}
else {
gumballMachine . SetState(gumballMachine . GetSoldState());
}
return output;
}

public string Dispense() {
string output;

output = gumballMachine . ReleaseBall();
output += "No gumball dispensed\n" ;

return output;
}

public override string ToString() {
return "State: HasQuarter\n waiting for turn of crank" ;
}

public string Refill( int numberOfGumball) {
return "Can't refill - there is a quarter in the machine so please turn crank" ;
}
}

public class SoldState : IState {
GumballMachine gumballMachine;

public SoldState( GumballMachine gumballMachine) {
this . gumballMachine = gumballMachine;
}

public string InsertQuarter() {
return "Please wait, we're already giving you a gumball\n" ;
}

public string EjectQuarter() {
return "Sorry, you already turned the crank\n" ;
}

public string TurnCrank() {
return "Turning twice doesn't get you another gumball!\n" ;
}

public string Dispense() {
string output;
output = gumballMachine . ReleaseBall();
if (gumballMachine . Count > 0 ) {
gumballMachine . SetState(gumballMachine . GetNoQuarterState());
}
else {
gumballMachine . SetState(gumballMachine . GetSoldOutState());
output += "Oops, out of gumballs!\n" ;
}
return output;
}

public override string ToString() {
return "State: Sold \n delivering a gumball" ;
}

public string Refill( int numberOfGumball) {
return "Can't refill - you've turned the crank and I'm about to dispense a gumball" ;
}
}

public class SoldOutState : IState {
GumballMachine gumballMachine;

public SoldOutState( GumballMachine gumballMachine) {
this . gumballMachine = gumballMachine;
}

public string InsertQuarter() {
return "You can't insert a quarter, the machine is sold out\n" ;
}

public string EjectQuarter() {
return "You can't eject, you haven't inserted a quarter yet\n" ;
}

public string TurnCrank() {
return "Sorry, you already turned the crank\n" ;
}

public string Dispense() {
return "You turned, but there are no gumballs\n" ;
}

public override string ToString() {
return "State: SoldOut" ;
}

public string Refill( int i) {
gumballMachine . Count = i;
gumballMachine . SetState(gumballMachine . GetNoQuarterState());
return "filled her up" ;
}
}

public class WinnerState : IState {

GumballMachine gumballMachine;

public WinnerState( GumballMachine gumballMachine) {
this . gumballMachine = gumballMachine;
}

public string InsertQuarter() {
return "Please wait, we're already giving you a gumball\n" ;
}

public string EjectQuarter() {
return "Sorry, you already turned the crank\n" ;
}

public string TurnCrank() {
return "Turning twice doesn't get you another gumball!\n" ;
}

public string Dispense() {
string output = "You're a winner. You get 2 gumballs for your quarter" ;
gumballMachine . ReleaseBall();
if (gumballMachine . Count == 0 )
gumballMachine . SetState(gumballMachine . GetSoldOutState());
else {
gumballMachine . ReleaseBall();
if (gumballMachine . Count == 0 )
gumballMachine . SetState(gumballMachine . GetSoldOutState());
else
gumballMachine . SetState(gumballMachine . GetNoQuarterState());
}
return output;
}

public string Refill( int numberOfGumball) {
return "Can't refill..you've turned the crank and I'm about to dispense 2 gumballs" ;
}
}


public interface IState {
string InsertQuarter();
string EjectQuarter();
string TurnCrank();
string Dispense();
string Refill( int numberOfGumball);
}

static void Main( string [] args) {
var gumballMachine = new GumballMachine ( 2 );
while ( true ) {
var typeThing = gumballMachine . GetState() . GetType();
//NoQuarter
if (typeThing == typeof ( NoQuarterState )) {
Console . WriteLine(gumballMachine . MachineStateHeader());
Console . WriteLine( "Press 1 to insert quarter or 2 to refill 2 more gumballs" );
var input = Console . ReadLine();
var output = "" ;
if (input == "1" )
output = gumballMachine . InsertQuarter();
if (input == "2" )
output = gumballMachine . Refill( 2 );
Console . WriteLine(output);
}

//HasQuarter
if (typeThing == typeof ( HasQuarterState )) {
Console . WriteLine(gumballMachine . MachineStateHeader());
Console . WriteLine( "Press 2 to turn crank or 3 to eject quarter" );
var input = Console . ReadLine();
var output = "" ;
if (input == "2" )
output = gumballMachine . TurnCrank();
if (input == "3" )
output = gumballMachine . EjectQuarter();
Console . WriteLine(output);
}

//SoldOut
if (typeThing == typeof ( SoldOutState )) {
Console . WriteLine(gumballMachine . MachineStateHeader());
Console . WriteLine( "Press 4 to refill 4 gumballs, 5 to refill 5 gumballs" );
var input = Console . ReadLine();
var output = "" ;
int i = 0 ;
Int32 . TryParse(input, out i);
if (input == "4" || input == "5" )
output = gumballMachine . Refill(i);
Console . WriteLine(output);
}
}
}

[ TestFixture ]
public class GumballTests {
[ Test ]
public void machine_is_in_no_quarter_state_if_has_5_gumballs_to_start_with() {
var gumballMachine = new GumballMachine ( 5 );
Assert . AreEqual( 5 , gumballMachine . Count);
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( NoQuarterState )));
}

[ Test ]
public void machine_is_in_sold_out_state_if_has_0_gumballs_to_start_with() {
var gumballMachine = new GumballMachine ( 0 );
Assert . AreEqual( 0 , gumballMachine . Count);
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( SoldOutState )));
}

[ Test ]
public void machine_is_in_has_quarter_state_if_has_5_gumballs_to_start_with_and_person_inserts_quarter() {
var gumballMachine = new GumballMachine ( 5 );
gumballMachine . InsertQuarter();
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( HasQuarterState )));
}

[ Test ]
public void machine_is_in_no_quarter_state_if_has_5_gumballs_to_start_with_and_person_inserts_quarter_then_ejects() {
var gumballMachine = new GumballMachine ( 5 );
Assert . AreEqual( 5 , gumballMachine . Count);
gumballMachine . InsertQuarter();
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( HasQuarterState )));
gumballMachine . EjectQuarter();
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( NoQuarterState )));
}

[ Test ]
public void machine_is_in_no_quarter_state_if_has_5_gumballs_to_start_with_and_person_inserts_quarter_then_turns_crank() {
var gumballMachine = new GumballMachine ( 5 );
Assert . AreEqual( 5 , gumballMachine . Count);
gumballMachine . InsertQuarter();
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( HasQuarterState )));
//this actually turns crank and dispenses
gumballMachine . TurnCrank();
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( NoQuarterState )));
Assert . AreEqual( 4 , gumballMachine . Count);
}

[ Test ]
public void machine_is_in_sold_out_state_if_has_1_gumball_to_start_with_and_person_inserts_quarter_then_turns_crank() {
var gumballMachine = new GumballMachine ( 1 );
Assert . AreEqual( 1 , gumballMachine . Count);
gumballMachine . InsertQuarter();
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( HasQuarterState )));
//this actually turns crank and dispenses
gumballMachine . TurnCrank();
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( SoldOutState )));
Assert . AreEqual( 0 , gumballMachine . Count);
}

[ Test ]
public void machine_gives_correct_message_when_sold_out_and_user_trys_to_insert_a_quarter() {
var gumballMachine = new GumballMachine ( 0 );
var output = gumballMachine . InsertQuarter();
Assert . AreEqual( "You can't insert a quarter, the machine is sold out\n" , output);
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( SoldOutState )));
Assert . AreEqual( 0 , gumballMachine . Count);
}

[ Test ]
public void machine_gives_2_gumballs_when_number_in_machine_is_10_faking_a_winner_random_scenario() {
var gumballMachine = new GumballMachine ( 10 );
gumballMachine . InsertQuarter();
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( HasQuarterState )));
var output = gumballMachine . TurnCrank();
StringAssert . Contains( "You're a winner" , output);
Assert . AreEqual( 8 , gumballMachine . Count);
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( NoQuarterState )));
}

[ Test ]
public void machine_goes_to_correct_number_of_gumballs_when_refill_is_done_at_sold_out_state() {
var gumballMachine = new GumballMachine ( 0 );
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( SoldOutState )));
var output = gumballMachine . Refill( 15 );
Assert . AreEqual( 15 , gumballMachine . Count);
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( NoQuarterState )));
}

[ Test ]
public void machine_goes_to_correct_number_of_gumballs_when_refill_is_done_on_no_quarter_state() {
var gumballMachine = new GumballMachine ( 5 );
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( NoQuarterState )));
var output = gumballMachine . Refill( 15 );
Assert . AreEqual( 20 , gumballMachine . Count);
Assert . That(gumballMachine . GetState(), Is . TypeOf( typeof ( NoQuarterState )));
}


[ Test ]
public void TestGumballMachine() {
GumballMachine gumballMachine = new GumballMachine ( 5 );
StringBuilder gumballMachineOutput = new StringBuilder ();

gumballMachineOutput . Append(gumballMachine . MachineStateHeader() + "\n" );

gumballMachineOutput . Append(gumballMachine . InsertQuarter());
gumballMachineOutput . Append(gumballMachine . TurnCrank() + "\n" );

//gumballMachineOutput.Append(gumballMachine.MachineStateHeader() + "\n");

//gumballMachineOutput.Append(gumballMachine.InsertQuarter());
//gumballMachineOutput.Append(gumballMachine.TurnCrank());
//gumballMachineOutput.Append(gumballMachine.InsertQuarter());
//gumballMachineOutput.Append(gumballMachine.TurnCrank() + "\n");

//gumballMachineOutput.Append(gumballMachine.MachineStateHeader() + "\n");

//gumballMachineOutput.Append(gumballMachine.Refill(5) + "\n");

//gumballMachineOutput.Append(gumballMachine.MachineStateHeader() + "\n");



//Because of the System.Random object, there is no way to know
//the outcome of the turn of the crank. Therefore, I am writing
//to the console. Use the Console.Out tab of NUnit
Console . WriteLine(gumballMachineOutput . ToString());
}
}

namespace GumballState {
class Program {
static void Main( string [] args) {
new GumballMachine ();
}
}

enum StateType {
SOLD_OUT = 0 ,
NO_QUARTER = 1 ,
HAS_QUARTER = 2 ,
SOLD = 3
}

class GumballMachine {
//created an instance variable to hold the state values
private int state = ( int ) StateType . SOLD_OUT;

public GumballMachine() {
InsertQuarter();
}

void InsertQuarter() {
//conditional code within method to handle each state
if (state == ( int ) StateType . HAS_QUARTER)
Console . WriteLine( "You can't insert another quarter" );
if (state == ( int ) StateType . SOLD_OUT)
Console . WriteLine( "You can't insert a quarter, the machine is sold out" );
if (state == ( int ) StateType . SOLD)
Console . WriteLine( "Please wait, we're giving you a gumball" );
if (state == ( int ) StateType . NO_QUARTER) {
state = ( int ) StateType . HAS_QUARTER;
Console . WriteLine( "You inserterd a quarter" );
}
}
}
}

namespace GumballState {
class Program {
static void Main( string [] args) {
new GumballMachine ();
}
}

class GumballMachine {
static readonly int SOLD_OUT = 0 ;
static readonly int NO_QUARTER = 1 ;
static readonly int HAS_QUARTER = 2 ;
static readonly int SOLD = 3 ;

//created an instance variable to hold the state values
int state = SOLD_OUT;

public GumballMachine() {
InsertQuarter();
}

void InsertQuarter() {
//conditional code within method to handle each state
if (state == HAS_QUARTER)
Console . WriteLine( "You can't insert another quarter" );
if (state == SOLD_OUT)
Console . WriteLine( "You can't insert a quarter, the machine is sold out" );
if (state == SOLD)
Console . WriteLine( "Please wait, we're giving you a gumball" );
if (state == NO_QUARTER) {
state = HAS_QUARTER;
Console . WriteLine( "You inserterd a quarter" );
}
}
}
}

class Program {
static void Main( string [] args) {
new GumballMachine ( 20 );
}
}

public class GumballMachine {
//enums is bigger app.. usually CamelCase
static readonly int SOLD_OUT = 0 ;
static readonly int NO_QUARTER = 1 ;
static readonly int HAS_QUARTER = 2 ;
static readonly int SOLD = 3 ;

//created an instance variable to hold the state value... could use underscore here.
public int state = SOLD_OUT;
//another instance variable to keep track of number of gumballs in machine
public int currentNumberOfGumballsInMachine = 0 ;

public GumballMachine( int initialNumberOfGumballsInMachine) {
currentNumberOfGumballsInMachine = initialNumberOfGumballsInMachine;
if (currentNumberOfGumballsInMachine > 0 )
state = NO_QUARTER;
}

public string DisplayStatus() {
var x = "Number of Gumballs: " + currentNumberOfGumballsInMachine . ToString();
x += Environment . NewLine;
x += "State: " + state . ToString();
x += Environment . NewLine;
return x;
}

public void InsertQuarter() {
//conditional code within method to handle each state
if (state == HAS_QUARTER)
Console . WriteLine( "You can't insert another quarter" );
if (state == SOLD_OUT)
Console . WriteLine( "You can't insert a quarter, the machine is sold out" );
if (state == SOLD)
Console . WriteLine( "Please wait, we're giving you a gumball" );
if (state == NO_QUARTER) {
state = HAS_QUARTER;
Console . WriteLine( "You inserterd a quarter" );
}
}

public void EjectQuarter() {
if (state == HAS_QUARTER) {
Console . WriteLine( "Quarter returned" );
state = NO_QUARTER;
} else
Console . WriteLine( "logic error in EjectQuarter" );
}

public void TurnCrank() {
if (state == HAS_QUARTER) {
Console . WriteLine( "You turned" );
state = SOLD;
Dispense();
}
}

public void Dispense() {
if (state == SOLD) {
Console . WriteLine( "a gumball comes rolling out of the slot" );
currentNumberOfGumballsInMachine -= 1 ;
if (currentNumberOfGumballsInMachine == 0 ) {
Console . WriteLine( "Out of gumballs" );
state = SOLD_OUT;
}
else
state = NO_QUARTER;
}
}
}