Skip to content

Commit c31e2cb

Browse files
zhongkechenzhongkechen
committed
add test cases
1 parent b94345c commit c31e2cb

File tree

2 files changed

+172
-3
lines changed

2 files changed

+172
-3
lines changed

‎sdk/src/main/java/software/amazon/lambda/durable/TypeToken.java‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
import java.lang.reflect.Type;
77
import java.util.Collections;
88
import java.util.Map;
9+
import java.util.Objects;
910
import java.util.WeakHashMap;
1011

1112
/**
@@ -55,6 +56,7 @@ private static Type resolveType(Class<?> aClass) {
5556
}
5657

5758
private TypeToken(Type type) {
59+
Objects.requireNonNull(type, "Type cannot be null");
5860
this.type = type;
5961
}
6062

‎sdk/src/test/java/software/amazon/lambda/durable/TypeTokenTest.java‎

Lines changed: 170 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ void testSimpleGenericType() {
1717
var token = new TypeToken<List<String>>() {};
1818
Type type = token.getType();
1919

20-
assertTrue(type instanceof ParameterizedType);
20+
assertInstanceOf(ParameterizedType.class, type);
2121
ParameterizedType paramType = (ParameterizedType) type;
2222
assertEquals(List.class, paramType.getRawType());
2323
assertEquals(String.class, paramType.getActualTypeArguments()[0]);
@@ -28,13 +28,13 @@ void testNestedGenericType() {
2828
var token = new TypeToken<Map<String, List<Integer>>>() {};
2929
Type type = token.getType();
3030

31-
assertTrue(type instanceof ParameterizedType);
31+
assertInstanceOf(ParameterizedType.class, type);
3232
ParameterizedType paramType = (ParameterizedType) type;
3333
assertEquals(Map.class, paramType.getRawType());
3434
assertEquals(String.class, paramType.getActualTypeArguments()[0]);
3535

3636
Type valueType = paramType.getActualTypeArguments()[1];
37-
assertTrue(valueType instanceof ParameterizedType);
37+
assertInstanceOf(ParameterizedType.class, valueType);
3838
ParameterizedType valueParamType = (ParameterizedType) valueType;
3939
assertEquals(List.class, valueParamType.getRawType());
4040
assertEquals(Integer.class, valueParamType.getActualTypeArguments()[0]);
@@ -70,4 +70,171 @@ void testMissingTypeParameter() {
7070
new TypeToken() {};
7171
});
7272
}
73+
74+
@Test
75+
void testGetWithClass() {
76+
var token = TypeToken.get(String.class);
77+
Type type = token.getType();
78+
79+
assertEquals(String.class, type);
80+
}
81+
82+
@Test
83+
void testGetWithClassEquals() {
84+
var token1 = TypeToken.get(String.class);
85+
var token2 = TypeToken.get(String.class);
86+
var token3 = TypeToken.get(Integer.class);
87+
88+
assertEquals(token1, token2);
89+
assertEquals(token1.hashCode(), token2.hashCode());
90+
assertNotEquals(token1, token3);
91+
}
92+
93+
@Test
94+
void testGetWithPrimitiveClass() {
95+
var intToken = TypeToken.get(int.class);
96+
var longToken = TypeToken.get(long.class);
97+
var booleanToken = TypeToken.get(boolean.class);
98+
99+
assertEquals(int.class, intToken.getType());
100+
assertEquals(long.class, longToken.getType());
101+
assertEquals(boolean.class, booleanToken.getType());
102+
}
103+
104+
@Test
105+
void testGetWithArrayClass() {
106+
var token = TypeToken.get(String[].class);
107+
assertEquals(String[].class, token.getType());
108+
}
109+
110+
@Test
111+
void testEqualsSameInstance() {
112+
var token = new TypeToken<List<String>>() {};
113+
assertEquals(token, token);
114+
}
115+
116+
@Test
117+
void testEqualsNull() {
118+
var token = new TypeToken<List<String>>() {};
119+
assertNotEquals(token, null);
120+
}
121+
122+
@Test
123+
void testEqualsDifferentClass() {
124+
var token = new TypeToken<List<String>>() {};
125+
assertNotEquals(token, "not a TypeToken");
126+
}
127+
128+
@Test
129+
void testComplexNestedGenericType() {
130+
var token = new TypeToken<Map<String, Map<Integer, List<String>>>>() {};
131+
Type type = token.getType();
132+
133+
assertInstanceOf(ParameterizedType.class, type);
134+
ParameterizedType paramType = (ParameterizedType) type;
135+
assertEquals(Map.class, paramType.getRawType());
136+
assertEquals(String.class, paramType.getActualTypeArguments()[0]);
137+
138+
Type valueType = paramType.getActualTypeArguments()[1];
139+
assertInstanceOf(ParameterizedType.class, valueType);
140+
ParameterizedType valueParamType = (ParameterizedType) valueType;
141+
assertEquals(Map.class, valueParamType.getRawType());
142+
assertEquals(Integer.class, valueParamType.getActualTypeArguments()[0]);
143+
144+
Type innerValueType = valueParamType.getActualTypeArguments()[1];
145+
assertInstanceOf(ParameterizedType.class, innerValueType);
146+
ParameterizedType innerValueParamType = (ParameterizedType) innerValueType;
147+
assertEquals(List.class, innerValueParamType.getRawType());
148+
assertEquals(String.class, innerValueParamType.getActualTypeArguments()[0]);
149+
}
150+
151+
@Test
152+
void testToStringWithSimpleType() {
153+
var token = TypeToken.get(String.class);
154+
var str = token.toString();
155+
156+
assertTrue(str.contains("TypeToken"));
157+
assertTrue(str.contains("String"));
158+
}
159+
160+
@Test
161+
void testToStringWithComplexType() {
162+
var token = new TypeToken<Map<String, List<Integer>>>() {};
163+
var str = token.toString();
164+
165+
assertTrue(str.contains("TypeToken"));
166+
assertTrue(str.contains("Map"));
167+
assertTrue(str.contains("String"));
168+
assertTrue(str.contains("List"));
169+
assertTrue(str.contains("Integer"));
170+
}
171+
172+
@Test
173+
void testTypeCaching() {
174+
// Create multiple instances of the same type
175+
var token1 = new TypeToken<List<String>>() {};
176+
var token2 = new TypeToken<List<String>>() {};
177+
178+
// They should be equal and have the same type
179+
assertEquals(token1, token2);
180+
assertEquals(token1.getType(), token2.getType());
181+
}
182+
183+
@Test
184+
void testDifferentGenericParameters() {
185+
var stringListToken = new TypeToken<List<String>>() {};
186+
var integerListToken = new TypeToken<List<Integer>>() {};
187+
var doubleListToken = new TypeToken<List<Double>>() {};
188+
189+
assertNotEquals(stringListToken, integerListToken);
190+
assertNotEquals(stringListToken, doubleListToken);
191+
assertNotEquals(integerListToken, doubleListToken);
192+
}
193+
194+
@Test
195+
void testWildcardType() {
196+
var token = new TypeToken<List<?>>() {};
197+
Type type = token.getType();
198+
199+
assertInstanceOf(ParameterizedType.class, type);
200+
ParameterizedType paramType = (ParameterizedType) type;
201+
assertEquals(List.class, paramType.getRawType());
202+
assertNotNull(paramType.getActualTypeArguments()[0]);
203+
}
204+
205+
@Test
206+
void testMultipleTypeParameters() {
207+
var token = new TypeToken<Map<String, Integer>>() {};
208+
Type type = token.getType();
209+
210+
assertInstanceOf(ParameterizedType.class, type);
211+
ParameterizedType paramType = (ParameterizedType) type;
212+
assertEquals(Map.class, paramType.getRawType());
213+
assertEquals(2, paramType.getActualTypeArguments().length);
214+
assertEquals(String.class, paramType.getActualTypeArguments()[0]);
215+
assertEquals(Integer.class, paramType.getActualTypeArguments()[1]);
216+
}
217+
218+
@Test
219+
void testGetTypeReturnsConsistentValue() {
220+
var token = new TypeToken<List<String>>() {};
221+
Type type1 = token.getType();
222+
Type type2 = token.getType();
223+
224+
assertSame(type1, type2);
225+
}
226+
227+
@Test
228+
void testHashCodeConsistency() {
229+
var token = new TypeToken<List<String>>() {};
230+
int hash1 = token.hashCode();
231+
int hash2 = token.hashCode();
232+
233+
assertEquals(hash1, hash2);
234+
}
235+
236+
@Test
237+
void testGetWithNullClass() {
238+
assertThrows(NullPointerException.class, () -> TypeToken.get(null));
239+
}
73240
}

0 commit comments

Comments
 (0)