Skip to content

Commit cdb3aff

Browse files
samuelfacSamuel Facchinellovil02
authored
style: enable AvoidNestedBlocks in checkstyle (#5228)
* enable style AvoidNestedBlocks * refactor after enable style AvoidNestedBlocks * fix clang * fix checkstyle * fix pmd --------- Co-authored-by: Samuel Facchinello <[email protected]> Co-authored-by: Piotr Idzik <[email protected]>
1 parent 87b17e0 commit cdb3aff

File tree

7 files changed

+117
-117
lines changed

7 files changed

+117
-117
lines changed

‎checkstyle.xml

+1-1
Original file line numberDiff line numberDiff line change
@@ -152,7 +152,7 @@
152152

153153
<!-- Checks for blocks. You know, those {}'s -->
154154
<!-- See https://checkstyle.org/checks/blocks/index.html -->
155-
<!-- TODO <module name="AvoidNestedBlocks"/> -->
155+
<module name="AvoidNestedBlocks"/>
156156
<!-- TODO <module name="EmptyBlock"/> -->
157157
<!-- TODO <module name="LeftCurly"/> -->
158158
<module name="NeedBraces"/>

‎src/main/java/com/thealgorithms/datastructures/hashmap/hashing/Main.java

+9-10
Original file line numberDiff line numberDiff line change
@@ -23,31 +23,30 @@ public static void main(String[] args) {
2323
choice = scan.nextInt();
2424

2525
switch (choice) {
26-
case 1: {
26+
case 1:
2727
System.out.println("Enter the Key: ");
2828
key = scan.nextInt();
2929
h.insertHash(key);
3030
break;
31-
}
32-
case 2: {
31+
32+
case 2:
3333
System.out.println("Enter the Key delete: ");
3434
key = scan.nextInt();
3535
h.deleteHash(key);
3636
break;
37-
}
38-
case 3: {
37+
38+
case 3:
3939
System.out.println("Print table");
4040
h.displayHashtable();
4141
break;
42-
}
43-
case 4: {
42+
43+
case 4:
4444
scan.close();
4545
return;
46-
}
47-
default: {
46+
47+
default:
4848
throw new IllegalArgumentException("Unexpected value: " + choice);
4949
}
50-
}
5150
}
5251
}
5352
}

‎src/main/java/com/thealgorithms/datastructures/hashmap/hashing/MainCuckooHashing.java

+15-16
Original file line numberDiff line numberDiff line change
@@ -27,45 +27,44 @@ public static void main(String[] args) {
2727
choice = scan.nextInt();
2828

2929
switch (choice) {
30-
case 1: {
30+
case 1:
3131
System.out.println("Enter the Key: ");
3232
key = scan.nextInt();
3333
h.insertKey2HashTable(key);
3434
break;
35-
}
36-
case 2: {
35+
36+
case 2:
3737
System.out.println("Enter the Key delete: ");
3838
key = scan.nextInt();
3939
h.deleteKeyFromHashTable(key);
4040
break;
41-
}
42-
case 3: {
41+
42+
case 3:
4343
System.out.println("Print table:\n");
4444
h.displayHashtable();
4545
break;
46-
}
47-
case 4: {
46+
47+
case 4:
4848
scan.close();
4949
return;
50-
}
51-
case 5: {
50+
51+
case 5:
5252
System.out.println("Enter the Key to find and print: ");
5353
key = scan.nextInt();
5454
System.out.println("Key: " + key + " is at index: " + h.findKeyInTable(key) + "\n");
5555
break;
56-
}
57-
case 6: {
56+
57+
case 6:
5858
System.out.printf("Load factor is: %.2f%n", h.checkLoadFactor());
5959
break;
60-
}
61-
case 7: {
60+
61+
case 7:
6262
h.reHashTableIncreasesTableSize();
6363
break;
64-
}
65-
default: {
64+
65+
default:
6666
throw new IllegalArgumentException("Unexpected value: " + choice);
6767
}
68-
}
6968
}
7069
}
7170
}

‎src/main/java/com/thealgorithms/maths/MatrixUtil.java

+4-80
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
package com.thealgorithms.maths;
22

33
import java.math.BigDecimal;
4-
import java.util.Arrays;
5-
import java.util.Objects;
64
import java.util.Optional;
75
import java.util.function.BiFunction;
86
import java.util.stream.IntStream;
@@ -15,19 +13,19 @@ public final class MatrixUtil {
1513
private MatrixUtil() {
1614
}
1715

18-
public static boolean isValid(final BigDecimal[][] matrix) {
16+
private static boolean isValid(final BigDecimal[][] matrix) {
1917
return matrix != null && matrix.length > 0 && matrix[0].length > 0;
2018
}
2119

22-
public static boolean hasEqualSizes(final BigDecimal[][] matrix1, final BigDecimal[][] matrix2) {
20+
private static boolean hasEqualSizes(final BigDecimal[][] matrix1, final BigDecimal[][] matrix2) {
2321
return (isValid(matrix1) && isValid(matrix2) && matrix1.length == matrix2.length && matrix1[0].length == matrix2[0].length);
2422
}
2523

26-
public static boolean canMultiply(final BigDecimal[][] matrix1, final BigDecimal[][] matrix2) {
24+
private static boolean canMultiply(final BigDecimal[][] matrix1, final BigDecimal[][] matrix2) {
2725
return (isValid(matrix1) && isValid(matrix2) && matrix1[0].length == matrix2.length);
2826
}
2927

30-
public static Optional<BigDecimal[][]> operate(final BigDecimal[][] matrix1, final BigDecimal[][] matrix2, final BiFunction<BigDecimal, BigDecimal, BigDecimal> operation) {
28+
private static Optional<BigDecimal[][]> operate(final BigDecimal[][] matrix1, final BigDecimal[][] matrix2, final BiFunction<BigDecimal, BigDecimal, BigDecimal> operation) {
3129
if (!hasEqualSizes(matrix1, matrix2)) {
3230
return Optional.empty();
3331
}
@@ -82,78 +80,4 @@ public static Optional<BigDecimal[][]> multiply(final BigDecimal[][] matrix1, fi
8280

8381
return Optional.of(result);
8482
}
85-
86-
public static void assertThat(final BigDecimal[][] actual, final BigDecimal[][] expected) {
87-
if (!Objects.deepEquals(actual, expected)) {
88-
throw new AssertionError(String.format("expected=%s but was actual=%s", Arrays.deepToString(expected), Arrays.deepToString(actual)));
89-
}
90-
}
91-
92-
public static void main(final String[] args) {
93-
{
94-
final BigDecimal[][] matrix1 = {
95-
{new BigDecimal(3), new BigDecimal(2)},
96-
{new BigDecimal(0), new BigDecimal(1)},
97-
};
98-
99-
final BigDecimal[][] matrix2 = {
100-
{new BigDecimal(1), new BigDecimal(3)},
101-
{new BigDecimal(2), new BigDecimal(0)},
102-
};
103-
104-
final BigDecimal[][] actual = add(matrix1, matrix2).orElseThrow(() -> new AssertionError("Could not compute matrix!"));
105-
106-
final BigDecimal[][] expected = {
107-
{new BigDecimal(4), new BigDecimal(5)},
108-
{new BigDecimal(2), new BigDecimal(1)},
109-
};
110-
111-
assertThat(actual, expected);
112-
}
113-
114-
{
115-
final BigDecimal[][] matrix1 = {
116-
{new BigDecimal(1), new BigDecimal(4)},
117-
{new BigDecimal(5), new BigDecimal(6)},
118-
};
119-
120-
final BigDecimal[][] matrix2 = {
121-
{new BigDecimal(2), new BigDecimal(0)},
122-
{new BigDecimal(-2), new BigDecimal(-3)},
123-
};
124-
125-
final BigDecimal[][] actual = subtract(matrix1, matrix2).orElseThrow(() -> new AssertionError("Could not compute matrix!"));
126-
127-
final BigDecimal[][] expected = {
128-
{new BigDecimal(-1), new BigDecimal(4)},
129-
{new BigDecimal(7), new BigDecimal(9)},
130-
};
131-
132-
assertThat(actual, expected);
133-
}
134-
135-
{
136-
final BigDecimal[][] matrix1 = {
137-
{new BigDecimal(1), new BigDecimal(2), new BigDecimal(3)},
138-
{new BigDecimal(4), new BigDecimal(5), new BigDecimal(6)},
139-
{new BigDecimal(7), new BigDecimal(8), new BigDecimal(9)},
140-
};
141-
142-
final BigDecimal[][] matrix2 = {
143-
{new BigDecimal(1), new BigDecimal(2)},
144-
{new BigDecimal(3), new BigDecimal(4)},
145-
{new BigDecimal(5), new BigDecimal(6)},
146-
};
147-
148-
final BigDecimal[][] actual = multiply(matrix1, matrix2).orElseThrow(() -> new AssertionError("Could not compute matrix!"));
149-
150-
final BigDecimal[][] expected = {
151-
{new BigDecimal(22), new BigDecimal(28)},
152-
{new BigDecimal(49), new BigDecimal(64)},
153-
{new BigDecimal(76), new BigDecimal(100)},
154-
};
155-
156-
assertThat(actual, expected);
157-
}
158-
}
15983
}

‎src/main/java/com/thealgorithms/misc/Sort012D.java

+5-6
Original file line numberDiff line numberDiff line change
@@ -33,28 +33,27 @@ public static void sort012(int[] a) {
3333
int temp;
3434
while (mid <= h) {
3535
switch (a[mid]) {
36-
case 0: {
36+
case 0:
3737
temp = a[l];
3838
a[l] = a[mid];
3939
a[mid] = temp;
4040
l++;
4141
mid++;
4242
break;
43-
}
43+
4444
case 1:
4545
mid++;
4646
break;
47-
case 2: {
47+
case 2:
4848
temp = a[mid];
4949
a[mid] = a[h];
5050
a[h] = temp;
5151
h--;
5252
break;
53-
}
54-
default: {
53+
54+
default:
5555
throw new IllegalArgumentException("Unexpected value: " + a[mid]);
5656
}
57-
}
5857
}
5958
System.out.println("the Sorted array is ");
6059
for (int i = 0; i < a.length; i++) {

‎src/main/java/com/thealgorithms/sorts/DNFSort.java

+4-4
Original file line numberDiff line numberDiff line change
@@ -13,24 +13,24 @@ static void sort012(int[] a, int arrSize) {
1313
int temp;
1414
while (mid <= high) {
1515
switch (a[mid]) {
16-
case 0: {
16+
case 0:
1717
temp = a[low];
1818
a[low] = a[mid];
1919
a[mid] = temp;
2020
low++;
2121
mid++;
2222
break;
23-
}
23+
2424
case 1:
2525
mid++;
2626
break;
27-
case 2: {
27+
case 2:
2828
temp = a[mid];
2929
a[mid] = a[high];
3030
a[high] = temp;
3131
high--;
3232
break;
33-
}
33+
3434
default:
3535
throw new IllegalArgumentException("Unexpected value: " + a[mid]);
3636
}

‎src/test/java/com/thealgorithms/maths/MatrixUtilTest.java

+79
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,79 @@
1+
package com.thealgorithms.maths;
2+
3+
import static org.junit.jupiter.api.Assertions.assertTrue;
4+
5+
import java.math.BigDecimal;
6+
import java.util.Objects;
7+
import org.junit.jupiter.api.Test;
8+
9+
class MatrixUtilTest {
10+
11+
@Test
12+
void add() {
13+
final BigDecimal[][] matrix1 = {
14+
{new BigDecimal(3), new BigDecimal(2)},
15+
{BigDecimal.ZERO, BigDecimal.ONE},
16+
};
17+
18+
final BigDecimal[][] matrix2 = {
19+
{BigDecimal.ONE, new BigDecimal(3)},
20+
{new BigDecimal(2), BigDecimal.ZERO},
21+
};
22+
23+
final BigDecimal[][] actual = MatrixUtil.add(matrix1, matrix2).orElseThrow(() -> new AssertionError("Could not compute matrix!"));
24+
25+
final BigDecimal[][] expected = {
26+
{new BigDecimal(4), new BigDecimal(5)},
27+
{new BigDecimal(2), BigDecimal.ONE},
28+
};
29+
30+
assertTrue(Objects.deepEquals(actual, expected));
31+
}
32+
@Test
33+
void subtract() {
34+
final BigDecimal[][] matrix1 = {
35+
{BigDecimal.ONE, new BigDecimal(4)},
36+
{new BigDecimal(5), new BigDecimal(6)},
37+
};
38+
39+
final BigDecimal[][] matrix2 = {
40+
{new BigDecimal(2), BigDecimal.ZERO},
41+
{new BigDecimal(-2), new BigDecimal(-3)},
42+
};
43+
44+
final BigDecimal[][] actual = MatrixUtil.subtract(matrix1, matrix2).orElseThrow(() -> new AssertionError("Could not compute matrix!"));
45+
46+
final BigDecimal[][] expected = {
47+
{new BigDecimal(-1), new BigDecimal(4)},
48+
{new BigDecimal(7), new BigDecimal(9)},
49+
};
50+
51+
assertTrue(Objects.deepEquals(actual, expected));
52+
}
53+
54+
@Test
55+
void multiply() {
56+
57+
final BigDecimal[][] matrix1 = {
58+
{BigDecimal.ONE, new BigDecimal(2), new BigDecimal(3)},
59+
{new BigDecimal(4), new BigDecimal(5), new BigDecimal(6)},
60+
{new BigDecimal(7), new BigDecimal(8), new BigDecimal(9)},
61+
};
62+
63+
final BigDecimal[][] matrix2 = {
64+
{BigDecimal.ONE, new BigDecimal(2)},
65+
{new BigDecimal(3), new BigDecimal(4)},
66+
{new BigDecimal(5), new BigDecimal(6)},
67+
};
68+
69+
final BigDecimal[][] actual = MatrixUtil.multiply(matrix1, matrix2).orElseThrow(() -> new AssertionError("Could not compute matrix!"));
70+
71+
final BigDecimal[][] expected = {
72+
{new BigDecimal(22), new BigDecimal(28)},
73+
{new BigDecimal(49), new BigDecimal(64)},
74+
{new BigDecimal(76), new BigDecimal(100)},
75+
};
76+
77+
assertTrue(Objects.deepEquals(actual, expected));
78+
}
79+
}

0 commit comments

Comments
 (0)