Skip to content

Commit 8f3c898

Browse files
jonpereiradevJonathan Pereira
jonpereiradev
authored and
Jonathan Pereira
committed
Remoção do wildcard do DiffResult.
1 parent 55cbb48 commit 8f3c898

11 files changed

Lines changed: 85 additions & 77 deletions

File tree

‎src/main/java/com/github/jonpereiradev/diffobjects/DiffObjects.java‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ public final class DiffObjects {
2222
* @param afterState objeto com as informaçnoes depois da alteração.
2323
* @return resultado do instance.
2424
*/
25-
public static <T> List<DiffResult<?>> diff(T beforeState, T afterState) {
25+
public static <T> List<DiffResult> diff(T beforeState, T afterState) {
2626
Objects.requireNonNull(beforeState, "Before state is required.");
2727
Objects.requireNonNull(afterState, "After state is required.");
2828

@@ -52,15 +52,15 @@ public static <T> boolean isEquals(T beforeState, T afterState) {
5252
* @param afterState objeto com as informaçnoes depois da alteração.
5353
* @return resultado do instance.
5454
*/
55-
public static <T> List<DiffResult<?>> diff(T beforeState, T afterState, DiffConfiguration configuration) {
55+
public static <T> List<DiffResult> diff(T beforeState, T afterState, DiffConfiguration configuration) {
5656
Objects.requireNonNull(beforeState, "Before state is required.");
5757
Objects.requireNonNull(afterState, "After state is required.");
5858
Objects.requireNonNull(configuration, "Configuration is required.");
5959

60-
List<DiffResult<?>> results = new LinkedList<>();
60+
List<DiffResult> results = new LinkedList<>();
6161

6262
for (DiffMetadata metadata : configuration.build()) {
63-
DiffResult<Object> diff = metadata.getStrategy().diff(beforeState, afterState, metadata);
63+
DiffResult diff = metadata.getStrategy().diff(beforeState, afterState, metadata);
6464
diff.setProperties(Collections.unmodifiableMap(metadata.getProperties()));
6565
results.add(diff);
6666
}
@@ -82,7 +82,7 @@ public static <T> boolean isEquals(T beforeState, T afterState, DiffConfiguratio
8282
Objects.requireNonNull(configuration, "Configuration is required.");
8383

8484
for (DiffMetadata metadata : configuration.build()) {
85-
DiffResult<T> result = metadata.getStrategy().diff(beforeState, afterState, metadata);
85+
DiffResult result = metadata.getStrategy().diff(beforeState, afterState, metadata);
8686

8787
if (!result.isEquals()) {
8888
return false;

‎src/main/java/com/github/jonpereiradev/diffobjects/DiffResult.java‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -5,24 +5,24 @@
55
/**
66
* @author jonpereiradev@gmail.com
77
*/
8-
public class DiffResult<T> {
8+
public class DiffResult {
99

10-
private T before;
11-
private T after;
10+
private Object before;
11+
private Object after;
1212
private boolean equals;
1313
private Map<String, String> properties;
1414

15-
public DiffResult(T before, T after, boolean equals) {
15+
public DiffResult(Object before, Object after, boolean equals) {
1616
this.before = before;
1717
this.after = after;
1818
this.equals = equals;
1919
}
2020

21-
public T getBefore() {
21+
public Object getBefore() {
2222
return before;
2323
}
2424

25-
public T getAfter() {
25+
public Object getAfter() {
2626
return after;
2727
}
2828

‎src/main/java/com/github/jonpereiradev/diffobjects/strategy/DiffCollectionStrategy.java‎

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -19,20 +19,19 @@ final class DiffCollectionStrategy implements DiffStrategy {
1919
* @param before object that is considered a state before the after object.
2020
* @param after object that is considered the before object updated.
2121
* @param diffMetadata the diffMetadata that is mapped to make the instance.
22-
* @param <T> the type of object returned by the instance.
2322
* @return the instance result between the two objects.
2423
*/
2524
@Override
26-
public <T> DiffResult<T> diff(Object before, Object after, DiffMetadata diffMetadata) {
25+
public DiffResult diff(Object before, Object after, DiffMetadata diffMetadata) {
2726
Collection<?> beforeCollection = initializeCollection(before, diffMetadata.getMethod());
2827
Collection<?> afterCollection = initializeCollection(after, diffMetadata.getMethod());
2928

3029
if (beforeCollection == null && afterCollection == null) {
31-
return new DiffResult<>(null, null, true);
30+
return new DiffResult(null, null, true);
3231
}
3332

3433
if (!isEqualsSize(beforeCollection, afterCollection)) {
35-
return new DiffResult<>((T) beforeCollection, (T) afterCollection, false);
34+
return new DiffResult(beforeCollection, afterCollection, false);
3635
}
3736

3837
Iterator<?> beforeIterator = beforeCollection.iterator();
@@ -45,17 +44,17 @@ public <T> DiffResult<T> diff(Object before, Object after, DiffMetadata diffMeta
4544
if (!diffMetadata.getValue().isEmpty()) {
4645
Method method = DiffReflections.discoverGetter(beforeObject.getClass(), diffMetadata.getValue());
4746
DiffMetadata metadata = new DiffMetadata(null, method, DiffStrategyType.SINGLE);
48-
DiffResult<Object> single = DiffStrategyType.SINGLE.getStrategy().diff(beforeObject, afterObject, metadata);
47+
DiffResult single = DiffStrategyType.SINGLE.getStrategy().diff(beforeObject, afterObject, metadata);
4948

5049
if (!single.isEquals()) {
51-
return new DiffResult<>((T) beforeCollection, (T) afterCollection, false);
50+
return new DiffResult(beforeCollection, afterCollection, false);
5251
}
5352
} else if (!beforeObject.equals(afterObject)) {
54-
return new DiffResult<>((T) beforeCollection, (T) afterCollection, false);
53+
return new DiffResult(beforeCollection, afterCollection, false);
5554
}
5655
}
5756

58-
return new DiffResult<>((T) beforeCollection, (T) afterCollection, true);
57+
return new DiffResult(beforeCollection, afterCollection, true);
5958
}
6059

6160
private boolean isEqualsSize(Collection<?> beforeCollection, Collection<?> afterCollection) {

‎src/main/java/com/github/jonpereiradev/diffobjects/strategy/DiffDeepStrategy.java‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -20,11 +20,10 @@ final class DiffDeepStrategy implements DiffStrategy {
2020
* @param before object that is considered a state before the after object.
2121
* @param after object that is considered the before object updated.
2222
* @param diffMetadata the diffMetadata that is mapped to make the instance.
23-
* @param <T> the type of object returned by the instance.
2423
* @return the instance result between the two objects.
2524
*/
2625
@Override
27-
public <T> DiffResult<T> diff(Object before, Object after, DiffMetadata diffMetadata) {
26+
public DiffResult diff(Object before, Object after, DiffMetadata diffMetadata) {
2827
Method beforeMethod = diffMetadata.getMethod();
2928
Method afterMethod = diffMetadata.getMethod();
3029
Object beforeObject = null;
@@ -51,6 +50,6 @@ public <T> DiffResult<T> diff(Object before, Object after, DiffMetadata diffMeta
5150
}
5251
}
5352

54-
return new DiffResult<>((T) beforeObject, (T) afterObject, Objects.deepEquals(beforeObject, afterObject));
53+
return new DiffResult(beforeObject, afterObject, Objects.deepEquals(beforeObject, afterObject));
5554
}
5655
}

‎src/main/java/com/github/jonpereiradev/diffobjects/strategy/DiffSingleStrategy.java‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -21,9 +21,9 @@ final class DiffSingleStrategy implements DiffStrategy {
2121
* @return the instance result between the two objects.
2222
*/
2323
@Override
24-
public <T> DiffResult<T> diff(Object before, Object after, DiffMetadata diffMetadata) {
25-
T beforeValue = null;
26-
T afterValue = null;
24+
public DiffResult diff(Object before, Object after, DiffMetadata diffMetadata) {
25+
Object beforeValue = null;
26+
Object afterValue = null;
2727

2828
if (before != null) {
2929
beforeValue = DiffReflections.invoke(before, diffMetadata.getMethod());
@@ -33,6 +33,6 @@ public <T> DiffResult<T> diff(Object before, Object after, DiffMetadata diffMeta
3333
afterValue = DiffReflections.invoke(after, diffMetadata.getMethod());
3434
}
3535

36-
return new DiffResult<>(beforeValue, afterValue, Objects.deepEquals(beforeValue, afterValue));
36+
return new DiffResult(beforeValue, afterValue, Objects.deepEquals(beforeValue, afterValue));
3737
}
3838
}

‎src/main/java/com/github/jonpereiradev/diffobjects/strategy/DiffStrategy.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,6 @@
1212
*/
1313
public interface DiffStrategy {
1414

15-
<T> DiffResult<T> diff(Object before, Object after, DiffMetadata diffMetadata);
15+
DiffResult diff(Object before, Object after, DiffMetadata diffMetadata);
1616

1717
}

‎src/test/java/com/github/jonpereiradev/diffobjects/DiffObjectsWithAnnotationsTest.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ public void testDiffObjectsWithNullAfterStateEqualsMustThrowNullPointerException
3535
public void testDiffObjectsWithEqualsObjectElementMustReturnDiffWithEquals() {
3636
ObjectElement objectA = new ObjectElement("Object");
3737
ObjectElement objectB = new ObjectElement("Object");
38-
List<DiffResult<?>> results = DiffObjects.diff(objectA, objectB);
38+
List<DiffResult> results = DiffObjects.diff(objectA, objectB);
3939

4040
Assert.assertFalse(results.isEmpty());
4141
Assert.assertEquals(1, results.size());
@@ -48,7 +48,7 @@ public void testDiffObjectsWithEqualsObjectElementMustReturnDiffWithEquals() {
4848
public void testDiffObjectsWithDifferentObjectElementMustReturnDiffWithDifference() {
4949
ObjectElement objectA = new ObjectElement("Object A");
5050
ObjectElement objectB = new ObjectElement("Object B");
51-
List<DiffResult<?>> results = DiffObjects.diff(objectA, objectB);
51+
List<DiffResult> results = DiffObjects.diff(objectA, objectB);
5252

5353
Assert.assertFalse(results.isEmpty());
5454
Assert.assertEquals(1, results.size());

‎src/test/java/com/github/jonpereiradev/diffobjects/DiffObjectsWithBuilderTest.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ public void testDiffObjectsWithNullConfigurationEqualsStateMustThrowNullPointerE
5757
public void testDiffObjectsWithEqualsObjectElementMustReturnResultWithEquals() {
5858
ObjectElement objectA = new ObjectElement("Object");
5959
ObjectElement objectB = new ObjectElement("Object");
60-
List<DiffResult<?>> results = DiffObjects.diff(objectA, objectB, configuration);
60+
List<DiffResult> results = DiffObjects.diff(objectA, objectB, configuration);
6161

6262
Assert.assertFalse(results.isEmpty());
6363
Assert.assertEquals(1, results.size());
@@ -70,7 +70,7 @@ public void testDiffObjectsWithEqualsObjectElementMustReturnResultWithEquals() {
7070
public void testDiffObjectsWithDifferentObjectElementMustReturnResultWithDifference() {
7171
ObjectElement objectA = new ObjectElement("Object A");
7272
ObjectElement objectB = new ObjectElement("Object B");
73-
List<DiffResult<?>> results = DiffObjects.diff(objectA, objectB, configuration);
73+
List<DiffResult> results = DiffObjects.diff(objectA, objectB, configuration);
7474

7575
Assert.assertFalse(results.isEmpty());
7676
Assert.assertEquals(1, results.size());

‎src/test/java/com/github/jonpereiradev/diffobjects/strategy/DiffCollectionStrategyTest.java‎

Lines changed: 42 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ public void beforeTest() {
2828

2929
@Test
3030
public void testCollectionStrategyEqualsNullObjects() {
31-
DiffResult<List<ObjectElement>> diffResult = diffStrategy.diff(null, null, diffMetadata);
31+
DiffResult diffResult = diffStrategy.diff(null, null, diffMetadata);
3232

3333
Assert.assertNotNull(diffResult);
3434
Assert.assertTrue(diffResult.isEquals());
@@ -40,7 +40,7 @@ public void testCollectionStrategyEqualsNullObjects() {
4040
public void testCollectionStrategyEqualsObjectsNullLists() {
4141
ComplexElement complexA = new ComplexElement((List<ObjectElement>) null);
4242
ComplexElement complexB = new ComplexElement((List<ObjectElement>) null);
43-
DiffResult<List<ObjectElement>> diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
43+
DiffResult diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
4444

4545
Assert.assertNotNull(diffResult);
4646
Assert.assertTrue(diffResult.isEquals());
@@ -52,7 +52,7 @@ public void testCollectionStrategyEqualsObjectsNullLists() {
5252
public void testCollectionStrategyEqualsObjectsEmptyLists() {
5353
ComplexElement complexA = new ComplexElement(new ArrayList<ObjectElement>());
5454
ComplexElement complexB = new ComplexElement(new ArrayList<ObjectElement>());
55-
DiffResult<List<ObjectElement>> diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
55+
DiffResult diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
5656

5757
Assert.assertNotNull(diffResult);
5858
Assert.assertTrue(diffResult.isEquals());
@@ -64,7 +64,7 @@ public void testCollectionStrategyEqualsObjectsEmptyLists() {
6464
public void testCollectionStrategyDifferentObjectsNullListA() {
6565
ComplexElement complexA = new ComplexElement((List<ObjectElement>) null);
6666
ComplexElement complexB = new ComplexElement(new ArrayList<ObjectElement>());
67-
DiffResult<List<ObjectElement>> diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
67+
DiffResult diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
6868

6969
Assert.assertNotNull(diffResult);
7070
Assert.assertTrue(diffResult.isEquals());
@@ -76,7 +76,7 @@ public void testCollectionStrategyDifferentObjectsNullListA() {
7676
public void testCollectionStrategyDifferentObjectsNullListB() {
7777
ComplexElement complexA = new ComplexElement(new ArrayList<ObjectElement>());
7878
ComplexElement complexB = new ComplexElement((List<ObjectElement>) null);
79-
DiffResult<List<ObjectElement>> diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
79+
DiffResult diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
8080

8181
Assert.assertNotNull(diffResult);
8282
Assert.assertTrue(diffResult.isEquals());
@@ -93,17 +93,19 @@ public void testCollectionStrategyDifferentObjectsDifferentSizeList() {
9393
complexB.getObjectElementList().add(new ObjectElement("Object B.A"));
9494
complexB.getObjectElementList().add(new ObjectElement("Object B.B"));
9595

96-
DiffResult<List<ObjectElement>> diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
96+
DiffResult diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
97+
List<ObjectElement> beforeCollection = (List<ObjectElement>) diffResult.getBefore();
98+
List<ObjectElement> afterCollection = (List<ObjectElement>) diffResult.getAfter();
9799

98100
Assert.assertNotNull(diffResult);
99101
Assert.assertFalse(diffResult.isEquals());
100-
Assert.assertNotNull(diffResult.getBefore());
102+
Assert.assertNotNull(beforeCollection);
101103
Assert.assertNotNull(diffResult.getAfter());
102-
Assert.assertTrue(diffResult.getBefore().size() == 1);
103-
Assert.assertEquals("Object A.A", diffResult.getBefore().get(0).getName());
104-
Assert.assertTrue(diffResult.getAfter().size() == 2);
105-
Assert.assertEquals("Object B.A", diffResult.getAfter().get(0).getName());
106-
Assert.assertEquals("Object B.B", diffResult.getAfter().get(1).getName());
104+
Assert.assertEquals(1, beforeCollection.size());
105+
Assert.assertEquals("Object A.A", beforeCollection.get(0).getName());
106+
Assert.assertTrue(afterCollection.size() == 2);
107+
Assert.assertEquals("Object B.A", afterCollection.get(0).getName());
108+
Assert.assertEquals("Object B.B", afterCollection.get(1).getName());
107109
}
108110

109111
@Test
@@ -114,16 +116,18 @@ public void testCollectionStrategyDifferentObjectsSameSizeList() {
114116
complexA.getObjectElementList().add(new ObjectElement("Object A.A"));
115117
complexB.getObjectElementList().add(new ObjectElement("Object B.A"));
116118

117-
DiffResult<List<ObjectElement>> diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
119+
DiffResult diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
120+
List<ObjectElement> beforeCollection = (List<ObjectElement>) diffResult.getBefore();
121+
List<ObjectElement> afterCollection = (List<ObjectElement>) diffResult.getAfter();
118122

119123
Assert.assertNotNull(diffResult);
120124
Assert.assertFalse(diffResult.isEquals());
121125
Assert.assertNotNull(diffResult.getBefore());
122126
Assert.assertNotNull(diffResult.getAfter());
123-
Assert.assertTrue(diffResult.getBefore().size() == 1);
124-
Assert.assertEquals("Object A.A", diffResult.getBefore().get(0).getName());
125-
Assert.assertTrue(diffResult.getAfter().size() == 1);
126-
Assert.assertEquals("Object B.A", diffResult.getAfter().get(0).getName());
127+
Assert.assertEquals(1, beforeCollection.size());
128+
Assert.assertEquals("Object A.A", beforeCollection.get(0).getName());
129+
Assert.assertEquals(1,afterCollection.size());
130+
Assert.assertEquals("Object B.A", afterCollection.get(0).getName());
127131
}
128132

129133
@Test
@@ -135,16 +139,18 @@ public void testCollectionStrategySameObjectsSameSizeList() {
135139
complexA.getObjectElementList().add(objectElement);
136140
complexB.getObjectElementList().add(objectElement);
137141

138-
DiffResult<List<ObjectElement>> diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
142+
DiffResult diffResult = diffStrategy.diff(complexA, complexB, diffMetadata);
143+
List<ObjectElement> beforeCollection = (List<ObjectElement>) diffResult.getBefore();
144+
List<ObjectElement> afterCollection = (List<ObjectElement>) diffResult.getAfter();
139145

140146
Assert.assertNotNull(diffResult);
141147
Assert.assertTrue(diffResult.isEquals());
142148
Assert.assertNotNull(diffResult.getBefore());
143149
Assert.assertNotNull(diffResult.getAfter());
144-
Assert.assertTrue(diffResult.getBefore().size() == 1);
145-
Assert.assertEquals("Object", diffResult.getBefore().get(0).getName());
146-
Assert.assertTrue(diffResult.getAfter().size() == 1);
147-
Assert.assertEquals("Object", diffResult.getAfter().get(0).getName());
150+
Assert.assertEquals(1, beforeCollection.size());
151+
Assert.assertEquals("Object", beforeCollection.get(0).getName());
152+
Assert.assertEquals(1,afterCollection.size());
153+
Assert.assertEquals("Object", afterCollection.get(0).getName());
148154
}
149155

150156
@Test
@@ -155,16 +161,18 @@ public void testCollectionStrategySameObjectsByNameSameSizeList() {
155161
complexA.getObjectElementListByName().add(new ObjectElement("Object"));
156162
complexB.getObjectElementListByName().add(new ObjectElement("Object"));
157163

158-
DiffResult<List<ObjectElement>> diffResult = diffStrategy.diff(complexA, complexB, diffMetadataByName);
164+
DiffResult diffResult = diffStrategy.diff(complexA, complexB, diffMetadataByName);
165+
List<ObjectElement> beforeCollection = (List<ObjectElement>) diffResult.getBefore();
166+
List<ObjectElement> afterCollection = (List<ObjectElement>) diffResult.getAfter();
159167

160168
Assert.assertNotNull(diffResult);
161169
Assert.assertTrue(diffResult.isEquals());
162170
Assert.assertNotNull(diffResult.getBefore());
163171
Assert.assertNotNull(diffResult.getAfter());
164-
Assert.assertTrue(diffResult.getBefore().size() == 1);
165-
Assert.assertEquals("Object", diffResult.getBefore().get(0).getName());
166-
Assert.assertTrue(diffResult.getAfter().size() == 1);
167-
Assert.assertEquals("Object", diffResult.getAfter().get(0).getName());
172+
Assert.assertEquals(1, beforeCollection.size());
173+
Assert.assertEquals("Object", beforeCollection.get(0).getName());
174+
Assert.assertEquals(1,afterCollection.size());
175+
Assert.assertEquals("Object", afterCollection.get(0).getName());
168176
}
169177

170178
@Test
@@ -175,15 +183,17 @@ public void testCollectionStrategyDifferentObjectsByNameSameSizeList() {
175183
complexA.getObjectElementListByName().add(new ObjectElement("Object A"));
176184
complexB.getObjectElementListByName().add(new ObjectElement("Object B"));
177185

178-
DiffResult<List<ObjectElement>> diffResult = diffStrategy.diff(complexA, complexB, diffMetadataByName);
186+
DiffResult diffResult = diffStrategy.diff(complexA, complexB, diffMetadataByName);
187+
List<ObjectElement> beforeCollection = (List<ObjectElement>) diffResult.getBefore();
188+
List<ObjectElement> afterCollection = (List<ObjectElement>) diffResult.getAfter();
179189

180190
Assert.assertNotNull(diffResult);
181191
Assert.assertFalse(diffResult.isEquals());
182192
Assert.assertNotNull(diffResult.getBefore());
183193
Assert.assertNotNull(diffResult.getAfter());
184-
Assert.assertTrue(diffResult.getBefore().size() == 1);
185-
Assert.assertEquals("Object A", diffResult.getBefore().get(0).getName());
186-
Assert.assertTrue(diffResult.getAfter().size() == 1);
187-
Assert.assertEquals("Object B", diffResult.getAfter().get(0).getName());
194+
Assert.assertEquals(1, beforeCollection.size());
195+
Assert.assertEquals("Object A", beforeCollection.get(0).getName());
196+
Assert.assertEquals(1, afterCollection.size());
197+
Assert.assertEquals("Object B", afterCollection.get(0).getName());
188198
}
189199
}

0 commit comments

Comments
 (0)