public void ShouldBySmallByDefault()
{
MarkarthMilk a = new MarkarthMilk();
Assert.Equal(Size.Small, a.Size);
}
public void ShouldBeADrink()
{
MarkarthMilk a = new MarkarthMilk();
Assert.IsAssignableFrom <Drink>(a);
}
public void ShouldBeIOrderItem()
{
MarkarthMilk mm = new MarkarthMilk();
Assert.IsAssignableFrom <IOrderItem>(mm);
}
public void ShouldNotIncludeIceByDefault()
{
MarkarthMilk mm = new MarkarthMilk();
Assert.False(mm.Ice);
}
public void ShouldReturnCorrectDescription()
{
MarkarthMilk mm = new MarkarthMilk();
Assert.Equal("Hormone-free organic 2% milk.", mm.Description);
}
public void IsAssignableFromINotifyPropertyChanged()
{
MarkarthMilk mm = new MarkarthMilk();
Assert.IsAssignableFrom <INotifyPropertyChanged>(mm);
}
/// <summary>
/// A method return all drinks
/// </summary>
/// <returns>an IEnumerable<IOrderItem> containing all available drinks offered by BleakwindBuffet. As each drink has 3 different sizes, this collection should contain a small, medium, and large instance of each. Similarly, it should contain three of each flavor of SailorSoda: one large, one medium, and one small.</returns>
public static IEnumerable <IOrderItem> Drinks()
{
List <IOrderItem> drinks = new List <IOrderItem>();
AretinoAppleJuice saa = new AretinoAppleJuice();
AretinoAppleJuice maa = new AretinoAppleJuice();
AretinoAppleJuice laa = new AretinoAppleJuice();
saa.Size = Size.Small;
maa.Size = Size.Medium;
laa.Size = Size.Large;
drinks.Add(saa);
drinks.Add(maa);
drinks.Add(laa);
WarriorWater sww = new WarriorWater();
WarriorWater mww = new WarriorWater();
WarriorWater lww = new WarriorWater();
sww.Size = Size.Small;
mww.Size = Size.Medium;
lww.Size = Size.Large;
drinks.Add(sww);
drinks.Add(mww);
drinks.Add(lww);
MarkarthMilk smm = new MarkarthMilk();
MarkarthMilk mmm = new MarkarthMilk();
MarkarthMilk lmm = new MarkarthMilk();
smm.Size = Size.Small;
mmm.Size = Size.Medium;
lmm.Size = Size.Large;
drinks.Add(smm);
drinks.Add(mmm);
drinks.Add(lmm);
CandlehearthCoffee scc = new CandlehearthCoffee();
CandlehearthCoffee mcc = new CandlehearthCoffee();
CandlehearthCoffee lcc = new CandlehearthCoffee();
scc.Size = Size.Small;
mcc.Size = Size.Medium;
lcc.Size = Size.Large;
drinks.Add(scc);
drinks.Add(mcc);
drinks.Add(lcc);
CandlehearthCoffee sdc = new CandlehearthCoffee();
CandlehearthCoffee mdc = new CandlehearthCoffee();
CandlehearthCoffee ldc = new CandlehearthCoffee();
sdc.Decaf = true;
mdc.Decaf = true;
ldc.Decaf = true;
sdc.Size = Size.Small;
mdc.Size = Size.Medium;
ldc.Size = Size.Large;
drinks.Add(sdc);
drinks.Add(mdc);
drinks.Add(ldc);
SailorSoda scherry = new SailorSoda();
SailorSoda mcherry = new SailorSoda();
SailorSoda lcherry = new SailorSoda();
scherry.Size = Size.Small;
mcherry.Size = Size.Medium;
lcherry.Size = Size.Large;
drinks.Add(scherry);
drinks.Add(mcherry);
drinks.Add(lcherry);
SailorSoda sblac = new SailorSoda();
SailorSoda mblac = new SailorSoda();
SailorSoda lblac = new SailorSoda();
sblac.Size = Size.Small;
mblac.Size = Size.Medium;
lblac.Size = Size.Large;
sblac.Flavor = SodaFlavor.Blackberry;
mblac.Flavor = SodaFlavor.Blackberry;
lblac.Flavor = SodaFlavor.Blackberry;
drinks.Add(sblac);
drinks.Add(mblac);
drinks.Add(lblac);
SailorSoda sgra = new SailorSoda();
SailorSoda mgra = new SailorSoda();
SailorSoda lgra = new SailorSoda();
sgra.Flavor = SodaFlavor.Grapefruit;
mgra.Flavor = SodaFlavor.Grapefruit;
lgra.Flavor = SodaFlavor.Grapefruit;
sgra.Size = Size.Small;
mgra.Size = Size.Medium;
lgra.Size = Size.Large;
drinks.Add(sgra);
drinks.Add(mgra);
drinks.Add(lgra);
SailorSoda slem = new SailorSoda();
SailorSoda mlem = new SailorSoda();
SailorSoda llem = new SailorSoda();
slem.Flavor = SodaFlavor.Lemon;
mlem.Flavor = SodaFlavor.Lemon;
llem.Flavor = SodaFlavor.Lemon;
slem.Size = Size.Small;
mlem.Size = Size.Medium;
llem.Size = Size.Large;
drinks.Add(slem);
drinks.Add(mlem);
drinks.Add(llem);
SailorSoda spea = new SailorSoda();
SailorSoda mpea = new SailorSoda();
SailorSoda lpea = new SailorSoda();
spea.Size = Size.Small;
mpea.Size = Size.Medium;
lpea.Size = Size.Large;
spea.Flavor = SodaFlavor.Peach;
mpea.Flavor = SodaFlavor.Peach;
lpea.Flavor = SodaFlavor.Peach;
drinks.Add(spea);
drinks.Add(mpea);
drinks.Add(lpea);
SailorSoda swat = new SailorSoda();
SailorSoda mwat = new SailorSoda();
SailorSoda lwat = new SailorSoda();
swat.Flavor = SodaFlavor.Watermelon;
mwat.Flavor = SodaFlavor.Watermelon;
lwat.Flavor = SodaFlavor.Watermelon;
swat.Size = Size.Small;
mwat.Size = Size.Medium;
lwat.Size = Size.Large;
drinks.Add(swat);
drinks.Add(mwat);
drinks.Add(lwat);
return(drinks);
}
public void CheckCorrectFullMenu()
{
Assert.Collection(Menu.FullMenu(),
//Entrees
item => Assert.IsType <BriarheartBurger>(item),
item => Assert.IsType <DoubleDraugr>(item),
item => Assert.IsType <GardenOrcOmelette>(item),
item => Assert.IsType <PhillyPoacher>(item),
item => Assert.IsType <SmokehouseSkeleton>(item),
item => Assert.IsType <ThalmorTriple>(item),
item => Assert.IsType <ThugsTBone>(item),
//Sides
item => {
Assert.IsType <DragonbornWaffleFries>(item);
DragonbornWaffleFries dbwf = (DragonbornWaffleFries)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, dbwf.Size);
},
item => {
Assert.IsType <DragonbornWaffleFries>(item);
DragonbornWaffleFries dbwf = (DragonbornWaffleFries)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, dbwf.Size);
},
item => {
Assert.IsType <DragonbornWaffleFries>(item);
DragonbornWaffleFries dbwf = (DragonbornWaffleFries)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, dbwf.Size);
},
//FriedMiraak
item => {
Assert.IsType <FriedMiraak>(item);
FriedMiraak fm = (FriedMiraak)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, fm.Size);
},
item => {
Assert.IsType <FriedMiraak>(item);
FriedMiraak fm = (FriedMiraak)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, fm.Size);
},
item => {
Assert.IsType <FriedMiraak>(item);
FriedMiraak fm = (FriedMiraak)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, fm.Size);
},
//MadOtarGrits
item => {
Assert.IsType <MadOtarGrits>(item);
MadOtarGrits mog = (MadOtarGrits)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, mog.Size);
},
item => {
Assert.IsType <MadOtarGrits>(item);
MadOtarGrits mog = (MadOtarGrits)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, mog.Size);
},
item => {
Assert.IsType <MadOtarGrits>(item);
MadOtarGrits mog = (MadOtarGrits)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, mog.Size);
},
//VokunSalad
item => {
Assert.IsType <VokunSalad>(item);
VokunSalad vs = (VokunSalad)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, vs.Size);
},
item => {
Assert.IsType <VokunSalad>(item);
VokunSalad vs = (VokunSalad)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, vs.Size);
},
item => {
Assert.IsType <VokunSalad>(item);
VokunSalad vs = (VokunSalad)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, vs.Size);
},
//Drinks
//AretinoAppleJuice
item => {
Assert.IsType <AretinoAppleJuice>(item);
AretinoAppleJuice aa = (AretinoAppleJuice)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, aa.Size);
},
item => {
Assert.IsType <AretinoAppleJuice>(item);
AretinoAppleJuice aa = (AretinoAppleJuice)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, aa.Size);
},
item => {
Assert.IsType <AretinoAppleJuice>(item);
AretinoAppleJuice aa = (AretinoAppleJuice)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, aa.Size);
},
//CandlehearthCofffee
item => {
Assert.IsType <CandlehearthCoffee>(item);
CandlehearthCoffee chc = (CandlehearthCoffee)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, chc.Size);
},
item => {
Assert.IsType <CandlehearthCoffee>(item);
CandlehearthCoffee chc = (CandlehearthCoffee)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, chc.Size);
},
item => {
Assert.IsType <CandlehearthCoffee>(item);
CandlehearthCoffee chc = (CandlehearthCoffee)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, chc.Size);
},
//MarkarthMilk
item => {
Assert.IsType <MarkarthMilk>(item);
MarkarthMilk mm = (MarkarthMilk)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, mm.Size);
},
item => {
Assert.IsType <MarkarthMilk>(item);
MarkarthMilk mm = (MarkarthMilk)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, mm.Size);
},
item => {
Assert.IsType <MarkarthMilk>(item);
MarkarthMilk mm = (MarkarthMilk)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, mm.Size);
},
//Warrior Water.
item => {
Assert.IsType <WarriorWater>(item);
WarriorWater ww = (WarriorWater)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ww.Size);
},
item => {
Assert.IsType <WarriorWater>(item);
WarriorWater ww = (WarriorWater)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ww.Size);
},
item => {
Assert.IsType <WarriorWater>(item);
WarriorWater ww = (WarriorWater)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ww.Size);
},
//SailorSoda
//Blackberry
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Blackberry, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Blackberry, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Blackberry, ss.Flavor);
},
//Cherry
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Cherry, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Cherry, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Cherry, ss.Flavor);
},
//Grapefruit
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Grapefruit, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Grapefruit, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Grapefruit, ss.Flavor);
},
//Lemon
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Lemon, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Lemon, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Lemon, ss.Flavor);
},
//Peach
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Peach, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Peach, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Peach, ss.Flavor);
},
//Watermelon
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Watermelon, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Watermelon, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Watermelon, ss.Flavor);
});
}
public void CheckCorrectDrinks()
{
Assert.Collection(Menu.Drinks(),
//AretinoAppleJuice
item => {
Assert.IsType <AretinoAppleJuice>(item);
AretinoAppleJuice aa = (AretinoAppleJuice)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, aa.Size);
},
item => {
Assert.IsType <AretinoAppleJuice>(item);
AretinoAppleJuice aa = (AretinoAppleJuice)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, aa.Size);
},
item => {
Assert.IsType <AretinoAppleJuice>(item);
AretinoAppleJuice aa = (AretinoAppleJuice)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, aa.Size);
},
//CandlehearthCofffee
item => {
Assert.IsType <CandlehearthCoffee>(item);
CandlehearthCoffee chc = (CandlehearthCoffee)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, chc.Size);
},
item => {
Assert.IsType <CandlehearthCoffee>(item);
CandlehearthCoffee chc = (CandlehearthCoffee)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, chc.Size);
},
item => {
Assert.IsType <CandlehearthCoffee>(item);
CandlehearthCoffee chc = (CandlehearthCoffee)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, chc.Size);
},
//MarkarthMilk
item => {
Assert.IsType <MarkarthMilk>(item);
MarkarthMilk mm = (MarkarthMilk)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, mm.Size);
},
item => {
Assert.IsType <MarkarthMilk>(item);
MarkarthMilk mm = (MarkarthMilk)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, mm.Size);
},
item => {
Assert.IsType <MarkarthMilk>(item);
MarkarthMilk mm = (MarkarthMilk)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, mm.Size);
},
//Warrior Water.
item => {
Assert.IsType <WarriorWater>(item);
WarriorWater ww = (WarriorWater)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ww.Size);
},
item => {
Assert.IsType <WarriorWater>(item);
WarriorWater ww = (WarriorWater)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ww.Size);
},
item => {
Assert.IsType <WarriorWater>(item);
WarriorWater ww = (WarriorWater)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ww.Size);
},
//SailorSoda
//Blackberry
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Blackberry, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Blackberry, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Blackberry, ss.Flavor);
},
//Cherry
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Cherry, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Cherry, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Cherry, ss.Flavor);
},
//Grapefruit
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Grapefruit, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Grapefruit, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Grapefruit, ss.Flavor);
},
//Lemon
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Lemon, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Lemon, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Lemon, ss.Flavor);
},
//Peach
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Peach, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Peach, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Peach, ss.Flavor);
},
//Watermelon
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Small, ss.Size);
Assert.Equal(SodaFlavor.Watermelon, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Medium, ss.Size);
Assert.Equal(SodaFlavor.Watermelon, ss.Flavor);
},
item => {
Assert.IsType <SailorSoda>(item);
SailorSoda ss = (SailorSoda)item; //Should be safe as it was asserted above for type
Assert.Equal(Size.Large, ss.Size);
Assert.Equal(SodaFlavor.Watermelon, ss.Flavor);
});
}
/// <summary>
/// Cancel click event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void CancelClick(object sender, RoutedEventArgs e)
{
milk = new MarkarthMilk();
Swap();
}
public void ShouldReturnCorrectDescription(string description)
{
MarkarthMilk mm = new MarkarthMilk();
Assert.Equal(description, mm.Description);
}
