Skip to content

Commit b1f5b83

Browse files
JavaSaBrJavaSaBr
committed
update unit tests
1 parent ea32ddb commit b1f5b83

File tree

13 files changed

+893
-66
lines changed

13 files changed

+893
-66
lines changed

‎buildSrc/src/main/groovy/configure-java.gradle‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,7 @@ dependencies {
5757
testImplementation libs.mockito.junit.jupiter
5858
testImplementation libs.junit.api
5959
testImplementation libs.junit.jupiter.params
60+
testImplementation libs.assertj.core
6061

6162
testCompileOnly libs.lombok
6263
testCompileOnly libs.jspecify

‎gradle/libs.versions.toml‎

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -10,15 +10,15 @@ angus-mail = "2.0.4"
1010
# https://mvnrepository.com/artifact/org.testcontainers/testcontainers
1111
testcontainers = "1.21.3"
1212
# https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-engine
13-
junit-jupiter = "5.13.4"
13+
junit-jupiter = "6.0.1"
1414
# https://mvnrepository.com/artifact/org.projectlombok/lombok
1515
lombok = "1.18.38"
1616
# https://mvnrepository.com/artifact/org.jspecify/jspecify
1717
jspecify = "1.0.0"
18-
# https://mvnrepository.com/artifact/org.junit.platform/junit-platform-launcher
19-
junit-platform-launcher = "1.13.4"
2018
# https://mvnrepository.com/artifact/org.mockito/mockito-core
2119
mockito = "5.20.0"
20+
# https://mvnrepository.com/artifact/org.assertj/assertj-core
21+
assertj-core = "4.0.0-M1"
2222

2323
[libraries]
2424
project-reactor-core = { module = "io.projectreactor:reactor-core", version.ref = "project-reactor" }
@@ -27,7 +27,7 @@ lombok = { module = "org.projectlombok:lombok", version.ref = "lombok" }
2727
junit-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit-jupiter" }
2828
junit-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit-jupiter" }
2929
junit-jupiter-params = { module = "org.junit.jupiter:junit-jupiter-params", version.ref = "junit-jupiter" }
30-
junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher", version.ref = "junit-platform-launcher" }
30+
junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher", version.ref = "junit-jupiter" }
3131
slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
3232
slf4j-simple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j" }
3333
slf4j-ext = { module = "org.slf4j:slf4j-ext", version.ref = "slf4j" }
@@ -36,6 +36,7 @@ angus-mail = { module = "org.eclipse.angus:angus-mail", version.ref = "angus-mai
3636
testcontainers = { module = "org.testcontainers:testcontainers", version.ref = "testcontainers" }
3737
mockito-core = { module = "org.mockito:mockito-core", version.ref = "mockito" }
3838
mockito-junit-jupiter = { module = "org.mockito:mockito-junit-jupiter", version.ref = "mockito" }
39+
assertj-core = { module = "org.assertj:assertj-core", version.ref = "assertj-core" }
3940

4041
[bundles]
4142
mail = ["jakarta-mail-api", "angus-mail"]

‎rlib-collections/src/main/java/javasabr/rlib/collections/array/Array.java‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,6 @@
55
import java.util.Iterator;
66
import java.util.List;
77
import java.util.Optional;
8-
import java.util.RandomAccess;
98
import java.util.function.Function;
109
import java.util.stream.Stream;
1110
import javasabr.rlib.collections.array.impl.DefaultArrayIterator;

‎rlib-collections/src/main/java/javasabr/rlib/collections/dictionary/RefToRefDictionary.java‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,6 @@
33
import java.util.function.BiConsumer;
44
import javasabr.rlib.collections.dictionary.impl.ImmutableHashBasedRefToRefDictionary;
55
import javasabr.rlib.collections.dictionary.impl.SimpleRefToRefEntry;
6-
import org.jspecify.annotations.Nullable;
76

87
public interface RefToRefDictionary<K, V> extends Dictionary<K, V> {
98

‎rlib-collections/src/test/java/javasabr/rlib/collections/array/ArrayTest.java‎

Lines changed: 76 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
package javasabr.rlib.collections.array;
22

3+
import static org.assertj.core.api.Assertions.assertThat;
4+
5+
import java.util.List;
36
import java.util.stream.Stream;
47
import org.junit.jupiter.api.Assertions;
58
import org.junit.jupiter.api.Test;
@@ -69,14 +72,23 @@ void shouldCorrectlyTakeValues(Array<String> array) {
6972
}
7073

7174
@ParameterizedTest
72-
@MethodSource("generateArrays")
75+
@MethodSource("generateArraysWithDuplicates")
7376
void shouldFindElementIndex(Array<String> array) {
7477
// when/then:
7578
Assertions.assertEquals(0, array.indexOf("First"));
7679
Assertions.assertEquals(3, array.indexOf(" "));
7780
Assertions.assertEquals(-1, array.indexOf("notexist"));
7881
}
7982

83+
@ParameterizedTest
84+
@MethodSource("generateArraysWithDuplicates")
85+
void shouldFindLastElementIndex(Array<String> array) {
86+
// when/then:
87+
Assertions.assertEquals(4, array.lastIndexOf("First"));
88+
Assertions.assertEquals(6, array.lastIndexOf("Third"));
89+
Assertions.assertEquals(-1, array.lastIndexOf("notexist"));
90+
}
91+
8092
@ParameterizedTest
8193
@MethodSource("generateArrays")
8294
void shouldFindElementIndexWithFunction(Array<String> array) {
@@ -113,6 +125,54 @@ void shouldCorrectlyTransformToNativeArray(Array<String> array) {
113125
}, array.toArray(String.class));
114126
}
115127

128+
@ParameterizedTest
129+
@MethodSource("generateArrays")
130+
void shouldCorrectlyCheckOnContains(Array<String> array) {
131+
// when/then:
132+
assertThat(array.contains("First")).isTrue();
133+
assertThat(array.contains(" ")).isTrue();
134+
assertThat(array.contains("notexist")).isFalse();
135+
}
136+
137+
@ParameterizedTest
138+
@MethodSource("generateArrays")
139+
void shouldCorrectlyCheckOnContainsAllByArray(Array<String> array) {
140+
// given:
141+
Array<String> check1 = Array.of("First");
142+
Array<String> check2 = Array.of("Second", "Third");
143+
Array<String> check3 = Array.of("Second", "Third", "noexist");
144+
// when/then:
145+
assertThat(array.containsAll(check1)).isTrue();
146+
assertThat(array.containsAll(check2)).isTrue();
147+
assertThat(array.containsAll(check3)).isFalse();
148+
}
149+
150+
@ParameterizedTest
151+
@MethodSource("generateArrays")
152+
void shouldCorrectlyCheckOnContainsAllByCollection(Array<String> array) {
153+
// given:
154+
List<String> check1 = List.of("First");
155+
List<String> check2 = List.of("Second", "Third");
156+
List<String> check3 = List.of("Second", "Third", "noexist");
157+
// when/then:
158+
assertThat(array.containsAll(check1)).isTrue();
159+
assertThat(array.containsAll(check2)).isTrue();
160+
assertThat(array.containsAll(check3)).isFalse();
161+
}
162+
163+
@ParameterizedTest
164+
@MethodSource("generateArrays")
165+
void shouldCorrectlyCheckOnContainsAllByNativeArray(Array<String> array) {
166+
// given:
167+
Object[] check1 = List.of("First").toArray();
168+
Object[] check2 = List.of("Second", "Third").toArray();
169+
Object[] check3 = List.of("Second", "Third", "noexist").toArray();
170+
// when/then:
171+
assertThat(array.containsAll(check1)).isTrue();
172+
assertThat(array.containsAll(check2)).isTrue();
173+
assertThat(array.containsAll(check3)).isFalse();
174+
}
175+
116176
private static Stream<Arguments> generateArrays() {
117177
Array<String> array = Array.of("First", "Second", "Third", " ");
118178
MutableArray<String> mutableArray = ArrayFactory.mutableArray(String.class);
@@ -127,4 +187,19 @@ private static Stream<Arguments> generateArrays() {
127187
Arguments.of(copyOnModifyArray),
128188
Arguments.of(stampedLockBasedArray));
129189
}
190+
191+
private static Stream<Arguments> generateArraysWithDuplicates() {
192+
Array<String> array = Array.typed(String.class, "First", "Second", "Third", " ", "First", "Second", "Third");
193+
MutableArray<String> mutableArray = ArrayFactory.mutableArray(String.class);
194+
mutableArray.addAll(array);
195+
MutableArray<String> copyOnModifyArray = ArrayFactory.copyOnModifyArray(String.class);
196+
copyOnModifyArray.addAll(array);
197+
LockableArray<String> stampedLockBasedArray = ArrayFactory.stampedLockBasedArray(String.class);
198+
stampedLockBasedArray.addAll(array);
199+
return Stream.of(
200+
Arguments.of(array),
201+
Arguments.of(mutableArray),
202+
Arguments.of(copyOnModifyArray),
203+
Arguments.of(stampedLockBasedArray));
204+
}
130205
}

‎rlib-collections/src/test/java/javasabr/rlib/collections/dictionary/IntToRefDictionaryTest.java‎

Lines changed: 194 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,194 @@
1+
package javasabr.rlib.collections.dictionary;
2+
3+
import static javasabr.rlib.collections.dictionary.IntToRefDictionary.entry;
4+
import static org.assertj.core.api.Assertions.assertThat;
5+
6+
import java.util.HashSet;
7+
import java.util.Set;
8+
import java.util.stream.Stream;
9+
import javasabr.rlib.collections.array.Array;
10+
import javasabr.rlib.collections.array.ArrayFactory;
11+
import javasabr.rlib.collections.array.IntArray;
12+
import javasabr.rlib.collections.array.MutableArray;
13+
import javasabr.rlib.common.tuple.IntRefTuple;
14+
import org.junit.jupiter.params.ParameterizedTest;
15+
import org.junit.jupiter.params.provider.Arguments;
16+
import org.junit.jupiter.params.provider.MethodSource;
17+
18+
class IntToRefDictionaryTest {
19+
20+
@ParameterizedTest
21+
@MethodSource("generateDictionaries")
22+
void shouldProvideCorrectSize(IntToRefDictionary<String> dictionary) {
23+
// then:
24+
assertThat(dictionary.size()).isEqualTo(5);
25+
assertThat(dictionary.isEmpty()).isFalse();
26+
}
27+
28+
@ParameterizedTest
29+
@MethodSource("generateEmptyDictionaries")
30+
void shouldConfirmThatDictionaryIsEmpty(IntToRefDictionary<String> dictionary) {
31+
// then:
32+
assertThat(dictionary.isEmpty()).isTrue();
33+
}
34+
35+
@ParameterizedTest
36+
@MethodSource("generateDictionaries")
37+
void shouldFindValuesByKeys(IntToRefDictionary<String> dictionary) {
38+
// then:
39+
assertThat(dictionary.get(1)).isEqualTo("val1");
40+
assertThat(dictionary.get(3)).isEqualTo("val3");
41+
assertThat(dictionary.get(4)).isEqualTo("val4");
42+
assertThat(dictionary.get(10)).isNull();
43+
}
44+
45+
@ParameterizedTest
46+
@MethodSource("generateDictionaries")
47+
void shouldFindValuesByKeysOrReturnDefault(IntToRefDictionary<String> dictionary) {
48+
// then:
49+
assertThat(dictionary.get(1)).isEqualTo("val1");
50+
assertThat(dictionary.get(10)).isNull();
51+
assertThat(dictionary.getOrDefault(10, "def1")).isEqualTo("def1");
52+
assertThat(dictionary.getOrDefault(30, "def2")).isEqualTo("def2");
53+
}
54+
55+
@ParameterizedTest
56+
@MethodSource("generateDictionaries")
57+
void shouldReturnOptionalValuesByKeys(IntToRefDictionary<String> dictionary) {
58+
// then:
59+
assertThat(dictionary.getOptional(1)).contains("val1");
60+
assertThat(dictionary.getOptional(10)).isEmpty();
61+
}
62+
63+
@ParameterizedTest
64+
@MethodSource("generateDictionaries")
65+
void shouldCheckContainsKeys(IntToRefDictionary<String> dictionary) {
66+
// then:
67+
assertThat(dictionary.containsKey(1)).isTrue();
68+
assertThat(dictionary.containsKey(2)).isTrue();
69+
assertThat(dictionary.containsKey(5)).isTrue();
70+
assertThat(dictionary.containsKey(10)).isFalse();
71+
}
72+
73+
@ParameterizedTest
74+
@MethodSource("generateDictionaries")
75+
void shouldCheckContainsValues(IntToRefDictionary<String> dictionary) {
76+
// then:
77+
assertThat(dictionary.containsValue("val1")).isTrue();
78+
assertThat(dictionary.containsValue("val3")).isTrue();
79+
assertThat(dictionary.containsValue("val4")).isTrue();
80+
assertThat(dictionary.containsValue("val10")).isFalse();
81+
}
82+
83+
@ParameterizedTest
84+
@MethodSource("generateDictionaries")
85+
void shouldHaveExpectedKeys(IntToRefDictionary<String> dictionary) {
86+
// given:
87+
var expectedArray = Array.typed(Integer.class, 1, 2, 3, 4, 5);
88+
var expectedIntArray = IntArray.of(1, 2, 3, 4, 5);
89+
var expectedSet = Set.copyOf(expectedArray.toList());
90+
91+
// when:
92+
Array<Integer> keys = dictionary.keys(Integer.class);
93+
94+
// then:
95+
assertThat(keys).isEqualTo(expectedArray);
96+
97+
// when:
98+
Array<Integer> keys2 = dictionary.keys(MutableArray.ofType(Integer.class));
99+
100+
// then:
101+
assertThat(keys2).isEqualTo(expectedArray);
102+
103+
// when:
104+
Set<Integer> keys3 = dictionary.keys(new HashSet<>());
105+
106+
// then:
107+
assertThat(keys3).isEqualTo(expectedSet);
108+
109+
// when:
110+
IntArray intKeys = dictionary.keys();
111+
112+
// then:
113+
assertThat(intKeys).isEqualTo(expectedIntArray);
114+
115+
// when:
116+
intKeys = dictionary.keys(ArrayFactory.mutableIntArray());
117+
118+
// then:
119+
assertThat(intKeys).isEqualTo(expectedIntArray);
120+
}
121+
122+
@ParameterizedTest
123+
@MethodSource("generateDictionaries")
124+
void shouldHaveExpectedValues(IntToRefDictionary<String> dictionary) {
125+
// given:
126+
var expectedArray = Array.typed(String.class, "val1", "val2", "val3", "val4", "val5");
127+
var expectedSet = Set.copyOf(expectedArray.toList());
128+
129+
// when:
130+
Array<String> values = dictionary.values(String.class);
131+
132+
// then:
133+
assertThat(values).isEqualTo(expectedArray);
134+
135+
// when:
136+
Array<String> values2 = dictionary.values(MutableArray.ofType(String.class));
137+
138+
// then:
139+
assertThat(values2).isEqualTo(expectedArray);
140+
141+
// when:
142+
Set<String> values3 = dictionary.values(new HashSet<>());
143+
144+
// then:
145+
assertThat(values3).isEqualTo(expectedSet);
146+
}
147+
148+
@ParameterizedTest
149+
@MethodSource("generateDictionaries")
150+
void shouldHaveExpectedResultFromForEach(IntToRefDictionary<String> dictionary) {
151+
// given:
152+
var expectedArray = Array.typed(String.class, "val1", "val2", "val3", "val4", "val5");
153+
var expectedPairs = Array.typed(IntRefTuple.class,
154+
new IntRefTuple<>(1, "val1"),
155+
new IntRefTuple<>(2, "val2"),
156+
new IntRefTuple<>(3, "val3"),
157+
new IntRefTuple<>(4, "val4"),
158+
new IntRefTuple<>(5, "val5"));
159+
160+
// when:
161+
MutableArray<String> values = MutableArray.ofType(String.class);
162+
dictionary.forEach(values::add);
163+
164+
// then:
165+
assertThat(values).isEqualTo(expectedArray);
166+
167+
// when:
168+
MutableArray<IntRefTuple> pairs = MutableArray.ofType(IntRefTuple.class);
169+
dictionary.forEach((key, value) -> pairs.add(new IntRefTuple<>(key, value)));
170+
171+
// then:
172+
assertThat(pairs).isEqualTo(expectedPairs);
173+
}
174+
175+
private static Stream<Arguments> generateDictionaries() {
176+
177+
IntToRefDictionary<String> source = IntToRefDictionary.ofEntries(
178+
entry(1, "val1"),
179+
entry(2, "val2"),
180+
entry(3, "val3"),
181+
entry(4, "val4"),
182+
entry(5, "val5"));
183+
184+
return Stream.of(
185+
Arguments.of(source),
186+
Arguments.of(DictionaryFactory.mutableIntToRefDictionary().append(source)));
187+
}
188+
189+
private static Stream<Arguments> generateEmptyDictionaries() {
190+
return Stream.of(
191+
Arguments.of(IntToRefDictionary.empty()),
192+
Arguments.of(DictionaryFactory.mutableIntToRefDictionary()));
193+
}
194+
}

0 commit comments

Comments
 (0)