Skip to content

Commit ced34aa

Browse files
CopilotGarciat
Copilot
and
Garciat
committed
Import ParsedType subtypes in ParsedTypeTest and UnificationTest
Co-authored-by: Garciat <118277+Garciat@users.noreply.github.com>
1 parent d167c72 commit ced34aa

2 files changed

Lines changed: 73 additions & 88 deletions

File tree

‎src/test/java/com/garciat/typeclasses/impl/ParsedTypeTest.java‎

Lines changed: 15 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,11 @@
33
import static org.assertj.core.api.Assertions.*;
44

55
import com.garciat.typeclasses.api.Ty;
6+
import com.garciat.typeclasses.impl.ParsedType.App;
7+
import com.garciat.typeclasses.impl.ParsedType.ArrayOf;
8+
import com.garciat.typeclasses.impl.ParsedType.Const;
9+
import com.garciat.typeclasses.impl.ParsedType.Primitive;
10+
import com.garciat.typeclasses.impl.ParsedType.Var;
611
import java.lang.reflect.Type;
712
import java.lang.reflect.TypeVariable;
813
import java.util.List;
@@ -14,34 +19,33 @@ final class ParsedTypeTest {
1419
@Test
1520
void parseClass() {
1621
ParsedType result = ParsedType.parse(String.class);
17-
assertThat(result).isEqualTo(new ParsedType.Const(String.class));
22+
assertThat(result).isEqualTo(new Const(String.class));
1823
}
1924

2025
@Test
2126
void parsePrimitiveType() {
2227
ParsedType result = ParsedType.parse(int.class);
23-
assertThat(result).isEqualTo(new ParsedType.Primitive(int.class));
28+
assertThat(result).isEqualTo(new Primitive(int.class));
2429
}
2530

2631
@Test
2732
void parseArrayType() {
2833
ParsedType result = ParsedType.parse(int[].class);
29-
assertThat(result).isEqualTo(new ParsedType.ArrayOf(new ParsedType.Primitive(int.class)));
34+
assertThat(result).isEqualTo(new ArrayOf(new Primitive(int.class)));
3035
}
3136

3237
@Test
3338
void parseObjectArrayType() {
3439
ParsedType result = ParsedType.parse(String[].class);
35-
assertThat(result).isEqualTo(new ParsedType.ArrayOf(new ParsedType.Const(String.class)));
40+
assertThat(result).isEqualTo(new ArrayOf(new Const(String.class)));
3641
}
3742

3843
@Test
3944
void parseParameterizedType() throws Exception {
4045
Type listType = new Ty<List<String>>() {}.type();
4146
ParsedType result = ParsedType.parse(listType);
4247

43-
ParsedType expected =
44-
new ParsedType.App(new ParsedType.Const(List.class), new ParsedType.Const(String.class));
48+
ParsedType expected = new App(new Const(List.class), new Const(String.class));
4549
assertThat(result).isEqualTo(expected);
4650
}
4751

@@ -51,9 +55,7 @@ void parseMultipleTypeParameters() throws Exception {
5155
ParsedType result = ParsedType.parse(mapType);
5256

5357
ParsedType expected =
54-
new ParsedType.App(
55-
new ParsedType.App(new ParsedType.Const(Map.class), new ParsedType.Const(String.class)),
56-
new ParsedType.Const(Integer.class));
58+
new App(new App(new Const(Map.class), new Const(String.class)), new Const(Integer.class));
5759
assertThat(result).isEqualTo(expected);
5860
}
5961

@@ -63,10 +65,7 @@ void parseNestedParameterizedType() throws Exception {
6365
ParsedType result = ParsedType.parse(nestedType);
6466

6567
ParsedType expected =
66-
new ParsedType.App(
67-
new ParsedType.Const(List.class),
68-
new ParsedType.App(
69-
new ParsedType.Const(Optional.class), new ParsedType.Const(String.class)));
68+
new App(new Const(List.class), new App(new Const(Optional.class), new Const(String.class)));
7069
assertThat(result).isEqualTo(expected);
7170
}
7271

@@ -76,10 +75,7 @@ void parseAll() throws Exception {
7675
List<ParsedType> result = ParsedType.parseAll(types);
7776

7877
List<ParsedType> expected =
79-
List.of(
80-
new ParsedType.Const(String.class),
81-
new ParsedType.Const(Integer.class),
82-
new ParsedType.Primitive(int.class));
78+
List.of(new Const(String.class), new Const(Integer.class), new Primitive(int.class));
8379
assertThat(result).isEqualTo(expected);
8480
}
8581

@@ -90,7 +86,7 @@ class TestClass<T> {}
9086

9187
ParsedType result = ParsedType.parse(tv);
9288

93-
assertThat(result).isEqualTo(new ParsedType.Var(tv));
89+
assertThat(result).isEqualTo(new Var(tv));
9490
}
9591

9692
@Test
@@ -103,8 +99,7 @@ class TestClass<T> {
10399

104100
ParsedType result = ParsedType.parse(fieldType);
105101

106-
ParsedType expected =
107-
new ParsedType.App(new ParsedType.Const(List.class), new ParsedType.Var(tv));
102+
ParsedType expected = new App(new Const(List.class), new Var(tv));
108103
assertThat(result).isEqualTo(expected);
109104
}
110105

‎src/test/java/com/garciat/typeclasses/impl/UnificationTest.java‎

Lines changed: 58 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,11 @@
22

33
import static org.assertj.core.api.Assertions.*;
44

5+
import com.garciat.typeclasses.impl.ParsedType.App;
6+
import com.garciat.typeclasses.impl.ParsedType.ArrayOf;
7+
import com.garciat.typeclasses.impl.ParsedType.Const;
8+
import com.garciat.typeclasses.impl.ParsedType.Primitive;
9+
import com.garciat.typeclasses.impl.ParsedType.Var;
510
import com.garciat.typeclasses.types.Maybe;
611
import java.lang.reflect.TypeVariable;
712
import java.util.List;
@@ -11,136 +16,126 @@
1116
final class UnificationTest {
1217
@Test
1318
void unifyEqualConsts() {
14-
ParsedType t1 = new ParsedType.Const(String.class);
15-
ParsedType t2 = new ParsedType.Const(String.class);
19+
ParsedType t1 = new Const(String.class);
20+
ParsedType t2 = new Const(String.class);
1621

17-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(t1, t2);
22+
Maybe<Map<Var, ParsedType>> result = Unification.unify(t1, t2);
1823

1924
assertThat(result).isEqualTo(Maybe.just(Map.of()));
2025
}
2126

2227
@Test
2328
void unifyDifferentConsts() {
24-
ParsedType t1 = new ParsedType.Const(String.class);
25-
ParsedType t2 = new ParsedType.Const(Integer.class);
29+
ParsedType t1 = new Const(String.class);
30+
ParsedType t2 = new Const(Integer.class);
2631

27-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(t1, t2);
32+
Maybe<Map<Var, ParsedType>> result = Unification.unify(t1, t2);
2833

2934
assertThat(result).isEqualTo(Maybe.nothing());
3035
}
3136

3237
@Test
3338
void unifyVarWithConst() throws Exception {
3439
TypeVariable<?> tv = getTypeVariable();
35-
ParsedType t1 = new ParsedType.Var(tv);
36-
ParsedType t2 = new ParsedType.Const(String.class);
40+
ParsedType t1 = new Var(tv);
41+
ParsedType t2 = new Const(String.class);
3742

38-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(t1, t2);
43+
Maybe<Map<Var, ParsedType>> result = Unification.unify(t1, t2);
3944

4045
assertThat(result).isEqualTo(Maybe.just(Map.of(t1, t2)));
4146
}
4247

4348
@Test
4449
void unifyVarWithPrimitiveFails() throws Exception {
4550
TypeVariable<?> tv = getTypeVariable();
46-
ParsedType t1 = new ParsedType.Var(tv);
47-
ParsedType t2 = new ParsedType.Primitive(int.class);
51+
ParsedType t1 = new Var(tv);
52+
ParsedType t2 = new Primitive(int.class);
4853

49-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(t1, t2);
54+
Maybe<Map<Var, ParsedType>> result = Unification.unify(t1, t2);
5055

5156
assertThat(result).isEqualTo(Maybe.nothing());
5257
}
5358

5459
@Test
5560
void unifyApps() {
56-
ParsedType list1 =
57-
new ParsedType.App(new ParsedType.Const(List.class), new ParsedType.Const(String.class));
58-
ParsedType list2 =
59-
new ParsedType.App(new ParsedType.Const(List.class), new ParsedType.Const(String.class));
61+
ParsedType list1 = new App(new Const(List.class), new Const(String.class));
62+
ParsedType list2 = new App(new Const(List.class), new Const(String.class));
6063

61-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(list1, list2);
64+
Maybe<Map<Var, ParsedType>> result = Unification.unify(list1, list2);
6265

6366
assertThat(result).isEqualTo(Maybe.just(Map.of()));
6467
}
6568

6669
@Test
6770
void unifyAppsDifferentArgs() {
68-
ParsedType list1 =
69-
new ParsedType.App(new ParsedType.Const(List.class), new ParsedType.Const(String.class));
70-
ParsedType list2 =
71-
new ParsedType.App(new ParsedType.Const(List.class), new ParsedType.Const(Integer.class));
71+
ParsedType list1 = new App(new Const(List.class), new Const(String.class));
72+
ParsedType list2 = new App(new Const(List.class), new Const(Integer.class));
7273

73-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(list1, list2);
74+
Maybe<Map<Var, ParsedType>> result = Unification.unify(list1, list2);
7475

7576
assertThat(result).isEqualTo(Maybe.nothing());
7677
}
7778

7879
@Test
7980
void unifyAppsWithVar() throws Exception {
8081
TypeVariable<?> tv = getTypeVariable();
81-
ParsedType.Var var = new ParsedType.Var(tv);
82-
ParsedType list1 = new ParsedType.App(new ParsedType.Const(List.class), var);
83-
ParsedType list2 =
84-
new ParsedType.App(new ParsedType.Const(List.class), new ParsedType.Const(String.class));
82+
Var var = new Var(tv);
83+
ParsedType list1 = new App(new Const(List.class), var);
84+
ParsedType list2 = new App(new Const(List.class), new Const(String.class));
8585

86-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(list1, list2);
86+
Maybe<Map<Var, ParsedType>> result = Unification.unify(list1, list2);
8787

88-
assertThat(result).isEqualTo(Maybe.just(Map.of(var, new ParsedType.Const(String.class))));
88+
assertThat(result).isEqualTo(Maybe.just(Map.of(var, new Const(String.class))));
8989
}
9090

9191
@Test
9292
void unifyNestedAppsWithVar() throws Exception {
9393
TypeVariable<?> tv = getTypeVariable();
94-
ParsedType.Var var = new ParsedType.Var(tv);
95-
ParsedType map1 =
96-
new ParsedType.App(
97-
new ParsedType.App(new ParsedType.Const(Map.class), var),
98-
new ParsedType.Const(Integer.class));
94+
Var var = new Var(tv);
95+
ParsedType map1 = new App(new App(new Const(Map.class), var), new Const(Integer.class));
9996
ParsedType map2 =
100-
new ParsedType.App(
101-
new ParsedType.App(new ParsedType.Const(Map.class), new ParsedType.Const(String.class)),
102-
new ParsedType.Const(Integer.class));
97+
new App(new App(new Const(Map.class), new Const(String.class)), new Const(Integer.class));
10398

104-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(map1, map2);
99+
Maybe<Map<Var, ParsedType>> result = Unification.unify(map1, map2);
105100

106-
assertThat(result).isEqualTo(Maybe.just(Map.of(var, new ParsedType.Const(String.class))));
101+
assertThat(result).isEqualTo(Maybe.just(Map.of(var, new Const(String.class))));
107102
}
108103

109104
@Test
110105
void unifyArrays() {
111-
ParsedType arr1 = new ParsedType.ArrayOf(new ParsedType.Const(String.class));
112-
ParsedType arr2 = new ParsedType.ArrayOf(new ParsedType.Const(String.class));
106+
ParsedType arr1 = new ArrayOf(new Const(String.class));
107+
ParsedType arr2 = new ArrayOf(new Const(String.class));
113108

114-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(arr1, arr2);
109+
Maybe<Map<Var, ParsedType>> result = Unification.unify(arr1, arr2);
115110

116111
assertThat(result).isEqualTo(Maybe.just(Map.of()));
117112
}
118113

119114
@Test
120115
void unifyPrimitives() {
121-
ParsedType p1 = new ParsedType.Primitive(int.class);
122-
ParsedType p2 = new ParsedType.Primitive(int.class);
116+
ParsedType p1 = new Primitive(int.class);
117+
ParsedType p2 = new Primitive(int.class);
123118

124-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(p1, p2);
119+
Maybe<Map<Var, ParsedType>> result = Unification.unify(p1, p2);
125120

126121
assertThat(result).isEqualTo(Maybe.just(Map.of()));
127122
}
128123

129124
@Test
130125
void unifyDifferentPrimitives() {
131-
ParsedType p1 = new ParsedType.Primitive(int.class);
132-
ParsedType p2 = new ParsedType.Primitive(boolean.class);
126+
ParsedType p1 = new Primitive(int.class);
127+
ParsedType p2 = new Primitive(boolean.class);
133128

134-
Maybe<Map<ParsedType.Var, ParsedType>> result = Unification.unify(p1, p2);
129+
Maybe<Map<Var, ParsedType>> result = Unification.unify(p1, p2);
135130

136131
assertThat(result).isEqualTo(Maybe.nothing());
137132
}
138133

139134
@Test
140135
void substituteVar() throws Exception {
141136
TypeVariable<?> tv = getTypeVariable();
142-
ParsedType.Var var = new ParsedType.Var(tv);
143-
ParsedType replacement = new ParsedType.Const(String.class);
137+
Var var = new Var(tv);
138+
ParsedType replacement = new Const(String.class);
144139

145140
ParsedType result = Unification.substitute(Map.of(var, replacement), var);
146141

@@ -149,7 +144,7 @@ void substituteVar() throws Exception {
149144

150145
@Test
151146
void substituteConst() {
152-
ParsedType type = new ParsedType.Const(String.class);
147+
ParsedType type = new Const(String.class);
153148

154149
ParsedType result = Unification.substitute(Map.of(), type);
155150

@@ -159,48 +154,43 @@ void substituteConst() {
159154
@Test
160155
void substituteApp() throws Exception {
161156
TypeVariable<?> tv = getTypeVariable();
162-
ParsedType.Var var = new ParsedType.Var(tv);
163-
ParsedType replacement = new ParsedType.Const(String.class);
157+
Var var = new Var(tv);
158+
ParsedType replacement = new Const(String.class);
164159

165160
ParsedType result =
166-
Unification.substitute(
167-
Map.of(var, replacement), new ParsedType.App(new ParsedType.Const(List.class), var));
161+
Unification.substitute(Map.of(var, replacement), new App(new Const(List.class), var));
168162

169-
assertThat(result).isEqualTo(new ParsedType.App(new ParsedType.Const(List.class), replacement));
163+
assertThat(result).isEqualTo(new App(new Const(List.class), replacement));
170164
}
171165

172166
@Test
173167
void substituteArrayOf() throws Exception {
174168
TypeVariable<?> tv = getTypeVariable();
175-
ParsedType.Var var = new ParsedType.Var(tv);
176-
ParsedType replacement = new ParsedType.Const(String.class);
169+
Var var = new Var(tv);
170+
ParsedType replacement = new Const(String.class);
177171

178-
ParsedType result =
179-
Unification.substitute(Map.of(var, replacement), new ParsedType.ArrayOf(var));
172+
ParsedType result = Unification.substitute(Map.of(var, replacement), new ArrayOf(var));
180173

181-
assertThat(result).isEqualTo(new ParsedType.ArrayOf(replacement));
174+
assertThat(result).isEqualTo(new ArrayOf(replacement));
182175
}
183176

184177
@Test
185178
void substituteAll() throws Exception {
186179
TypeVariable<?> tv = getTypeVariable();
187-
ParsedType.Var var = new ParsedType.Var(tv);
188-
ParsedType replacement = new ParsedType.Const(String.class);
180+
Var var = new Var(tv);
181+
ParsedType replacement = new Const(String.class);
189182

190183
List<ParsedType> result =
191184
Unification.substituteAll(
192185
Map.of(var, replacement),
193-
List.of(
194-
var,
195-
new ParsedType.Const(Integer.class),
196-
new ParsedType.App(new ParsedType.Const(List.class), var)));
186+
List.of(var, new Const(Integer.class), new App(new Const(List.class), var)));
197187

198188
assertThat(result)
199189
.isEqualTo(
200190
List.of(
201191
replacement,
202-
new ParsedType.Const(Integer.class),
203-
new ParsedType.App(new ParsedType.Const(List.class), replacement)));
192+
new Const(Integer.class),
193+
new App(new Const(List.class), replacement)));
204194
}
205195

206196
// Helper to get a type variable for testing

0 commit comments

Comments
 (0)