public void TryGenerateAndCalculate100000Games()
        {
            var round = new RoundOfPlay(new Player(), 1);
            var total = 0;
            var highestRound = 0;
            var highestRoundFrames = new Frame[10];
            var lowestRound = 100;
            var lowestRoundFrames = new Frame[10];
            try
            {
                for (int i = 0; i < 100000; i++)
                {
                    var fullRoundOfFrames = GenerateSpecifiedNumberOfRandomFrames(10);
                    round.Frames = fullRoundOfFrames.ToArray();
                    total += (int)round.TotalScore;
                    if ((int)round.TotalScore > highestRound)
                    {
                        highestRound = (int)round.TotalScore;
                        highestRoundFrames = round.Frames;
                    }
                    if ((int)round.TotalScore < lowestRound)
                    {
                        lowestRound = (int)round.TotalScore;
                        lowestRoundFrames = round.Frames;
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Did not expect an exception, but got: " + ex.Message);
            }

        }
        public void OnlyAllowThirdThrowOnRoundTen()
        {
            var round = new RoundOfPlay(new Player(), 1);
            round.Frames = GeneratePredictableFrames(10);
            _ = Assert.Throws<InvalidOperationException>(() => round.Frames[0].ThirdThrow = 3);

            round.Frames[9].ThirdThrow = 3;
            Assert.Equal(3, round.Frames[9].ThirdThrow);

        }
 public void ThrowIndexOutOfRange_When_Over_Ten_Frames_Are_Added_To_Round()
 {
     var round = new RoundOfPlay(new Player(), 1);
     var frames = GenerateSpecifiedNumberOfRandomFrames(10);
     var extraFrame = GenerateSpecifiedNumberOfRandomFrames(1);
     
     round.Frames = frames.ToArray();
     _ = Assert.Throws<IndexOutOfRangeException>(() => round.Frames[10] = extraFrame.FirstOrDefault());
     
     Assert.Equal(10, round.Frames.Count());
 }
        public void GetTotalScoreOnPlayerRound_Simple_After_Two_Frames_When_One_Score_Is_Null()
        {
            var testPlayer = new Player();
            var firstFrame = new Frame { FirstThrow = 4, SecondThrow = 1 };
            var secondFrame = new Frame() { FirstThrow = 0, SecondThrow = null };
            var frames = new Frame[10];
            frames[0] = firstFrame;
            frames[1] = secondFrame;
            var roundOfPlay = new RoundOfPlay(testPlayer, 1) { Frames = frames }; ;

            Assert.Equal(5, roundOfPlay.TotalScore);
        }
        public void CorrectTotalScoreForFullRound_WithoutThirdThrow()
        {
            //Arrange
            var round = new RoundOfPlay(new Player(), 1);
            round.Frames = GeneratePredictableFrames(10);

            //Act
            var result = round.TotalScore;

            //Assert
            Assert.Equal(45, result);
        }
        public void GetTotalScoresWithStrikeSpare()
        {
            var testPlayer = new Player();
            var firstFrame = new Frame { FrameNumber = 1, FirstThrow = 10, SecondThrow = null };
            var secondFrame = new Frame() { FrameNumber = 2, FirstThrow = 2, SecondThrow = 8 };
            var roundOfPlay = new RoundOfPlay(testPlayer, 1);
            roundOfPlay.Frames[0] = firstFrame;
            roundOfPlay.Frames[1] = secondFrame;

            var result = roundOfPlay.TotalScore;

            Assert.Equal(20, result);
        }
        public void CorrectCountStrikeSpareNormal()
        {
            //Arrange
            var testPlayer = new Player();
            var firstFrame = new Frame { FrameNumber = 1, FirstThrow = 10, SecondThrow = null };
            var secondFrame = new Frame() { FrameNumber = 2, FirstThrow = 3, SecondThrow = 7 };
            var thirdFrame = new Frame() { FrameNumber = 3, FirstThrow = 5, SecondThrow = 3 };

            var roundOfPlay = new RoundOfPlay(testPlayer, 1);
            roundOfPlay.Frames[0] = firstFrame;
            roundOfPlay.Frames[1] = secondFrame;
            roundOfPlay.Frames[2] = thirdFrame;
            //Act
            var result = roundOfPlay.TotalScore;

            //Assert
            Assert.Equal(43, result);
        }
        public void CorrectTotalScoreForFullRound_WithSomeStrikesAndSpares_WithoutThirdthrow()
        {
            //Arrange
            var round = new RoundOfPlay(new Player(), 1);
            round.Frames = GeneratePredictableFrames(10);


            round.Frames[0] = new Frame() { FrameNumber = 1, FirstThrow = 10 };
            round.Frames[1] = new Frame() { FrameNumber = 2, FirstThrow = 2, SecondThrow = 8 };
            round.Frames[3] = new Frame() { FrameNumber = 4, FirstThrow = 0, SecondThrow = 10 };
            round.Frames[5] = new Frame() { FrameNumber = 6, FirstThrow = 10 };
            foreach(var test in round.Frames)
            {
                var totalFrame = test.GetScoreForFrame(round.Frames);
            }
            //Act
            //var result = round.Frames[0].GetScoreForFrame(round.Frames);
            var result = round.TotalScore;

            //Assert
            Assert.Equal(98, result);
        }
        public void GetMaxPointsForAFrame_AndThenStopStrikeChain()
        {
            var testPlayer = new Player();
            var firstFrame = new Frame { FrameNumber = 1, FirstThrow = 10, SecondThrow = null };
            var secondFrame = new Frame() { FrameNumber = 2, FirstThrow = 10, SecondThrow = null };
            var thirdFrame = new Frame() { FrameNumber = 3, FirstThrow = 10, SecondThrow = null };
            var fourthFrame = new Frame() { FrameNumber = 4, FirstThrow = 10, SecondThrow = null };
            var fifthFrame = new Frame() { FrameNumber = 5, FirstThrow = 1, SecondThrow = 0 };

            var roundOfPlay = new RoundOfPlay(testPlayer, 1);
            roundOfPlay.Frames[0] = firstFrame;
            roundOfPlay.Frames[1] = secondFrame;
            roundOfPlay.Frames[2] = thirdFrame;
            roundOfPlay.Frames[3] = fourthFrame;
            roundOfPlay.Frames[4] = fifthFrame;

            var result = roundOfPlay.Frames[0].GetScoreForFrame(roundOfPlay.Frames);
            var resultTotal = roundOfPlay.TotalScore;
            Assert.Equal(30, result);
            Assert.Equal(93, resultTotal);

        }
        public void GetMaxPointsForAFrame()
        {
            var testPlayer = new Player();
            var firstFrame = new Frame { FrameNumber = 1, FirstThrow = 10, SecondThrow = null };
            var secondFrame = new Frame() { FrameNumber = 2, FirstThrow = 10, SecondThrow = null };
            var thirdFrame = new Frame() { FrameNumber = 3, FirstThrow = 10, SecondThrow = null };
            var fourthFrame = new Frame() { FrameNumber = 3, FirstThrow = 10, SecondThrow = null };

            var roundOfPlay = new RoundOfPlay(testPlayer, 1);
            roundOfPlay.Frames[0] = firstFrame;
            roundOfPlay.Frames[1] = secondFrame;
            roundOfPlay.Frames[2] = thirdFrame;
            roundOfPlay.Frames[3] = fourthFrame;

            var result1 = roundOfPlay.Frames[0].GetScoreForFrame(roundOfPlay.Frames);
            var result2 = roundOfPlay.Frames[1].GetScoreForFrame(roundOfPlay.Frames);
            var shouldBeNull = roundOfPlay.Frames[2].GetScoreForFrame(roundOfPlay.Frames);
            var resultTotal = roundOfPlay.TotalScore;
            Assert.Equal(30, result1);
            Assert.Equal(30, result2);
            Assert.Equal(60, resultTotal);
            Assert.Null(shouldBeNull);

        }