Change ksu-cis#2

Braden155543 · Braden155543 · commit 9e6aeb3507fb · 2020-09-07T18:30:00.000-05:00
diff --git a/Data/Drinks/CandlehearthCoffee.cs b/Data/Drinks/CandlehearthCoffee.cs
@@ -124,6 +124,7 @@ public override string ToString()
         {
             StringBuilder sb = new StringBuilder();
             sb.Append(Size);
+            if (Decaf) sb.Append(" Decaf");
             sb.Append(" Candlehearth Coffee");
             return sb.ToString();
         }
diff --git a/Data/Drinks/SailorSoda.cs b/Data/Drinks/SailorSoda.cs
@@ -13,7 +13,7 @@ public class SailorSoda
         /// <summary>
         /// sets the private fields to their default values
         /// </summary>
-        private bool ice = false;
+        private bool ice = true;
         private Size size = Size.Small;
         private SodaFlavor flavor = SodaFlavor.Cherry;
 
@@ -93,9 +93,9 @@ public List<string> SpecialInstructions {
             get 
             {
                 List<string> list = new List<string>();
-                if (Ice)
+                if (!Ice)
                 {
-                    list.Add("Add ice");
+                    list.Add("Hold ice");
                 }
 
                 return list;
diff --git a/DataTests/DataTests.csproj b/DataTests/DataTests.csproj
@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
 
     <IsPackable>false</IsPackable>
 
diff --git a/DataTests/UnitTests/DrinkTests/AretinoAppleJuiceTests.cs b/DataTests/UnitTests/DrinkTests/AretinoAppleJuiceTests.cs
@@ -5,6 +5,7 @@
  */
 using Xunit;
 
+using System.Collections.Generic;
 using BleakwindBuffet.Data;
 using BleakwindBuffet.Data.Enums;
 using BleakwindBuffet.Data.Drinks;
@@ -76,9 +77,10 @@ public void ShouldHaveCorrectSpecialInstructions(bool includeIce)
         {
             AretinoAppleJuice apple = new AretinoAppleJuice();
             apple.Ice = includeIce;
+            List<string> list = apple.SpecialInstructions;
 
-            if (includeIce) Assert.Equal("Add ice", apple.SpecialInstructions[0]);
-            else Assert.Equal("", apple.SpecialInstructions[0]);
+            if (includeIce) Assert.Equal("Add ice", list[0]);
+            else Assert.Empty(list);
         }
 
         [Theory]
diff --git a/DataTests/UnitTests/DrinkTests/CandlehearthCoffeeTests.cs b/DataTests/UnitTests/DrinkTests/CandlehearthCoffeeTests.cs
@@ -7,6 +7,7 @@
 
 using BleakwindBuffet.Data;
 using BleakwindBuffet.Data.Enums;
+using BleakwindBuffet.Data.Drinks;
 
 namespace BleakwindBuffet.DataTests.UnitTests.DrinkTests
 {
@@ -15,41 +16,63 @@ public class CandlehearthCoffeeTests
         [Fact]
         public void ShouldNotIncludeIceByDefault()
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            Assert.False(coffee.Ice);
         }
 
         [Fact]
         public void ShouldNotBeDecafByDefault()
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            Assert.False(coffee.Decaf);
         }
 
         [Fact]
         public void ShouldNotHaveRoomForCreamByDefault()
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            Assert.False(coffee.RoomForCream);
         }
 
         [Fact]
         public void ShouldBeSmallByDefault()
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            Assert.Equal(Size.Small, coffee.Size);
         }
 
         [Fact]
         public void ShouldBeAbleToSetIce()
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            coffee.Ice = true;
+            Assert.True(coffee.Ice);
         }
 
         [Fact]
         public void ShouldBeAbleToSetDecaf()
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            coffee.Decaf = true;
+            Assert.True(coffee.Decaf);
         }
 
         [Fact]
         public void ShouldBeAbleToSetRoomForCream()
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            coffee.RoomForCream = true;
+            Assert.True(coffee.RoomForCream);
         }
 
         [Fact]
         public void ShouldBeAbleToSetSize()
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            coffee.Size = Size.Medium;
+            Assert.Equal(Size.Medium, coffee.Size);
+            coffee.Size = Size.Large;
+            Assert.Equal(Size.Large, coffee.Size);
         }
 
         [Theory]
@@ -58,6 +81,9 @@ public void ShouldBeAbleToSetSize()
         [InlineData(Size.Large, 1.75)]
         public void ShouldHaveCorrectPriceForSize(Size size, double price)
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            coffee.Size = size;
+            Assert.True(price == coffee.Price);
         }
 
         [Theory]
@@ -66,6 +92,9 @@ public void ShouldHaveCorrectPriceForSize(Size size, double price)
         [InlineData(Size.Large, 20)]
         public void ShouldHaveCorrectCaloriesForSize(Size size, uint cal)
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            coffee.Size = size;
+            Assert.True(cal == coffee.Calories);
         }
 
         [Theory]
@@ -75,6 +104,27 @@ public void ShouldHaveCorrectCaloriesForSize(Size size, uint cal)
         [InlineData(false, false)]
         public void ShouldHaveCorrectSpecialInstructions(bool includeIce, bool includeCream)
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            coffee.Ice = includeIce;
+            coffee.RoomForCream = includeCream;
+
+            if (includeIce && includeCream)
+            {
+                Assert.Equal("Add ice", coffee.SpecialInstructions[0]);
+                Assert.Equal("Add cream", coffee.SpecialInstructions[1]);
+            }
+            else if (includeIce && !includeCream)
+            {
+                Assert.Equal("Add ice", coffee.SpecialInstructions[0]);
+            }
+            else if (!includeIce && includeCream)
+            {
+                Assert.Equal("Add cream", coffee.SpecialInstructions[0]);
+            }
+            else
+            {
+                Assert.Empty(coffee.SpecialInstructions);
+            }
         }
 
         [Theory]
@@ -86,6 +136,10 @@ public void ShouldHaveCorrectSpecialInstructions(bool includeIce, bool includeCr
         [InlineData(false, Size.Large, "Large Candlehearth Coffee")]
         public void ShouldReturnCorrectToStringBasedOnSize(bool decaf, Size size, string name)
         {
+            CandlehearthCoffee coffee = new CandlehearthCoffee();
+            coffee.Decaf = decaf;
+            coffee.Size = size;
+            Assert.Equal(name, coffee.ToString());
         }
     }
 }
diff --git a/DataTests/UnitTests/DrinkTests/MarkarthMilkTests.cs b/DataTests/UnitTests/DrinkTests/MarkarthMilkTests.cs
@@ -7,6 +7,7 @@
 
 using BleakwindBuffet.Data;
 using BleakwindBuffet.Data.Enums;
+using BleakwindBuffet.Data.Drinks;
 
 namespace BleakwindBuffet.DataTests.UnitTests.DrinkTests
 {
@@ -15,21 +16,33 @@ public class MarkarthMilkTests
         [Fact]
         public void ShouldNotIncludeIceByDefault()
         {
+            MarkarthMilk milk = new MarkarthMilk();
+            Assert.False(milk.Ice);
         }
 
         [Fact]
         public void ShouldBySmallByDefault()
         {
+            MarkarthMilk milk = new MarkarthMilk();
+            Assert.Equal(Size.Small, milk.Size);
         }
 
         [Fact]
         public void ShouldByAbleToSetIce()
         {
+            MarkarthMilk milk = new MarkarthMilk();
+            milk.Ice = true;
+            Assert.True(milk.Ice);
         }
 
         [Fact]
         public void ShouldBeAbleToSetSize()
         {
+            MarkarthMilk milk = new MarkarthMilk();
+            milk.Size = Size.Medium;
+            Assert.Equal(Size.Medium, milk.Size);
+            milk.Size = Size.Large;
+            Assert.Equal(Size.Large, milk.Size);
         }
 
         [Theory]
@@ -38,6 +51,9 @@ public void ShouldBeAbleToSetSize()
         [InlineData(Size.Large, 1.22)]
         public void ShouldHaveCorrectPriceForSize(Size size, double price)
         {
+            MarkarthMilk milk = new MarkarthMilk();
+            milk.Size = size;
+            Assert.True(milk.Price == price);
         }
 
         [Theory]
@@ -46,13 +62,21 @@ public void ShouldHaveCorrectPriceForSize(Size size, double price)
         [InlineData(Size.Large, 93)]
         public void ShouldHaveCorrectCaloriesForSize(Size size, uint cal)
         {
+            MarkarthMilk milk = new MarkarthMilk();
+            milk.Size = size;
+            Assert.True(milk.Calories == cal);
         }
 
         [Theory]
         [InlineData(true)]
         [InlineData(false)]
         public void ShouldHaveCorrectSpecialInstructions(bool includeIce)
         {
+            MarkarthMilk milk = new MarkarthMilk();
+            milk.Ice = includeIce;
+
+            if (includeIce) Assert.Equal("Add ice", milk.SpecialInstructions[0]);
+            else Assert.Empty(milk.SpecialInstructions);
         }
 
         [Theory]
@@ -61,6 +85,9 @@ public void ShouldHaveCorrectSpecialInstructions(bool includeIce)
         [InlineData(Size.Large, "Large Markarth Milk")]
         public void ShouldReturnCorrectToStringBasedOnSize(Size size, string name)
         {
+            MarkarthMilk milk = new MarkarthMilk();
+            milk.Size = size;
+            Assert.Equal(name, milk.ToString());
         }
     }
 }
diff --git a/DataTests/UnitTests/DrinkTests/SailorSodaTests.cs b/DataTests/UnitTests/DrinkTests/SailorSodaTests.cs
@@ -9,6 +9,7 @@
 
 using BleakwindBuffet.Data;
 using BleakwindBuffet.Data.Enums;
+using BleakwindBuffet.Data.Drinks;
 
 namespace BleakwindBuffet.DataTests.UnitTests.DrinkTests
 {
@@ -17,31 +18,56 @@ public class SailorSodaTests
         [Fact]
         public void ShouldIncludeIceByDefault()
         {
+            SailorSoda soda = new SailorSoda();
+            Assert.True(soda.Ice);
         }
 
         [Fact]
         public void ShouldBeSmallByDefault()
         {
+            SailorSoda soda = new SailorSoda();
+            Assert.Equal(Size.Small, soda.Size);
         }
 
         [Fact]
         public void FlavorShouldBeCherryByDefault()
         {
+            SailorSoda soda = new SailorSoda();
+            Assert.Equal(SodaFlavor.Cherry, soda.Flavor);
         }
 
         [Fact]
         public void ShouldBeAbleToSetIce()
         {
+            SailorSoda soda = new SailorSoda();
+            soda.Ice = false;
+            Assert.False(soda.Ice);
         }
 
         [Fact]
         public void ShouldBeAbleToSetSize()
         {
+            SailorSoda soda = new SailorSoda();
+            soda.Size = Size.Medium;
+            Assert.Equal(Size.Medium, soda.Size);
+            soda.Size = Size.Large;
+            Assert.Equal(Size.Large, soda.Size);
         }
 
         [Fact]
         public void ShouldBeAbleToSetFlavor()
         {
+            SailorSoda soda = new SailorSoda();
+            soda.Flavor = SodaFlavor.Blackberry;
+            Assert.Equal(SodaFlavor.Blackberry, soda.Flavor);
+            soda.Flavor = SodaFlavor.Grapefruit;
+            Assert.Equal(SodaFlavor.Grapefruit, soda.Flavor);
+            soda.Flavor = SodaFlavor.Lemon;
+            Assert.Equal(SodaFlavor.Lemon, soda.Flavor);
+            soda.Flavor = SodaFlavor.Peach;
+            Assert.Equal(SodaFlavor.Peach, soda.Flavor);
+            soda.Flavor = SodaFlavor.Watermelon;
+            Assert.Equal(SodaFlavor.Watermelon, soda.Flavor);
         }
 
         [Theory]
@@ -50,6 +76,9 @@ public void ShouldBeAbleToSetFlavor()
         [InlineData(Size.Large, 2.07)]
         public void ShouldHaveCorrectPriceForSize(Size size, double price)
         {
+            SailorSoda soda = new SailorSoda();
+            soda.Size = size;
+            Assert.True(soda.Price == price);
         }
 
         [Theory]
@@ -58,13 +87,21 @@ public void ShouldHaveCorrectPriceForSize(Size size, double price)
         [InlineData(Size.Large, 205)]
         public void ShouldHaveCorrectCaloriesForSize(Size size, uint cal)
         {
+            SailorSoda soda = new SailorSoda();
+            soda.Size = size;
+            Assert.True(soda.Calories == cal);
         }
 
         [Theory]
         [InlineData(true)]
         [InlineData(false)]
         public void ShouldHaveCorrectSpecialInstructions(bool includeIce)
         {
+            SailorSoda soda = new SailorSoda();
+            soda.Ice = includeIce;
+
+            if (!includeIce) Assert.Equal("Hold ice", soda.SpecialInstructions[0]);
+            else Assert.Empty(soda.SpecialInstructions);
         }
         
         [Theory]
@@ -93,6 +130,10 @@ public void ShouldHaveCorrectSpecialInstructions(bool includeIce)
         [InlineData(SodaFlavor.Watermelon, Size.Large, "Large Watermelon Sailor Soda")]
         public void ShouldHaveCorrectToStringBasedOnSizeAndFlavor(SodaFlavor flavor, Size size, string name)
         {
+            SailorSoda soda = new SailorSoda();
+            soda.Flavor = flavor;
+            soda.Size = size;
+            Assert.Equal(name, soda.ToString());
         }
     }
 }
diff --git a/DataTests/UnitTests/EntreeTests/BriarheartBurgerTests.cs b/DataTests/UnitTests/EntreeTests/BriarheartBurgerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -124,6 +124,7 @@ public override string ToString()`
`124`	`124`	`{`
`125`	`125`	`StringBuilder sb = new StringBuilder();`
`126`	`126`	`sb.Append(Size);`
	`127`	`+ if (Decaf) sb.Append(" Decaf");`
`127`	`128`	`sb.Append(" Candlehearth Coffee");`
`128`	`129`	`return sb.ToString();`
`129`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public class SailorSoda`
`13`	`13`	`/// <summary>`
`14`	`14`	`/// sets the private fields to their default values`
`15`	`15`	`/// </summary>`
`16`		`- private bool ice = false;`
	`16`	`+ private bool ice = true;`
`17`	`17`	`private Size size = Size.Small;`
`18`	`18`	`private SodaFlavor flavor = SodaFlavor.Cherry;`
`19`	`19`
`@@ -93,9 +93,9 @@ public List<string> SpecialInstructions {`
`93`	`93`	`get`
`94`	`94`	`{`
`95`	`95`	`List<string> list = new List<string>();`
`96`		`- if (Ice)`
	`96`	`+ if (!Ice)`
`97`	`97`	`{`
`98`		`- list.Add("Add ice");`
	`98`	`+ list.Add("Hold ice");`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`return list;`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`
`8`	`8`	`using BleakwindBuffet.Data;`
`9`	`9`	`using BleakwindBuffet.Data.Enums;`
	`10`	`+using BleakwindBuffet.Data.Drinks;`
`10`	`11`
`11`	`12`	`namespace BleakwindBuffet.DataTests.UnitTests.DrinkTests`
`12`	`13`	`{`
`@@ -15,41 +16,63 @@ public class CandlehearthCoffeeTests`
`15`	`16`	`[Fact]`
`16`	`17`	`public void ShouldNotIncludeIceByDefault()`
`17`	`18`	`{`
	`19`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`20`	`+ Assert.False(coffee.Ice);`
`18`	`21`	`}`
`19`	`22`
`20`	`23`	`[Fact]`
`21`	`24`	`public void ShouldNotBeDecafByDefault()`
`22`	`25`	`{`
	`26`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`27`	`+ Assert.False(coffee.Decaf);`
`23`	`28`	`}`
`24`	`29`
`25`	`30`	`[Fact]`
`26`	`31`	`public void ShouldNotHaveRoomForCreamByDefault()`
`27`	`32`	`{`
	`33`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`34`	`+ Assert.False(coffee.RoomForCream);`
`28`	`35`	`}`
`29`	`36`
`30`	`37`	`[Fact]`
`31`	`38`	`public void ShouldBeSmallByDefault()`
`32`	`39`	`{`
	`40`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`41`	`+ Assert.Equal(Size.Small, coffee.Size);`
`33`	`42`	`}`
`34`	`43`
`35`	`44`	`[Fact]`
`36`	`45`	`public void ShouldBeAbleToSetIce()`
`37`	`46`	`{`
	`47`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`48`	`+ coffee.Ice = true;`
	`49`	`+ Assert.True(coffee.Ice);`
`38`	`50`	`}`
`39`	`51`
`40`	`52`	`[Fact]`
`41`	`53`	`public void ShouldBeAbleToSetDecaf()`
`42`	`54`	`{`
	`55`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`56`	`+ coffee.Decaf = true;`
	`57`	`+ Assert.True(coffee.Decaf);`
`43`	`58`	`}`
`44`	`59`
`45`	`60`	`[Fact]`
`46`	`61`	`public void ShouldBeAbleToSetRoomForCream()`
`47`	`62`	`{`
	`63`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`64`	`+ coffee.RoomForCream = true;`
	`65`	`+ Assert.True(coffee.RoomForCream);`
`48`	`66`	`}`
`49`	`67`
`50`	`68`	`[Fact]`
`51`	`69`	`public void ShouldBeAbleToSetSize()`
`52`	`70`	`{`
	`71`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`72`	`+ coffee.Size = Size.Medium;`
	`73`	`+ Assert.Equal(Size.Medium, coffee.Size);`
	`74`	`+ coffee.Size = Size.Large;`
	`75`	`+ Assert.Equal(Size.Large, coffee.Size);`
`53`	`76`	`}`
`54`	`77`
`55`	`78`	`[Theory]`
`@@ -58,6 +81,9 @@ public void ShouldBeAbleToSetSize()`
`58`	`81`	`[InlineData(Size.Large, 1.75)]`
`59`	`82`	`public void ShouldHaveCorrectPriceForSize(Size size, double price)`
`60`	`83`	`{`
	`84`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`85`	`+ coffee.Size = size;`
	`86`	`+ Assert.True(price == coffee.Price);`
`61`	`87`	`}`
`62`	`88`
`63`	`89`	`[Theory]`
`@@ -66,6 +92,9 @@ public void ShouldHaveCorrectPriceForSize(Size size, double price)`
`66`	`92`	`[InlineData(Size.Large, 20)]`
`67`	`93`	`public void ShouldHaveCorrectCaloriesForSize(Size size, uint cal)`
`68`	`94`	`{`
	`95`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`96`	`+ coffee.Size = size;`
	`97`	`+ Assert.True(cal == coffee.Calories);`
`69`	`98`	`}`
`70`	`99`
`71`	`100`	`[Theory]`
`@@ -75,6 +104,27 @@ public void ShouldHaveCorrectCaloriesForSize(Size size, uint cal)`
`75`	`104`	`[InlineData(false, false)]`
`76`	`105`	`public void ShouldHaveCorrectSpecialInstructions(bool includeIce, bool includeCream)`
`77`	`106`	`{`
	`107`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`108`	`+ coffee.Ice = includeIce;`
	`109`	`+ coffee.RoomForCream = includeCream;`
	`110`	`+`
	`111`	`+ if (includeIce && includeCream)`
	`112`	`+ {`
	`113`	`+ Assert.Equal("Add ice", coffee.SpecialInstructions[0]);`
	`114`	`+ Assert.Equal("Add cream", coffee.SpecialInstructions[1]);`
	`115`	`+ }`
	`116`	`+ else if (includeIce && !includeCream)`
	`117`	`+ {`
	`118`	`+ Assert.Equal("Add ice", coffee.SpecialInstructions[0]);`
	`119`	`+ }`
	`120`	`+ else if (!includeIce && includeCream)`
	`121`	`+ {`
	`122`	`+ Assert.Equal("Add cream", coffee.SpecialInstructions[0]);`
	`123`	`+ }`
	`124`	`+ else`
	`125`	`+ {`
	`126`	`+ Assert.Empty(coffee.SpecialInstructions);`
	`127`	`+ }`
`78`	`128`	`}`
`79`	`129`
`80`	`130`	`[Theory]`
`@@ -86,6 +136,10 @@ public void ShouldHaveCorrectSpecialInstructions(bool includeIce, bool includeCr`
`86`	`136`	`[InlineData(false, Size.Large, "Large Candlehearth Coffee")]`
`87`	`137`	`public void ShouldReturnCorrectToStringBasedOnSize(bool decaf, Size size, string name)`
`88`	`138`	`{`
	`139`	`+ CandlehearthCoffee coffee = new CandlehearthCoffee();`
	`140`	`+ coffee.Decaf = decaf;`
	`141`	`+ coffee.Size = size;`
	`142`	`+ Assert.Equal(name, coffee.ToString());`
`89`	`143`	`}`
`90`	`144`	`}`
`91`	`145`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`
`10`	`10`	`using BleakwindBuffet.Data;`
`11`	`11`	`using BleakwindBuffet.Data.Enums;`
	`12`	`+using BleakwindBuffet.Data.Drinks;`
`12`	`13`
`13`	`14`	`namespace BleakwindBuffet.DataTests.UnitTests.DrinkTests`
`14`	`15`	`{`
`@@ -17,31 +18,56 @@ public class SailorSodaTests`
`17`	`18`	`[Fact]`
`18`	`19`	`public void ShouldIncludeIceByDefault()`
`19`	`20`	`{`
	`21`	`+ SailorSoda soda = new SailorSoda();`
	`22`	`+ Assert.True(soda.Ice);`
`20`	`23`	`}`
`21`	`24`
`22`	`25`	`[Fact]`
`23`	`26`	`public void ShouldBeSmallByDefault()`
`24`	`27`	`{`
	`28`	`+ SailorSoda soda = new SailorSoda();`
	`29`	`+ Assert.Equal(Size.Small, soda.Size);`
`25`	`30`	`}`
`26`	`31`
`27`	`32`	`[Fact]`
`28`	`33`	`public void FlavorShouldBeCherryByDefault()`
`29`	`34`	`{`
	`35`	`+ SailorSoda soda = new SailorSoda();`
	`36`	`+ Assert.Equal(SodaFlavor.Cherry, soda.Flavor);`
`30`	`37`	`}`
`31`	`38`
`32`	`39`	`[Fact]`
`33`	`40`	`public void ShouldBeAbleToSetIce()`
`34`	`41`	`{`
	`42`	`+ SailorSoda soda = new SailorSoda();`
	`43`	`+ soda.Ice = false;`
	`44`	`+ Assert.False(soda.Ice);`
`35`	`45`	`}`
`36`	`46`
`37`	`47`	`[Fact]`
`38`	`48`	`public void ShouldBeAbleToSetSize()`
`39`	`49`	`{`
	`50`	`+ SailorSoda soda = new SailorSoda();`
	`51`	`+ soda.Size = Size.Medium;`
	`52`	`+ Assert.Equal(Size.Medium, soda.Size);`
	`53`	`+ soda.Size = Size.Large;`
	`54`	`+ Assert.Equal(Size.Large, soda.Size);`
`40`	`55`	`}`
`41`	`56`
`42`	`57`	`[Fact]`
`43`	`58`	`public void ShouldBeAbleToSetFlavor()`
`44`	`59`	`{`
	`60`	`+ SailorSoda soda = new SailorSoda();`
	`61`	`+ soda.Flavor = SodaFlavor.Blackberry;`
	`62`	`+ Assert.Equal(SodaFlavor.Blackberry, soda.Flavor);`
	`63`	`+ soda.Flavor = SodaFlavor.Grapefruit;`
	`64`	`+ Assert.Equal(SodaFlavor.Grapefruit, soda.Flavor);`
	`65`	`+ soda.Flavor = SodaFlavor.Lemon;`
	`66`	`+ Assert.Equal(SodaFlavor.Lemon, soda.Flavor);`
	`67`	`+ soda.Flavor = SodaFlavor.Peach;`
	`68`	`+ Assert.Equal(SodaFlavor.Peach, soda.Flavor);`
	`69`	`+ soda.Flavor = SodaFlavor.Watermelon;`
	`70`	`+ Assert.Equal(SodaFlavor.Watermelon, soda.Flavor);`
`45`	`71`	`}`
`46`	`72`
`47`	`73`	`[Theory]`
`@@ -50,6 +76,9 @@ public void ShouldBeAbleToSetFlavor()`
`50`	`76`	`[InlineData(Size.Large, 2.07)]`
`51`	`77`	`public void ShouldHaveCorrectPriceForSize(Size size, double price)`
`52`	`78`	`{`
	`79`	`+ SailorSoda soda = new SailorSoda();`
	`80`	`+ soda.Size = size;`
	`81`	`+ Assert.True(soda.Price == price);`
`53`	`82`	`}`
`54`	`83`
`55`	`84`	`[Theory]`
`@@ -58,13 +87,21 @@ public void ShouldHaveCorrectPriceForSize(Size size, double price)`
`58`	`87`	`[InlineData(Size.Large, 205)]`
`59`	`88`	`public void ShouldHaveCorrectCaloriesForSize(Size size, uint cal)`
`60`	`89`	`{`
	`90`	`+ SailorSoda soda = new SailorSoda();`
	`91`	`+ soda.Size = size;`
	`92`	`+ Assert.True(soda.Calories == cal);`
`61`	`93`	`}`
`62`	`94`
`63`	`95`	`[Theory]`
`64`	`96`	`[InlineData(true)]`
`65`	`97`	`[InlineData(false)]`
`66`	`98`	`public void ShouldHaveCorrectSpecialInstructions(bool includeIce)`
`67`	`99`	`{`
	`100`	`+ SailorSoda soda = new SailorSoda();`
	`101`	`+ soda.Ice = includeIce;`
	`102`	`+`
	`103`	`+ if (!includeIce) Assert.Equal("Hold ice", soda.SpecialInstructions[0]);`
	`104`	`+ else Assert.Empty(soda.SpecialInstructions);`
`68`	`105`	`}`
`69`	`106`
`70`	`107`	`[Theory]`
`@@ -93,6 +130,10 @@ public void ShouldHaveCorrectSpecialInstructions(bool includeIce)`
`93`	`130`	`[InlineData(SodaFlavor.Watermelon, Size.Large, "Large Watermelon Sailor Soda")]`
`94`	`131`	`public void ShouldHaveCorrectToStringBasedOnSizeAndFlavor(SodaFlavor flavor, Size size, string name)`
`95`	`132`	`{`
	`133`	`+ SailorSoda soda = new SailorSoda();`
	`134`	`+ soda.Flavor = flavor;`
	`135`	`+ soda.Size = size;`
	`136`	`+ Assert.Equal(name, soda.ToString());`
`96`	`137`	`}`
`97`	`138`	`}`
`98`	`139`	`}`