Skip to content

Commit b153c84

Browse files
HardvanHardvan
committed
Fix lint
1 parent c8a4dc1 commit b153c84

File tree

1 file changed

+75
-69
lines changed

1 file changed

+75
-69
lines changed

‎src/test/java/com/thealgorithms/others/HuffmanTest.java‎

Lines changed: 75 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,7 @@
11
package com.thealgorithms.others;
22

3-
import static org.junit.jupiter.api.Assertions.assertEquals;
4-
import static org.junit.jupiter.api.Assertions.assertNotEquals;
5-
import static org.junit.jupiter.api.Assertions.assertNotNull;
6-
import static org.junit.jupiter.api.Assertions.assertThrows;
7-
import static org.junit.jupiter.api.Assertions.assertTrue;
8-
93
import java.util.Map;
4+
import org.junit.jupiter.api.Assertions;
105
import org.junit.jupiter.api.Test;
116

127
/**
@@ -18,167 +13,177 @@ class HuffmanTest {
1813

1914
@Test
2015
void testBuildHuffmanTreeWithBasicInput() {
21-
char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f'};
22-
int[] charFreq = {5, 9, 12, 13, 16, 45};
16+
char[] charArray = { 'a', 'b', 'c', 'd', 'e', 'f' };
17+
int[] charFreq = { 5, 9, 12, 13, 16, 45 };
2318

2419
HuffmanNode root = Huffman.buildHuffmanTree(charArray, charFreq);
2520

26-
assertNotNull(root);
27-
assertEquals(100, root.data); // Total frequency
21+
Assertions.assertNotNull(root);
22+
Assertions.assertEquals(100, root.data); // Total frequency
2823
}
2924

3025
@Test
3126
void testGenerateCodesWithBasicInput() {
32-
char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f'};
33-
int[] charFreq = {5, 9, 12, 13, 16, 45};
27+
char[] charArray = { 'a', 'b', 'c', 'd', 'e', 'f' };
28+
int[] charFreq = { 5, 9, 12, 13, 16, 45 };
3429

3530
HuffmanNode root = Huffman.buildHuffmanTree(charArray, charFreq);
3631
Map<Character, String> codes = Huffman.generateCodes(root);
3732

38-
assertNotNull(codes);
39-
assertEquals(6, codes.size());
33+
Assertions.assertNotNull(codes);
34+
Assertions.assertEquals(6, codes.size());
4035

4136
// Verify that all characters have codes
4237
for (char c : charArray) {
43-
assertTrue(codes.containsKey(c), "Missing code for character: " + c);
44-
assertNotNull(codes.get(c), "Null code for character: " + c);
38+
Assertions.assertTrue(codes.containsKey(c), "Missing code for character: " + c);
39+
Assertions.assertNotNull(codes.get(c), "Null code for character: " + c);
4540
}
4641

4742
// Verify that higher frequency characters have shorter codes
4843
// 'f' has the highest frequency (45), so it should have one of the shortest
4944
// codes
50-
assertTrue(codes.get('f').length() <= codes.get('a').length());
45+
Assertions.assertTrue(codes.get('f').length() <= codes.get('a').length());
5146
}
5247

5348
@Test
5449
void testSingleCharacter() {
55-
char[] charArray = {'a'};
56-
int[] charFreq = {10};
50+
char[] charArray = { 'a' };
51+
int[] charFreq = { 10 };
5752

5853
HuffmanNode root = Huffman.buildHuffmanTree(charArray, charFreq);
5954
Map<Character, String> codes = Huffman.generateCodes(root);
6055

61-
assertNotNull(codes);
62-
assertEquals(1, codes.size());
63-
assertEquals("0", codes.get('a')); // Single character gets code "0"
56+
Assertions.assertNotNull(codes);
57+
Assertions.assertEquals(1, codes.size());
58+
Assertions.assertEquals("0", codes.get('a')); // Single character gets code "0"
6459
}
6560

6661
@Test
6762
void testTwoCharacters() {
68-
char[] charArray = {'a', 'b'};
69-
int[] charFreq = {3, 7};
63+
char[] charArray = { 'a', 'b' };
64+
int[] charFreq = { 3, 7 };
7065

7166
HuffmanNode root = Huffman.buildHuffmanTree(charArray, charFreq);
7267
Map<Character, String> codes = Huffman.generateCodes(root);
7368

74-
assertNotNull(codes);
75-
assertEquals(2, codes.size());
69+
Assertions.assertNotNull(codes);
70+
Assertions.assertEquals(2, codes.size());
7671

7772
// Verify both characters have codes
78-
assertTrue(codes.containsKey('a'));
79-
assertTrue(codes.containsKey('b'));
73+
Assertions.assertTrue(codes.containsKey('a'));
74+
Assertions.assertTrue(codes.containsKey('b'));
8075

8176
// Verify codes are different
82-
assertNotEquals(codes.get('a'), codes.get('b'));
77+
Assertions.assertNotEquals(codes.get('a'), codes.get('b'));
8378
}
8479

8580
@Test
8681
void testEqualFrequencies() {
87-
char[] charArray = {'a', 'b', 'c'};
88-
int[] charFreq = {5, 5, 5};
82+
char[] charArray = { 'a', 'b', 'c' };
83+
int[] charFreq = { 5, 5, 5 };
8984

9085
HuffmanNode root = Huffman.buildHuffmanTree(charArray, charFreq);
9186
Map<Character, String> codes = Huffman.generateCodes(root);
9287

93-
assertNotNull(codes);
94-
assertEquals(3, codes.size());
88+
Assertions.assertNotNull(codes);
89+
Assertions.assertEquals(3, codes.size());
9590

9691
// Verify all characters have codes
9792
for (char c : charArray) {
98-
assertTrue(codes.containsKey(c));
93+
Assertions.assertTrue(codes.containsKey(c));
9994
}
10095
}
10196

10297
@Test
10398
void testLargeFrequencyDifference() {
104-
char[] charArray = {'a', 'b', 'c'};
105-
int[] charFreq = {1, 10, 100};
99+
char[] charArray = { 'a', 'b', 'c' };
100+
int[] charFreq = { 1, 10, 100 };
106101

107102
HuffmanNode root = Huffman.buildHuffmanTree(charArray, charFreq);
108103
Map<Character, String> codes = Huffman.generateCodes(root);
109104

110-
assertNotNull(codes);
111-
assertEquals(3, codes.size());
105+
Assertions.assertNotNull(codes);
106+
Assertions.assertEquals(3, codes.size());
112107

113108
// Character 'c' with highest frequency should have shortest code
114-
assertTrue(codes.get('c').length() <= codes.get('b').length());
115-
assertTrue(codes.get('c').length() <= codes.get('a').length());
109+
Assertions.assertTrue(codes.get('c').length() <= codes.get('b').length());
110+
Assertions.assertTrue(codes.get('c').length() <= codes.get('a').length());
116111
}
117112

118113
@Test
119114
void testNullCharacterArray() {
120-
int[] charFreq = {5, 9, 12};
115+
int[] charFreq = { 5, 9, 12 };
121116

122-
assertThrows(IllegalArgumentException.class, () -> { Huffman.buildHuffmanTree(null, charFreq); });
117+
Assertions.assertThrows(IllegalArgumentException.class, () -> {
118+
Huffman.buildHuffmanTree(null, charFreq);
119+
});
123120
}
124121

125122
@Test
126123
void testNullFrequencyArray() {
127-
char[] charArray = {'a', 'b', 'c'};
124+
char[] charArray = { 'a', 'b', 'c' };
128125

129-
assertThrows(IllegalArgumentException.class, () -> { Huffman.buildHuffmanTree(charArray, null); });
126+
Assertions.assertThrows(IllegalArgumentException.class, () -> {
127+
Huffman.buildHuffmanTree(charArray, null);
128+
});
130129
}
131130

132131
@Test
133132
void testEmptyArrays() {
134133
char[] charArray = {};
135134
int[] charFreq = {};
136135

137-
assertThrows(IllegalArgumentException.class, () -> { Huffman.buildHuffmanTree(charArray, charFreq); });
136+
Assertions.assertThrows(IllegalArgumentException.class, () -> {
137+
Huffman.buildHuffmanTree(charArray, charFreq);
138+
});
138139
}
139140

140141
@Test
141142
void testMismatchedArrayLengths() {
142-
char[] charArray = {'a', 'b', 'c'};
143-
int[] charFreq = {5, 9};
143+
char[] charArray = { 'a', 'b', 'c' };
144+
int[] charFreq = { 5, 9 };
144145

145-
assertThrows(IllegalArgumentException.class, () -> { Huffman.buildHuffmanTree(charArray, charFreq); });
146+
Assertions.assertThrows(IllegalArgumentException.class, () -> {
147+
Huffman.buildHuffmanTree(charArray, charFreq);
148+
});
146149
}
147150

148151
@Test
149152
void testNegativeFrequency() {
150-
char[] charArray = {'a', 'b', 'c'};
151-
int[] charFreq = {5, -9, 12};
153+
char[] charArray = { 'a', 'b', 'c' };
154+
int[] charFreq = { 5, -9, 12 };
152155

153-
assertThrows(IllegalArgumentException.class, () -> { Huffman.buildHuffmanTree(charArray, charFreq); });
156+
Assertions.assertThrows(IllegalArgumentException.class, () -> {
157+
Huffman.buildHuffmanTree(charArray, charFreq);
158+
});
154159
}
155160

156161
@Test
157162
void testZeroFrequency() {
158-
char[] charArray = {'a', 'b', 'c'};
159-
int[] charFreq = {0, 5, 10};
163+
char[] charArray = { 'a', 'b', 'c' };
164+
int[] charFreq = { 0, 5, 10 };
160165

161166
HuffmanNode root = Huffman.buildHuffmanTree(charArray, charFreq);
162167
Map<Character, String> codes = Huffman.generateCodes(root);
163168

164-
assertNotNull(codes);
165-
assertEquals(3, codes.size());
166-
assertTrue(codes.containsKey('a')); // Even with 0 frequency, character should have a code
169+
Assertions.assertNotNull(codes);
170+
Assertions.assertEquals(3, codes.size());
171+
Assertions.assertTrue(codes.containsKey('a')); // Even with 0 frequency, character should have a code
167172
}
168173

169174
@Test
170175
void testGenerateCodesWithNullRoot() {
171176
Map<Character, String> codes = Huffman.generateCodes(null);
172177

173-
assertNotNull(codes);
174-
assertTrue(codes.isEmpty());
178+
Assertions.assertNotNull(codes);
179+
Assertions.assertTrue(codes.isEmpty());
175180
}
176181

177182
@Test
178183
void testPrefixProperty() {
179184
// Verify that no code is a prefix of another (Huffman property)
180-
char[] charArray = {'a', 'b', 'c', 'd', 'e'};
181-
int[] charFreq = {5, 9, 12, 13, 16};
185+
char[] charArray = { 'a', 'b', 'c', 'd', 'e' };
186+
int[] charFreq = { 5, 9, 12, 13, 16 };
182187

183188
HuffmanNode root = Huffman.buildHuffmanTree(charArray, charFreq);
184189
Map<Character, String> codes = Huffman.generateCodes(root);
@@ -189,7 +194,8 @@ void testPrefixProperty() {
189194
if (!entry1.getKey().equals(entry2.getKey())) {
190195
String code1 = entry1.getValue();
191196
String code2 = entry2.getValue();
192-
assertTrue(!code1.startsWith(code2) && !code2.startsWith(code1), "Code " + code1 + " is a prefix of " + code2);
197+
Assertions.assertTrue(!code1.startsWith(code2) && !code2.startsWith(code1),
198+
"Code " + code1 + " is a prefix of " + code2);
193199
}
194200
}
195201
}
@@ -198,31 +204,31 @@ void testPrefixProperty() {
198204
@Test
199205
void testBinaryCodesOnly() {
200206
// Verify that all codes contain only '0' and '1'
201-
char[] charArray = {'a', 'b', 'c', 'd'};
202-
int[] charFreq = {1, 2, 3, 4};
207+
char[] charArray = { 'a', 'b', 'c', 'd' };
208+
int[] charFreq = { 1, 2, 3, 4 };
203209

204210
HuffmanNode root = Huffman.buildHuffmanTree(charArray, charFreq);
205211
Map<Character, String> codes = Huffman.generateCodes(root);
206212

207213
for (String code : codes.values()) {
208-
assertTrue(code.matches("[01]+"), "Code contains non-binary characters: " + code);
214+
Assertions.assertTrue(code.matches("[01]+"), "Code contains non-binary characters: " + code);
209215
}
210216
}
211217

212218
@Test
213219
void testMultipleCharactersWithLargeAlphabet() {
214-
char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
215-
int[] charFreq = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
220+
char[] charArray = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' };
221+
int[] charFreq = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };
216222

217223
HuffmanNode root = Huffman.buildHuffmanTree(charArray, charFreq);
218224
Map<Character, String> codes = Huffman.generateCodes(root);
219225

220-
assertNotNull(codes);
221-
assertEquals(10, codes.size());
226+
Assertions.assertNotNull(codes);
227+
Assertions.assertEquals(10, codes.size());
222228

223229
// Verify all characters have codes
224230
for (char c : charArray) {
225-
assertTrue(codes.containsKey(c));
231+
Assertions.assertTrue(codes.containsKey(c));
226232
}
227233
}
228234
}

0 commit comments

Comments
 (0)