Completed Assignment

BowlingBall.Tests/FrameTest.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace BowlingBall.Tests
+{
+    public class FrameTest
+    {
+        [Fact]
+        public void RollValueMoreThan10()
+        {
+            //roll cannot be more than 10
+            var result = Frame.IsValidRoll(12);
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void RollValueNegative()
+        {
+            //roll cannot be less than 0
+            var result = Frame.IsValidRoll(-2);
+            Assert.False(result);
+        }
+        [Fact]
+        public void ValidRollValues()
+        {
+            //valid roll values lies in the range of 0 to 10
+            var result1 = Frame.IsValidRoll(0);
+            var result2 = Frame.IsValidRoll(10);
+            var result3 = Frame.IsValidRoll(4);
+            var result4 = Frame.IsValidRoll(2);
+            var result5 = Frame.IsValidRoll(7);
+
+            var result = result1 && result2 && result3 && result4 && result5;
+            Assert.True(result);
+        }
+    }
+}

BowlingBall.Tests/GameFixture.cs

@@ -8,7 +8,7 @@ public class GameFixture
         [Fact]
         public void DummyTest()
         {
-            // This is a dummy test that will always pass.
+            Assert.True(true);
         }
     }
 }

BowlingBall.Tests/GameTest.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+namespace BowlingBall.Tests
+{
+    public class GameTest
+    {
+        [Fact]
+        public void RollWithPinsMoreThan10()
+        {
+            //roll cannot be more than 10 or negative
+            try
+            {
+                Game newGame = new Game();
+                newGame.Roll(11);
+            }
+            catch(Exception E)
+            {
+                //throws Exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void RollWithPinsLessThan0()
+        {
+            //roll cannot be more than 10 or negative
+            try
+            {
+                Game newGame = new Game();
+                newGame.Roll(-2);
+            }
+            catch (Exception E)
+            {
+                //throws Exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void RollWithvalidPins()
+        {
+            //roll cannot be more than 10 or negative
+            try
+            {
+                Game newGame = new Game();
+                newGame.Roll(2);
+            }
+            catch (Exception E)
+            {
+                //should not throw exception
+                Assert.True(false);
+            }
+            Assert.True(true);
+        }
+    }
+}

BowlingBall.Tests/RegularFrameTest.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using BowlingBall;
+using Xunit;
+namespace BowlingBall.Tests
+{
+    public class RegularFrameTest
+    {
+        [Fact]
+        public void NegativeRollsToCreateRegularFrame()
+        {
+            //Negative roll shall throw exception
+            try
+            {
+                RegularFrame regularFrame = new RegularFrame(-1, -2);
+            }
+            catch(Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void OneNegativeRollToCreateRegularFrame()
+        {
+            //Negative roll shall throw exception
+            try
+            {
+                RegularFrame regularFrame = new RegularFrame(-1, 2);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void InvalidRollToCreateRegularFrame()
+        {
+            //Negative roll shall throw exception
+            try
+            {
+                RegularFrame regularFrame = new RegularFrame(100,1);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void RollsSumUpToValueMoreThanExpectedToCreateRegularFrame()
+        {
+            //Negative roll shall throw exception
+            try
+            {
+                RegularFrame regularFrame = new RegularFrame(5, 6);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void validRollsToCreateRegularFrame()
+        {
+            //valid roll shall not throw exception
+            try
+            {
+                RegularFrame regularFrame = new RegularFrame(5, 4);
+            }
+            catch (Exception e)
+            {
+                Assert.True(false);
+            }
+            Assert.True(true);
+        }
+
+    }
+}

BowlingBall.Tests/SpareFrameTest.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+namespace BowlingBall.Tests
+{
+    public class SpareFrameTest
+    {
+        [Fact]
+        public void NegativeRollsToCreateSpareFrame()
+        {
+            //Negative roll shall throw exception
+            try
+            {
+                SpareFrame spareFrame = new SpareFrame(-1, -2,-8);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void FirstRollNegativeToCreateSpareFrame()
+        {
+            //Negative roll shall throw exception
+            try
+            {
+                SpareFrame spareFrame = new SpareFrame(-1, 2, 8);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+
+        [Fact]
+        public void SecondRollNegativeToCreateSpareFrame()
+        {
+            //Negative roll shall throw exception
+            try
+            {
+                SpareFrame spareFrame = new SpareFrame(1, -2, 8);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+
+        [Fact]
+        public void ThirdRollNegativeToCreateSpareFrame()
+        {
+            //Negative roll shall throw exception
+            try
+            {
+                SpareFrame spareFrame = new SpareFrame(1, 2, -8);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void RollsSumUpToValueLessThanExpectedToCreateSpareFrame()
+        {
+            //sum of rolls shall be 10 to create a spare frame
+            try
+            {
+                SpareFrame spareFrame = new SpareFrame(5,4,10);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void RollsSumUpToValueMoreThanExpectedToCreateSpareFrame()
+        {
+            //sum of rolls shall be 10 to create a spare frame
+            try
+            {
+                SpareFrame spareFrame = new SpareFrame(5, 6, 10);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void InvalidFirstRollToCreateSpareFrame()
+        {
+            //roll can't be more than 10
+            try
+            {
+                SpareFrame spareFrame = new SpareFrame(50, 4, 1);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void InvalidSecondRollToCreateSpareFrame()
+        {
+            //roll can't be more than 10
+            try
+            {
+                SpareFrame spareFrame = new SpareFrame(5, 14, 1);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void InvalidThirdRollToCreateSpareFrame()
+        {
+            //roll can't be more than 10
+            try
+            {
+                SpareFrame spareFrame = new SpareFrame(5, 4, 11);
+            }
+            catch (Exception e)
+            {
+                //Throws exception
+                return;
+            }
+            Assert.True(false);
+        }
+        [Fact]
+        public void ValidSetOfRollsToCreateSpareFrame()
+        {
+            try
+            {
+                SpareFrame spareFrame = new SpareFrame(5, 5, 1);
+            }
+            catch (Exception e)
+            {
+                //No exception is expected
+                Assert.True(false);
+            }
+            Assert.True(true);
+        }
+    }
+}