Java/src/test/java/com/thealgorithms/maths/LucasSeriesTest.java at master · TheAlgorithms/Java · 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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
packagecom.thealgorithms.maths;

importstaticorg.junit.jupiter.api.Assertions.assertEquals;
importstaticorg.junit.jupiter.api.Assertions.assertThrows;

importorg.junit.jupiter.api.Test;

/**
 * Test cases for {@link LucasSeries} class.
 * Tests both recursive and iterative implementations for correctness,
 * edge cases, and error handling.
 */
classLucasSeriesTest {

/**
 * Test the first Lucas number L(1) = 2
 */
@Test
voidtestFirstLucasNumber() {
assertEquals(2, LucasSeries.lucasSeries(1));
assertEquals(2, LucasSeries.lucasSeriesIteration(1));
 }

/**
 * Test the second Lucas number L(2) = 1
 */
@Test
voidtestSecondLucasNumber() {
assertEquals(1, LucasSeries.lucasSeries(2));
assertEquals(1, LucasSeries.lucasSeriesIteration(2));
 }

/**
 * Test the third Lucas number L(3) = 3
 */
@Test
voidtestThirdLucasNumber() {
assertEquals(3, LucasSeries.lucasSeries(3));
assertEquals(3, LucasSeries.lucasSeriesIteration(3));
 }

/**
 * Test the fourth Lucas number L(4) = 4
 */
@Test
voidtestFourthLucasNumber() {
assertEquals(4, LucasSeries.lucasSeries(4));
assertEquals(4, LucasSeries.lucasSeriesIteration(4));
 }

/**
 * Test the fifth Lucas number L(5) = 7
 */
@Test
voidtestFifthLucasNumber() {
assertEquals(7, LucasSeries.lucasSeries(5));
assertEquals(7, LucasSeries.lucasSeriesIteration(5));
 }

/**
 * Test the sixth Lucas number L(6) = 11
 */
@Test
voidtestSixthLucasNumber() {
assertEquals(11, LucasSeries.lucasSeries(6));
assertEquals(11, LucasSeries.lucasSeriesIteration(6));
 }

/**
 * Test the seventh Lucas number L(7) = 18
 */
@Test
voidtestSeventhLucasNumber() {
assertEquals(18, LucasSeries.lucasSeries(7));
assertEquals(18, LucasSeries.lucasSeriesIteration(7));
 }

/**
 * Test the eighth Lucas number L(8) = 29
 */
@Test
voidtestEighthLucasNumber() {
assertEquals(29, LucasSeries.lucasSeries(8));
assertEquals(29, LucasSeries.lucasSeriesIteration(8));
 }

/**
 * Test the ninth Lucas number L(9) = 47
 */
@Test
voidtestNinthLucasNumber() {
assertEquals(47, LucasSeries.lucasSeries(9));
assertEquals(47, LucasSeries.lucasSeriesIteration(9));
 }

/**
 * Test the tenth Lucas number L(10) = 76
 */
@Test
voidtestTenthLucasNumber() {
assertEquals(76, LucasSeries.lucasSeries(10));
assertEquals(76, LucasSeries.lucasSeriesIteration(10));
 }

/**
 * Test the eleventh Lucas number L(11) = 123
 */
@Test
voidtestEleventhLucasNumber() {
assertEquals(123, LucasSeries.lucasSeries(11));
assertEquals(123, LucasSeries.lucasSeriesIteration(11));
 }

/**
 * Test larger Lucas numbers to ensure correctness
 */
@Test
voidtestLargerLucasNumbers() {
assertEquals(199, LucasSeries.lucasSeries(12));
assertEquals(199, LucasSeries.lucasSeriesIteration(12));
assertEquals(322, LucasSeries.lucasSeries(13));
assertEquals(322, LucasSeries.lucasSeriesIteration(13));
assertEquals(521, LucasSeries.lucasSeries(14));
assertEquals(521, LucasSeries.lucasSeriesIteration(14));
assertEquals(843, LucasSeries.lucasSeries(15));
assertEquals(843, LucasSeries.lucasSeriesIteration(15));
 }

/**
 * Test that both methods produce the same results
 */
@Test
voidtestRecursiveAndIterativeConsistency() {
for (inti = 1; i <= 15; i++) {
assertEquals(LucasSeries.lucasSeries(i), LucasSeries.lucasSeriesIteration(i), "Mismatch at position " + i);
 }
 }

/**
 * Test invalid input: zero
 */
@Test
voidtestZeroInputThrowsException() {
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeries(0));
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeriesIteration(0));
 }

/**
 * Test invalid input: negative number
 */
@Test
voidtestNegativeInputThrowsException() {
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeries(-1));
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeriesIteration(-1));
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeries(-5));
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeriesIteration(-5));
 }
}