Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit aff3eae

Browse files
committed
Improved test coverage
1 parent 8ef3a14 commit aff3eae

File tree

11 files changed

+588
-60
lines changed

11 files changed

+588
-60
lines changed

‎src/integration-test/java/de/danielbechler/diff/categories/CategoriesTestIT.groovy‎ renamed to ‎src/integration-test/java/de/danielbechler/diff/category/CategoriesTestIT.groovy‎

Lines changed: 17 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,20 @@
1-
package de.danielbechler.diff.categories
1+
/*
2+
* Copyright 2016 Daniel Bechler
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* http://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
17+
package de.danielbechler.diff.category
218

319
import de.danielbechler.diff.ObjectDifferBuilder
420
import de.danielbechler.diff.introspection.ObjectDiffProperty
Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
/*
2+
* Copyright 2016 Daniel Bechler
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* http://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
17+
package de.danielbechler.diff;
18+
19+
import de.danielbechler.diff.category.CategoryResolver;
20+
import de.danielbechler.diff.comparison.ComparisonStrategy;
21+
import de.danielbechler.diff.comparison.ComparisonStrategyResolver;
22+
import de.danielbechler.diff.comparison.PrimitiveDefaultValueMode;
23+
import de.danielbechler.diff.comparison.PrimitiveDefaultValueModeResolver;
24+
import de.danielbechler.diff.filtering.IsReturnableResolver;
25+
import de.danielbechler.diff.inclusion.IsIgnoredResolver;
26+
import de.danielbechler.diff.introspection.IsIntrospectableResolver;
27+
import de.danielbechler.diff.node.DiffNode;
28+
29+
import java.util.Set;
30+
31+
class DefaultNodeQueryService implements NodeQueryService
32+
{
33+
private final CategoryResolver categoryResolver;
34+
private final IsIntrospectableResolver introspectableResolver;
35+
private final IsIgnoredResolver ignoredResolver;
36+
private final IsReturnableResolver returnableResolver;
37+
private final ComparisonStrategyResolver comparisonStrategyResolver;
38+
private final PrimitiveDefaultValueModeResolver primitiveDefaultValueModeResolver;
39+
40+
public DefaultNodeQueryService(final CategoryResolver categoryResolver,
41+
final IsIntrospectableResolver introspectableResolver,
42+
final IsIgnoredResolver ignoredResolver,
43+
final IsReturnableResolver returnableResolver,
44+
final ComparisonStrategyResolver comparisonStrategyResolver,
45+
final PrimitiveDefaultValueModeResolver primitiveDefaultValueModeResolver)
46+
{
47+
this.categoryResolver = categoryResolver;
48+
this.introspectableResolver = introspectableResolver;
49+
this.ignoredResolver = ignoredResolver;
50+
this.returnableResolver = returnableResolver;
51+
this.comparisonStrategyResolver = comparisonStrategyResolver;
52+
this.primitiveDefaultValueModeResolver = primitiveDefaultValueModeResolver;
53+
}
54+
55+
public Set<String> resolveCategories(final DiffNode node)
56+
{
57+
return categoryResolver.resolveCategories(node);
58+
}
59+
60+
public boolean isIntrospectable(final DiffNode node)
61+
{
62+
return introspectableResolver.isIntrospectable(node);
63+
}
64+
65+
public boolean isIgnored(final DiffNode node)
66+
{
67+
return ignoredResolver.isIgnored(node);
68+
}
69+
70+
public boolean isReturnable(final DiffNode node)
71+
{
72+
return returnableResolver.isReturnable(node);
73+
}
74+
75+
public ComparisonStrategy resolveComparisonStrategy(final DiffNode node)
76+
{
77+
return comparisonStrategyResolver.resolveComparisonStrategy(node);
78+
}
79+
80+
public PrimitiveDefaultValueMode resolvePrimitiveDefaultValueMode(final DiffNode node)
81+
{
82+
return primitiveDefaultValueModeResolver.resolvePrimitiveDefaultValueMode(node);
83+
}
84+
}

‎src/main/java/de/danielbechler/diff/ObjectDifferBuilder.java‎

Lines changed: 48 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -22,14 +22,14 @@
2222
import de.danielbechler.diff.circular.CircularReferenceService;
2323
import de.danielbechler.diff.comparison.ComparisonConfigurer;
2424
import de.danielbechler.diff.comparison.ComparisonService;
25-
import de.danielbechler.diff.comparison.ComparisonStrategy;
26-
import de.danielbechler.diff.comparison.PrimitiveDefaultValueMode;
2725
import de.danielbechler.diff.differ.BeanDiffer;
2826
import de.danielbechler.diff.differ.CollectionDiffer;
27+
import de.danielbechler.diff.differ.Differ;
2928
import de.danielbechler.diff.differ.DifferConfigurer;
3029
import de.danielbechler.diff.differ.DifferDispatcher;
3130
import de.danielbechler.diff.differ.DifferFactory;
3231
import de.danielbechler.diff.differ.DifferProvider;
32+
import de.danielbechler.diff.differ.DifferService;
3333
import de.danielbechler.diff.differ.MapDiffer;
3434
import de.danielbechler.diff.differ.PrimitiveDiffer;
3535
import de.danielbechler.diff.filtering.FilteringConfigurer;
@@ -39,11 +39,9 @@
3939
import de.danielbechler.diff.inclusion.InclusionService;
4040
import de.danielbechler.diff.introspection.IntrospectionConfigurer;
4141
import de.danielbechler.diff.introspection.IntrospectionService;
42-
import de.danielbechler.diff.node.DiffNode;
4342

4443
import java.util.ArrayList;
4544
import java.util.Collection;
46-
import java.util.Set;
4745

4846
/**
4947
* This is the entry point of every diffing operation. It acts as a factory to
@@ -61,12 +59,17 @@ public class ObjectDifferBuilder
6159
private final IdentityService identityService = new IdentityService(this);
6260
private final ReturnableNodeService returnableNodeService = new ReturnableNodeService(this);
6361
private final CircularReferenceService circularReferenceService = new CircularReferenceService(this);
64-
private final DifferConfigurer differConfigurer = new DifferConfigurerImpl();
65-
private final NodeQueryService nodeQueryService = new NodeQueryServiceImpl();
66-
private final Collection<DifferFactory> differFactories = new ArrayList<DifferFactory>();
62+
private final DifferService differService = new DifferService(this);
63+
private final NodeQueryService nodeQueryService;
6764

6865
private ObjectDifferBuilder()
6966
{
67+
nodeQueryService = new DefaultNodeQueryService(categoryService,
68+
introspectionService,
69+
inclusionService,
70+
returnableNodeService,
71+
comparisonService,
72+
comparisonService);
7073
}
7174

7275
/**
@@ -143,87 +146,76 @@ public CategoryConfigurer categories()
143146

144147
public DifferConfigurer differs()
145148
{
146-
return differConfigurer;
149+
return differService;
147150
}
148151

149152
public static ObjectDiffer buildDefault()
150153
{
151154
return startBuilding().build();
152155
}
153156

157+
public static ObjectDifferBuilder startBuilding()
158+
{
159+
return new ObjectDifferBuilder();
160+
}
161+
154162
public ObjectDiffer build()
155163
{
156164
final DifferProvider differProvider = new DifferProvider();
157-
final DifferDispatcher differDispatcher = new DifferDispatcher(
165+
final DifferDispatcher differDispatcher = newDifferDispatcher(differProvider);
166+
differProvider.push(newBeanDiffer(differDispatcher));
167+
differProvider.push(newCollectionDiffer(differDispatcher));
168+
differProvider.push(newMapDiffer(differDispatcher));
169+
differProvider.push(newPrimitiveDiffer());
170+
differProvider.pushAll(createCustomDiffers(differDispatcher));
171+
return new ObjectDiffer(differDispatcher);
172+
}
173+
174+
private DifferDispatcher newDifferDispatcher(final DifferProvider differProvider)
175+
{
176+
return new DifferDispatcher(
158177
differProvider,
159178
circularReferenceService,
160179
circularReferenceService,
161180
inclusionService,
162181
returnableNodeService,
163182
introspectionService,
164183
categoryService);
165-
differProvider.push(new BeanDiffer(
184+
}
185+
186+
private Differ newBeanDiffer(final DifferDispatcher differDispatcher)
187+
{
188+
return new BeanDiffer(
166189
differDispatcher,
167190
introspectionService,
168191
returnableNodeService,
169192
comparisonService,
170-
introspectionService));
171-
differProvider.push(new CollectionDiffer(differDispatcher, comparisonService, identityService));
172-
differProvider.push(new MapDiffer(differDispatcher, comparisonService));
173-
differProvider.push(new PrimitiveDiffer(comparisonService));
174-
for (final DifferFactory differFactory : differFactories)
175-
{
176-
differProvider.push(differFactory.createDiffer(differDispatcher, nodeQueryService));
177-
}
178-
return new ObjectDiffer(differDispatcher);
193+
introspectionService);
179194
}
180195

181-
publicstaticObjectDifferBuilderstartBuilding()
196+
privateDiffernewCollectionDiffer(finalDifferDispatcherdifferDispatcher)
182197
{
183-
return new ObjectDifferBuilder();
198+
return new CollectionDiffer(differDispatcher, comparisonService, identityService);
184199
}
185200

186-
publicclassDifferConfigurerImplimplementsDifferConfigurer
201+
privateDiffernewMapDiffer(finalDifferDispatcherdifferDispatcher)
187202
{
188-
public ObjectDifferBuilder register(final DifferFactory differFactory)
189-
{
190-
differFactories.add(differFactory);
191-
return ObjectDifferBuilder.this;
192-
}
193-
203+
return new MapDiffer(differDispatcher, comparisonService);
194204
}
195205

196-
private classNodeQueryServiceImplimplementsNodeQueryService
206+
private DiffernewPrimitiveDiffer()
197207
{
198-
public Set<String> resolveCategories(final DiffNode node)
199-
{
200-
return categoryService.resolveCategories(node);
201-
}
202-
203-
public boolean isIntrospectable(final DiffNode node)
204-
{
205-
return introspectionService.isIntrospectable(node);
206-
}
207-
208-
public boolean isIgnored(final DiffNode node)
209-
{
210-
return inclusionService.isIgnored(node);
211-
}
212-
213-
public boolean isReturnable(final DiffNode node)
214-
{
215-
return returnableNodeService.isReturnable(node);
216-
}
217-
218-
public ComparisonStrategy resolveComparisonStrategy(final DiffNode node)
219-
{
220-
return comparisonService.resolveComparisonStrategy(node);
221-
}
208+
return new PrimitiveDiffer(comparisonService);
209+
}
222210

223-
public PrimitiveDefaultValueMode resolvePrimitiveDefaultValueMode(
224-
final DiffNode node)
211+
private Iterable<Differ> createCustomDiffers(final DifferDispatcher differDispatcher)
212+
{
213+
final Collection<DifferFactory> differFactories = differService.getDifferFactories();
214+
final Collection<Differ> differs = new ArrayList<Differ>(differFactories.size());
215+
for (final DifferFactory differFactory : differFactories)
225216
{
226-
returncomparisonService.resolvePrimitiveDefaultValueMode(node);
217+
differs.add(differFactory.createDiffer(differDispatcher, nodeQueryService));
227218
}
219+
return differs;
228220
}
229221
}

‎src/main/java/de/danielbechler/diff/differ/DifferProvider.java‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,14 @@ public void push(final Differ differ)
3131
differs.add(0, differ);
3232
}
3333

34+
public void pushAll(final Iterable<Differ> differs)
35+
{
36+
for (final Differ differ : differs)
37+
{
38+
push(differ);
39+
}
40+
}
41+
3442
public Differ retrieveDifferForType(final Class<?> type)
3543
{
3644
if (type == null)
Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
/*
2+
* Copyright 2016 Daniel Bechler
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* http://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
17+
package de.danielbechler.diff.differ;
18+
19+
import de.danielbechler.diff.ObjectDifferBuilder;
20+
import de.danielbechler.util.Assert;
21+
22+
import java.util.ArrayList;
23+
import java.util.Collection;
24+
import java.util.Collections;
25+
26+
public class DifferService implements DifferConfigurer
27+
{
28+
private final ObjectDifferBuilder objectDifferBuilder;
29+
private final Collection<DifferFactory> differFactories = new ArrayList<DifferFactory>();
30+
31+
public DifferService(final ObjectDifferBuilder objectDifferBuilder)
32+
{
33+
Assert.notNull(objectDifferBuilder, "objectDifferBuilder");
34+
this.objectDifferBuilder = objectDifferBuilder;
35+
}
36+
37+
public ObjectDifferBuilder register(final DifferFactory differFactory)
38+
{
39+
Assert.notNull(differFactory, "differFactory");
40+
differFactories.add(differFactory);
41+
return objectDifferBuilder;
42+
}
43+
44+
public Collection<DifferFactory> getDifferFactories()
45+
{
46+
return Collections.unmodifiableCollection(differFactories);
47+
}
48+
}

‎src/main/java/de/danielbechler/diff/node/CategoryFilteringVisitor.java‎

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@
2525
* @author Daniel Bechler
2626
*/
2727
@SuppressWarnings("UnusedDeclaration")
28-
public abstractclass CategoryFilteringVisitor extends AbstractFilteringVisitor
28+
public class CategoryFilteringVisitor extends AbstractFilteringVisitor
2929
{
3030
private final Collection<String> include = new TreeSet<String>();
3131
private final Collection<String> exclude = new TreeSet<String>();
@@ -72,7 +72,13 @@ public final CategoryFilteringVisitor include(final String category)
7272
return this;
7373
}
7474

75-
@SuppressWarnings({"UnusedDeclaration"})
75+
/**
76+
* @deprecated This method is confusing. The name implies only nodes with the given category
77+
* will be included, but that's not the case. Instead every previously included category will
78+
* also be included. On top of that every excluded category will remain excluded. This method
79+
* will be removed in future versions until the feature is explicitly requested.
80+
*/
81+
@Deprecated
7682
public final CategoryFilteringVisitor includeOnly(final String category)
7783
{
7884
include(category);
@@ -86,7 +92,6 @@ public final CategoryFilteringVisitor includeAllNonExcluded(final boolean value)
8692
return this;
8793
}
8894

89-
@SuppressWarnings({"UnusedDeclaration"})
9095
public final CategoryFilteringVisitor exclude(final String category)
9196
{
9297
exclude.add(category);

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /