CopilotHackathon/cpp/01-commands/explain/LifeGame/GridTest.cpp at main · Cellenza/CopilotHackathon · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#include "pch.h"
#include "CppUnitTest.h"
#include "Grid.h"

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

namespace LifeGame
{
	TEST_CLASS(GridTest)
	{
	public:

		TEST_METHOD(WhenCreatingGridWithoutColumn_ExceptionIsThrown)
		{
			// Arrange
			const int numberOfLines = 1;
			const std::vector<Cell> cells = { Cell(1, 1) };

			// Act
			auto action0 = [&] { Grid grid(0, numberOfLines, cells); };
			auto action1 = [&] { Grid grid(-1, numberOfLines, cells); };

			// Assert
			Assert::ExpectException<std::invalid_argument>(action0);
			Assert::ExpectException<std::invalid_argument>(action1);
		}

		TEST_METHOD(WhenCreatingGridWithoutLine_ExceptionIsThrown)
		{
            // Arrange
            const int numberOfColumns = 1;
            const std::vector<Cell> cells = { Cell(1, 1) };

            // Act
            auto action0 = [&] { Grid grid(numberOfColumns, 0, cells); };
            auto action1 = [&] { Grid grid(numberOfColumns, -1, cells); };

            // Assert
            Assert::ExpectException<std::invalid_argument>(action0);
            Assert::ExpectException<std::invalid_argument>(action1);
        }

		TEST_METHOD(WhenCreatingGrid1x1_GridWithOneColumnAndOneLineIsCreated)
		{
            // Arrange
            const int numberOfColumns = 1;
            const int numberOfLines = 1;
            const std::vector<Cell> cells = { Cell(1, 1) };

            // Act
            Grid grid(numberOfColumns, numberOfLines, cells);

            // Assert
            Assert::AreEqual(numberOfColumns, grid.NumberOfColumns());
            Assert::AreEqual(numberOfLines, grid.NumberOfLines());
			Assert::IsFalse(grid.IsEmpty());
        }

		TEST_METHOD(WhenCellHas2Neighbours_ItIsAliveNextRound)
		{
            // Arrange
            const int numberOfColumns = 2;
            const int numberOfLines = 2;
            const std::vector<Cell> cells = { Cell(1, 1), Cell(1, 2), Cell(2, 1) };
            Grid grid(numberOfColumns, numberOfLines, cells);

            // Act
            Grid nextGrid = grid.NextState();

            // Assert
            Assert::IsTrue(nextGrid.IsCellAliveAtThisPosition(1, 1));
            Assert::IsTrue(nextGrid.IsCellAliveAtThisPosition(1, 2));
            Assert::IsTrue(nextGrid.IsCellAliveAtThisPosition(2, 1));
        }

        TEST_METHOD(WhenCellHas1Neighbor_ItIsDeadNextRound)
        {
            // Arrange
            const int numberOfColumns = 2;
            const int numberOfLines = 2;
            const std::vector<Cell> cells = { Cell(1, 1), Cell(1, 2) };
            Grid grid(numberOfColumns, numberOfLines, cells);

            // Act
            Grid nextGrid = grid.NextState();

            // Assert
            Assert::IsFalse(nextGrid.IsCellAliveAtThisPosition(1, 1));
            Assert::IsFalse(nextGrid.IsCellAliveAtThisPosition(1, 2));
            Assert::IsFalse(nextGrid.IsCellAliveAtThisPosition(2, 1));
            Assert::IsFalse(nextGrid.IsCellAliveAtThisPosition(2, 2));
        }

        TEST_METHOD(WhenCellHasMoreThan3Neighbors_ItIsDeadNextRound)
        {
            // Arrange
            //X X
            //X X
            //  X
            const int numberOfColumns = 2;
            const int numberOfLines = 3;
            const std::vector<Cell> cells = { Cell(1, 1), Cell(1, 2), Cell(2, 1), Cell(2, 2), Cell(2, 3) };
            Grid grid(numberOfColumns, numberOfLines, cells);

            // Act
            Grid nextGrid = grid.NextState();

            // Assert
            Assert::IsTrue (nextGrid.IsCellAliveAtThisPosition(1, 1));
            Assert::IsFalse(nextGrid.IsCellAliveAtThisPosition(1, 2));
            Assert::IsTrue (nextGrid.IsCellAliveAtThisPosition(2, 1));
            Assert::IsFalse(nextGrid.IsCellAliveAtThisPosition(2, 2));
            Assert::IsTrue (nextGrid.IsCellAliveAtThisPosition(2, 3));
        }

        TEST_METHOD(WhenCellHas3Neighbors_ItComesToLifeNextRound)
        {
            // Arrange
            const int numberOfColumns = 2;
            const int numberOfLines = 2;
            const std::vector<Cell> cells = { Cell(1, 1), Cell(1, 2), Cell(2, 1) };
            Grid grid(numberOfColumns, numberOfLines, cells);

            // Act
            Grid nextGrid = grid.NextState();

            // Assert
            Assert::IsTrue(nextGrid.IsCellAliveAtThisPosition(1, 1));
            Assert::IsTrue(nextGrid.IsCellAliveAtThisPosition(1, 2));
            Assert::IsTrue(nextGrid.IsCellAliveAtThisPosition(2, 1));
            Assert::IsTrue(nextGrid.IsCellAliveAtThisPosition(2, 2));
        }
	};
}