コード例 #1
0
        public void Should_allow_addtional_20Th_roll_if_there_are_strike_in_the_last_frame_and_one_strike_before()
        {
            // Arrange
            var scorer = new Scorer();

            // Act
            scorer.Roll(10);
            for (int i = 0; i < 17; i++)
            {
                scorer.Roll(0);
            }
            scorer.Roll(10);
            scorer.Roll(0);

            // Assert
            scorer.Invoking(s => s.Roll(1)).ShouldThrow<MaxNumberOfRollsExceededException>();
        }
コード例 #2
0
        public void Should_allow_aditional_roll_if_spare_in_the_last_frame()
        {
            // Arrange
            var scorer = new Scorer();

            // Act
            for (int i = 0; i < 18; i++)
            {
                scorer.Roll(0);
            }
            scorer.Roll(1);
            scorer.Roll(9);
            scorer.Roll(9);
            var score = scorer.CalculateScore();

            // Assert
            score.Should().Be(19);
        }
コード例 #3
0
        public void Should_allow_only_19_rolls_if_strike_is_not_in_the_last_frame()
        {
            // Arrange
            var scorer = new Scorer();

            // Act
            scorer.Roll(10);
            for (int i = 0; i < 18; i++)
            {
                scorer.Roll(2);
            }

            // Assert
            scorer.Invoking(r => r.Roll(1)).ShouldThrow<MaxNumberOfRollsExceededException>();
        }
コード例 #4
0
        public void Should_sum_two_subsequent_rolls(
			int firstRoll,
			int secondRoll,
			int total)
        {
            // Arrange
            var scorer = new Scorer();

            // Act
            scorer.Roll(firstRoll);
            scorer.Roll(secondRoll);
            var score = scorer.CalculateScore();

            // Assert
            Assert.AreEqual(total, score);
        }
コード例 #5
0
        public void Should_sum_two_subsequent_rolls_if_strike(int[] rolls, int total)
        {
            // Arrange
            var scorer = new Scorer();

            // Act
            foreach (int pins in rolls)
            {
                scorer.Roll(pins);
            }
            var score = scorer.CalculateScore();

            // Assert
            score.Should().Be(total);
        }
コード例 #6
0
        public void Should_sum_one_subsequent_roll_if_spare(
			int first,
			int second,
			int third,
			int total)
        {
            // Arrange
            var scorer = new Scorer();

            // Act
            scorer.Roll(first);
            scorer.Roll(second);
            scorer.Roll(third);
            var score = scorer.CalculateScore();

            // Assert
            score.Should().Be(total);
        }
コード例 #7
0
        public void Should_return_300_for_the_perfect_game()
        {
            // Arrange
            var scorer = new Scorer();

            // Act
            for (int i = 0; i < 12; i++)
            {
                scorer.Roll(10);
            }
            var score = scorer.CalculateScore();

            // Assert
            score.Should().Be(300);
        }
コード例 #8
0
        public void Should_allow_only_20_rolls()
        {
            // Arrange
            var scorer = new Scorer();

            // Act
            for (int i = 0; i < 20; i++)
            {
                scorer.Roll(1);
            }

            // Assert
            scorer.Invoking(s => s.Roll(1)).ShouldThrow<MaxNumberOfRollsExceededException>("sdf")
                  .And.Message.Should().Be("Maximum number of rolls exceeded", "Message should be meaningful");
        }
コード例 #9
0
        public void Should_sum_two_subsequent_rolls_if_triple()
        {
            // Arrange
            var scorer = new Scorer();

            // Act
            scorer.Roll(10);
            scorer.Roll(10);
            scorer.Roll(10);
            scorer.Roll(2);
            scorer.Roll(2);
            scorer.Roll(2);
            var score = scorer.CalculateScore();

            // Assert
            score.Should().Be(72);
        }
コード例 #10
0
        public void Should_sum_two_subsequent_rolls_if_strike_at_the_beggining_of_the_game()
        {
            // Arrange
            var scorer = new Scorer();

            // Act
            scorer.Roll(10);
            scorer.Roll(2);
            scorer.Roll(2);
            var score = scorer.CalculateScore();

            // Assert
            score.Should().Be(18);
        }