Spring/spring-data-commons
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

DATACMNS-867 - Additional Java 8 language feature cleanup.

Browse Source 
Make use of lambdas and method references though out the codebase. Remove no longer required generic type parameters.
Additionally remove unused imports and replace single element list initialization with dedicated singletonList.
Use Assertion overloads taking Supplier for dynamic assertion error messages.
This commit is contained in:
Christoph Strobl
2017-02-15 12:06:09 +01:00
committed by Oliver Gierke
parent aa4c51e1ea
commit be347eaaab
176 changed files with 673 additions and 797 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
src/test/java/org/springframework/data/util/ClassTypeInformationUnitTests.java
View File

@@ -48,9 +48,9 @@ public class ClassTypeInformationUnitTests {
OptionalAssert<TypeInformation<?>> assertThat = assertOptional(discoverer.getProperty("content"));
assertThat.value(it -> it.getType()).isEqualTo(String.class);
assertThat.flatMap(it -> it.getComponentType()).isNotPresent();
assertThat.flatMap(it -> it.getMapValueType()).isNotPresent();
assertThat.value(TypeInformation::getType).isEqualTo(String.class);
assertThat.flatMap(TypeInformation::getComponentType).isNotPresent();
assertThat.flatMap(TypeInformation::getMapValueType).isNotPresent();
}
@Test
@@ -60,11 +60,11 @@ public class ClassTypeInformationUnitTests {
assertThat(discoverer.getType()).isEqualTo(ConcreteWrapper.class);
assertOptional(discoverer.getProperty("wrapped")).andAssert(inner -> {
inner.value(it -> it.getType()).isEqualTo(GenericType.class);
inner.flatMap(it -> it.getProperty("content")).value(it -> it.getType()).isEqualTo(String.class);
inner.value(TypeInformation::getType).isEqualTo(GenericType.class);
inner.flatMap(it -> it.getProperty("content")).value(TypeInformation::getType).isEqualTo(String.class);
});
assertOptional(discoverer.getProperty("wrapped.content")).value(it -> it.getType()).isEqualTo(String.class);
assertOptional(discoverer.getProperty("wrapped.content")).value(TypeInformation::getType).isEqualTo(String.class);
}
@Test
@@ -72,7 +72,7 @@ public class ClassTypeInformationUnitTests {
public void discoversBoundType() {
TypeInformation<GenericTypeWithBound> information = ClassTypeInformation.from(GenericTypeWithBound.class);
assertOptional(information.getProperty("person")).value(it -> it.getType()).isEqualTo(Person.class);
assertOptional(information.getProperty("person")).value(TypeInformation::getType).isEqualTo(Person.class);
}
@Test
@@ -80,7 +80,7 @@ public class ClassTypeInformationUnitTests {
TypeInformation<SpecialGenericTypeWithBound> information = ClassTypeInformation
.from(SpecialGenericTypeWithBound.class);
assertOptional(information.getProperty("person")).value(it -> it.getType()).isEqualTo(SpecialPerson.class);
assertOptional(information.getProperty("person")).value(TypeInformation::getType).isEqualTo(SpecialPerson.class);
}
@Test
@@ -89,8 +89,8 @@ public class ClassTypeInformationUnitTests {
TypeInformation<AnotherGenericType> information = ClassTypeInformation.from(AnotherGenericType.class);
assertOptional(information.getProperty("nested")).value(it -> it.getType()).isEqualTo(GenericTypeWithBound.class);
assertOptional(information.getProperty("nested.person")).value(it -> it.getType()).isEqualTo(Person.class);
assertOptional(information.getProperty("nested")).value(TypeInformation::getType).isEqualTo(GenericTypeWithBound.class);
assertOptional(information.getProperty("nested.person")).value(TypeInformation::getType).isEqualTo(Person.class);
}
@Test
@@ -100,25 +100,25 @@ public class ClassTypeInformationUnitTests {
OptionalAssert<TypeInformation<?>> optional = assertOptional(information.getProperty("array"));
optional.flatMap(it -> it.getComponentType()).value(it -> it.getType()).isEqualTo(String.class);
optional.value(it -> it.getType()).satisfies(it -> {
optional.flatMap(TypeInformation::getComponentType).value(TypeInformation::getType).isEqualTo(String.class);
optional.value(TypeInformation::getType).satisfies(it -> {
assertThat(it).isEqualTo(String[].class);
assertThat(it.isArray()).isTrue();
});
optional = assertOptional(information.getProperty("foo"));
optional.value(it -> it.getType()).isEqualTo(Collection[].class);
optional.flatMap(it -> it.getComponentType()).andAssert(it -> {
it.value(inner -> inner.getType()).isEqualTo(Collection.class);
it.flatMap(inner -> inner.getComponentType()).value(inner -> inner.getType()).isEqualTo(String.class);
optional.value(TypeInformation::getType).isEqualTo(Collection[].class);
optional.flatMap(TypeInformation::getComponentType).andAssert(it -> {
it.value(TypeInformation::getType).isEqualTo(Collection.class);
it.flatMap(TypeInformation::getComponentType).value(TypeInformation::getType).isEqualTo(String.class);
});
optional = assertOptional(information.getProperty("rawSet"));
optional.value(it -> it.getType()).isEqualTo(Set.class);
optional.flatMap(it -> it.getComponentType()).value(it -> it.getType()).isEqualTo(Object.class);
optional.flatMap(it -> it.getMapValueType()).isNotPresent();
optional.value(TypeInformation::getType).isEqualTo(Set.class);
optional.flatMap(TypeInformation::getComponentType).value(TypeInformation::getType).isEqualTo(Object.class);
optional.flatMap(TypeInformation::getMapValueType).isNotPresent();
}
@Test
@@ -127,13 +127,13 @@ public class ClassTypeInformationUnitTests {
TypeInformation<StringMapContainer> information = ClassTypeInformation.from(StringMapContainer.class);
OptionalAssert<TypeInformation<?>> assertion = assertOptional(information.getProperty("genericMap"));
assertion.value(it -> it.getType()).isEqualTo(Map.class);
assertion.flatMap(it -> it.getMapValueType()).value(it -> it.getType()).isEqualTo(String.class);
assertion.value(TypeInformation::getType).isEqualTo(Map.class);
assertion.flatMap(TypeInformation::getMapValueType).value(TypeInformation::getType).isEqualTo(String.class);
assertion = assertOptional(information.getProperty("map"));
assertion.value(it -> it.getType()).isEqualTo(Map.class);
assertion.flatMap(it -> it.getMapValueType()).value(it -> it.getType()).isEqualTo(Calendar.class);
assertion.value(TypeInformation::getType).isEqualTo(Map.class);
assertion.flatMap(TypeInformation::getMapValueType).value(TypeInformation::getType).isEqualTo(Calendar.class);
}
@Test
@@ -150,8 +150,8 @@ public class ClassTypeInformationUnitTests {
TypeInformation<PropertyGetter> from = ClassTypeInformation.from(PropertyGetter.class);
assertOptional(from.getProperty("_name")).value(it -> it.getType()).isEqualTo(String.class);
assertOptional(from.getProperty("name")).value(it -> it.getType()).isEqualTo(byte[].class);
assertOptional(from.getProperty("_name")).value(TypeInformation::getType).isEqualTo(String.class);
assertOptional(from.getProperty("name")).value(TypeInformation::getType).isEqualTo(byte[].class);
}
@Test // DATACMNS-77
@@ -168,15 +168,15 @@ public class ClassTypeInformationUnitTests {
OptionalAssert<TypeInformation<?>> assertion = assertOptional(information.getProperty("wildcard"));
assertion.value(it -> it.isCollectionLike()).isEqualTo(true);
assertion.flatMap(it -> it.getComponentType()).value(it -> it.getType()).isEqualTo(String.class);
assertion.value(TypeInformation::isCollectionLike).isEqualTo(true);
assertion.flatMap(TypeInformation::getComponentType).value(TypeInformation::getType).isEqualTo(String.class);
assertion = assertOptional(information.getProperty("complexWildcard"));
assertion.value(it -> it.isCollectionLike()).isEqualTo(true);
assertion.flatMap(it -> it.getComponentType()).andAssert(it -> {
it.value(inner -> inner.isCollectionLike()).isEqualTo(true);
it.flatMap(inner -> inner.getComponentType()).value(inner -> inner.getType()).isEqualTo(String.class);
assertion.value(TypeInformation::isCollectionLike).isEqualTo(true);
assertion.flatMap(TypeInformation::getComponentType).andAssert(it -> {
it.value(TypeInformation::isCollectionLike).isEqualTo(true);
it.flatMap(TypeInformation::getComponentType).value(TypeInformation::getType).isEqualTo(String.class);
});
}
@@ -266,7 +266,7 @@ public class ClassTypeInformationUnitTests {
TypeInformation<?> information = from(String[][].class);
assertThat(information.getType()).isEqualTo(String[][].class);
assertOptional(information.getComponentType()).value(it -> it.getType()).isEqualTo(String[].class);
assertOptional(information.getComponentType()).value(TypeInformation::getType).isEqualTo(String[].class);
assertThat(information.getActualType().getActualType().getType()).isEqualTo(String.class);
}
@@ -299,17 +299,17 @@ public class ClassTypeInformationUnitTests {
assertion//
// Type
.andAssert(inner -> inner.value(it -> it.getType()).isEqualTo(SortedMap.class))//
.andAssert(inner -> inner.value(TypeInformation::getType).isEqualTo(SortedMap.class))//
// Map value type
.andAssert(inner -> inner.flatMap(it -> it.getMapValueType()).andAssert(value -> {
value.value(it -> it.getType()).isEqualTo(SortedMap.class);
value.flatMap(it -> it.getComponentType()).value(it -> it.getType()).isEqualTo(String.class);
.andAssert(inner -> inner.flatMap(TypeInformation::getMapValueType).andAssert(value -> {
value.value(TypeInformation::getType).isEqualTo(SortedMap.class);
value.flatMap(TypeInformation::getComponentType).value(TypeInformation::getType).isEqualTo(String.class);
// Nested value type
}).flatMap(it -> it.getMapValueType()).andAssert(nestedValue -> {
nestedValue.value(it -> it.getType()).isEqualTo(List.class);
nestedValue.flatMap(it -> it.getComponentType()).value(it -> it.getType()).isEqualTo(Person.class);
}).flatMap(TypeInformation::getMapValueType).andAssert(nestedValue -> {
nestedValue.value(TypeInformation::getType).isEqualTo(List.class);
nestedValue.flatMap(TypeInformation::getComponentType).value(TypeInformation::getType).isEqualTo(Person.class);
}));
}
@@ -325,9 +325,9 @@ public class ClassTypeInformationUnitTests {
ClassTypeInformation<ConcreteRoot> rootType = from(ConcreteRoot.class);
assertOptional(rootType.getProperty("subs"))//
.map(it -> it.getActualType())//
.map(TypeInformation::getActualType)//
.flatMap(it -> it.getProperty("subSub"))//
.value(it -> it.getType()).isEqualTo(ConcreteSubSub.class);
.value(TypeInformation::getType).isEqualTo(ConcreteSubSub.class);
}
@Test // DATACMNS-594
@@ -335,7 +335,7 @@ public class ClassTypeInformationUnitTests {
assertOptional(ClassTypeInformation.from(ConcreteRootIntermediate.class)
.getProperty("intermediate.content.intermediate.content"))//
.value(it -> it.getType()).isEqualTo(Leaf.class);
.value(TypeInformation::getType).isEqualTo(Leaf.class);
}
@Test // DATACMNS-783, DATACMNS-853
@@ -346,9 +346,9 @@ public class ClassTypeInformationUnitTests {
assertOptional(root.getProperty("abstractBar"))//
.map(it -> it.specialize(ClassTypeInformation.from(Bar.class)))//
.andAssert(inner -> {
inner.value(it -> it.getType()).isEqualTo(Bar.class);
inner.flatMap(it -> it.getProperty("field")).value(it -> it.getType()).isEqualTo(Character.class);
inner.flatMap(it -> it.getProperty("anotherField")).value(it -> it.getType()).isEqualTo(Integer.class);
inner.value(TypeInformation::getType).isEqualTo(Bar.class);
inner.flatMap(it -> it.getProperty("field")).value(TypeInformation::getType).isEqualTo(Character.class);
inner.flatMap(it -> it.getProperty("anotherField")).value(TypeInformation::getType).isEqualTo(Integer.class);
});
}
@@ -385,7 +385,7 @@ public class ClassTypeInformationUnitTests {
ClassTypeInformation<Concrete> information = ClassTypeInformation.from(Concrete.class);
assertOptional(information.getProperty("field")).value(it -> it.getType()).isEqualTo(Nested.class);
assertOptional(information.getProperty("field")).value(TypeInformation::getType).isEqualTo(Nested.class);
}
@Test // DATACMNS-940
@@ -393,9 +393,7 @@ public class ClassTypeInformationUnitTests {
ClassTypeInformation<SampleTraversable> information = ClassTypeInformation.from(SampleTraversable.class);
assertThat(information.getComponentType()).hasValueSatisfying(it -> {
assertThat(it.getType()).isAssignableFrom(Integer.class);
});
assertThat(information.getComponentType()).hasValueSatisfying(it -> assertThat(it.getType()).isAssignableFrom(Integer.class));
}
@Test // DATACMNS-940
@@ -403,13 +401,9 @@ public class ClassTypeInformationUnitTests {
ClassTypeInformation<SampleMap> information = ClassTypeInformation.from(SampleMap.class);
assertThat(information.getComponentType()).hasValueSatisfying(it -> {
assertThat(it.getType()).isAssignableFrom(String.class);
});
assertThat(information.getComponentType()).hasValueSatisfying(it -> assertThat(it.getType()).isAssignableFrom(String.class));
assertThat(information.getMapValueType()).hasValueSatisfying(it -> {
assertThat(it.getType()).isAssignableFrom(Integer.class);
});
assertThat(information.getMapValueType()).hasValueSatisfying(it -> assertThat(it.getType()).isAssignableFrom(Integer.class));
}
static class StringMapContainer extends MapContainer<String> {

6
src/test/java/org/springframework/data/util/DataCmns511Tests.java
View File

@@ -37,16 +37,16 @@ public class DataCmns511Tests {
ClassTypeInformation.from(AbstractRole.class).getProperty("createdBy"));
assertion.flatMap(it -> it.getProperty("roles"))//
.map(it -> it.getActualType())//
.map(TypeInformation::getActualType)//
.flatMap(it -> it.getProperty("createdBy"))//
.andAssert(second -> {
OptionalAssert<TypeInformation<?>> third = second.flatMap(it -> it.getProperty("roles"))//
.map(it -> it.getActualType())//
.map(TypeInformation::getActualType)//
.flatMap(it -> it.getProperty("createdBy"));
second.isEqualTo(third);
second.value(it -> it.hashCode()).isEqualTo(third.getActual().hashCode());
second.value(Object::hashCode).isEqualTo(third.getActual().hashCode());
});
}

4
src/test/java/org/springframework/data/util/OptionalAssert.java
View File

@@ -35,7 +35,7 @@ public class OptionalAssert<T> extends org.assertj.core.api.OptionalAssert<T> {
}
public static <T> OptionalAssert<T> assertOptional(Optional<T> optional) {
return new OptionalAssert<T>(optional);
return new OptionalAssert<>(optional);
}
public Optional<T> getActual() {
@@ -60,7 +60,7 @@ public class OptionalAssert<T> extends org.assertj.core.api.OptionalAssert<T> {
Assertions.assertThat(actual).isPresent();
return Assertions.assertThat(actual.map(function).orElseThrow(() -> new IllegalStateException()));
return Assertions.assertThat(actual.map(function).orElseThrow(IllegalStateException::new));
}
public OptionalAssert<T> isEqualTo(OptionalAssert<?> other) {

24
src/test/java/org/springframework/data/util/ParameterizedTypeUnitTests.java
View File

@@ -85,19 +85,19 @@ public class ParameterizedTypeUnitTests {
OptionalAssert<TypeInformation<?>> assertion = assertOptional(propertyType);
assertion.flatMap(it -> it.getProperty("value")).value(it -> it.getType()).isEqualTo(String.class);
assertion.flatMap(it -> it.getMapValueType()).value(it -> it.getType()).isEqualTo(String.class);
assertion.flatMap(it -> it.getProperty("value")).value(TypeInformation::getType).isEqualTo(String.class);
assertion.flatMap(TypeInformation::getMapValueType).value(TypeInformation::getType).isEqualTo(String.class);
propertyType = type.getProperty("param2");
assertion.flatMap(it -> it.getProperty("value")).value(it -> it.getType()).isEqualTo(String.class);
assertion.flatMap(it -> it.getMapValueType()).value(it -> it.getType()).isEqualTo(String.class);
assertion.flatMap(it -> it.getProperty("value")).value(TypeInformation::getType).isEqualTo(String.class);
assertion.flatMap(TypeInformation::getMapValueType).value(TypeInformation::getType).isEqualTo(String.class);
}
@Test // DATACMNS-446
public void createsToStringRepresentation() {
assertOptional(from(Foo.class).getProperty("param")).value(it -> it.toString())
assertOptional(from(Foo.class).getProperty("param")).value(Object::toString)
.isEqualTo("org.springframework.data.util.ParameterizedTypeUnitTests$Localized<java.lang.String>");
}
@@ -110,11 +110,7 @@ public class ParameterizedTypeUnitTests {
assertThat(first).isEqualTo(second);
assertThat(first).hasValueSatisfying(left -> {
assertThat(second).hasValueSatisfying(right -> {
assertThat(left.hashCode()).isEqualTo(right.hashCode());
});
});
assertThat(first).hasValueSatisfying(left -> assertThat(second).hasValueSatisfying(right -> assertThat(left.hashCode()).isEqualTo(right.hashCode())));
}
@Test // DATACMNS-485
@@ -123,7 +119,7 @@ public class ParameterizedTypeUnitTests {
Optional<TypeInformation<?>> type = from(First.class).getProperty("property");
assertOptional(type).map(it -> it.getActualType()).isEqualTo(type);
assertOptional(type).map(TypeInformation::getActualType).isEqualTo(type);
}
@Test // DATACMNS-697
@@ -132,9 +128,9 @@ public class ParameterizedTypeUnitTests {
TypeInformation<NormalizedProfile> information = ClassTypeInformation.from(NormalizedProfile.class);
assertOptional(information.getProperty("education2.data"))//
.flatMap(it -> it.getComponentType())//
.flatMap(TypeInformation::getComponentType)//
.flatMap(it -> it.getProperty("value"))//
.value(it -> it.getType())//
.value(TypeInformation::getType)//
.isEqualTo(Education.class);
}
@@ -145,7 +141,7 @@ public class ParameterizedTypeUnitTests {
ClassTypeInformation.from(Bar.class).getProperty("param"));
assertion.hasValueSatisfying(it -> assertThat(it).isInstanceOf(ParameterizedTypeInformation.class));
assertion.flatMap(it -> it.getMapValueType()).isEmpty();
assertion.flatMap(TypeInformation::getMapValueType).isEmpty();
}
@SuppressWarnings("serial")

2
src/test/java/org/springframework/data/util/StreamUtilsTests.java
View File

@@ -38,7 +38,7 @@ public class StreamUtilsTests {
List<String> input = Arrays.asList("a", "b", "c");
Stream<String> stream = createStreamFromIterator(input.iterator());
List<String> output = stream.collect(Collectors.<String> toList());
List<String> output = stream.collect(Collectors.toList());
assertThat(input).isEqualTo(output);
}

30
src/test/java/org/springframework/data/util/TypeDiscovererUnitTests.java
View File

@@ -75,9 +75,9 @@ public class TypeDiscovererUnitTests {
public void dealsWithTypesReferencingThemselves() {
TypeInformation<SelfReferencing> information = from(SelfReferencing.class);
Optional<TypeInformation<?>> first = information.getProperty("parent").flatMap(it -> it.getMapValueType());
Optional<TypeInformation<?>> first = information.getProperty("parent").flatMap(TypeInformation::getMapValueType);
Optional<TypeInformation<?>> second = first.flatMap(it -> it.getProperty("map"))
.flatMap(it -> it.getMapValueType());
.flatMap(TypeInformation::getMapValueType);
assertThat(second).isEqualTo(first);
}
@@ -88,9 +88,7 @@ public class TypeDiscovererUnitTests {
TypeInformation<SelfReferencingMap> information = from(SelfReferencingMap.class);
Optional<TypeInformation<?>> property = information.getProperty("map");
assertThat(property).hasValueSatisfying(it -> {
assertThat(it.getMapValueType()).hasValue(information);
});
assertThat(property).hasValueSatisfying(it -> assertThat(it.getMapValueType()).hasValue(information));
}
@Test
@@ -98,13 +96,9 @@ public class TypeDiscovererUnitTests {
TypeInformation<?> discoverer = new TypeDiscoverer<>(CustomMap.class, EMPTY_MAP);
assertThat(discoverer.getMapValueType()).hasValueSatisfying(it -> {
assertThat(it.getType()).isEqualTo(Locale.class);
});
assertThat(discoverer.getMapValueType()).hasValueSatisfying(it -> assertThat(it.getType()).isEqualTo(Locale.class));
assertThat(discoverer.getComponentType()).hasValueSatisfying(it -> {
assertThat(it.getType()).isEqualTo(String.class);
});
assertThat(discoverer.getComponentType()).hasValueSatisfying(it -> assertThat(it.getType()).isEqualTo(String.class));
}
@Test
@@ -112,19 +106,15 @@ public class TypeDiscovererUnitTests {
TypeDiscoverer<CustomCollection> discoverer = new TypeDiscoverer<>(CustomCollection.class, firstMap);
assertThat(discoverer.getComponentType()).hasValueSatisfying(it -> {
assertThat(it.getType()).isEqualTo(String.class);
});
assertThat(discoverer.getComponentType()).hasValueSatisfying(it -> assertThat(it.getType()).isEqualTo(String.class));
}
@Test
public void returnsComponentTypeForArrays() {
TypeDiscoverer<String[]> discoverer = new TypeDiscoverer<String[]>(String[].class, EMPTY_MAP);
TypeDiscoverer<String[]> discoverer = new TypeDiscoverer<>(String[].class, EMPTY_MAP);
assertThat(discoverer.getComponentType()).hasValueSatisfying(it -> {
assertThat(it.getType()).isEqualTo(String.class);
});
assertThat(discoverer.getComponentType()).hasValueSatisfying(it -> assertThat(it.getType()).isEqualTo(String.class));
}
@Test // DATACMNS-57
@@ -137,9 +127,7 @@ public class TypeDiscovererUnitTests {
assertThat(types).hasSize(2);
assertThat(types.get(0).getType()).isEqualTo(List.class);
assertThat(types.get(0).getComponentType()).hasValueSatisfying(it -> {
assertThat(it.getType()).isEqualTo(String.class);
});
assertThat(types.get(0).getComponentType()).hasValueSatisfying(it -> assertThat(it.getType()).isEqualTo(String.class));
}
@Test

4
src/test/java/org/springframework/data/util/TypeInformationAssert.java
View File

@@ -22,9 +22,7 @@ public class TypeInformationAssert extends AbstractAssert<TypeInformationAssert,
public TypeInformationAssert hasComponentType(Class<?> type) {
Assertions.assertThat(actual.getComponentType()).hasValueSatisfying(it -> {
Assertions.assertThat(it.getType()).isEqualTo(type);
});
Assertions.assertThat(actual.getComponentType()).hasValueSatisfying(it -> Assertions.assertThat(it.getType()).isEqualTo(type));
return this;
}

2
src/test/java/org/springframework/data/util/VersionUnitTests.java
View File

@@ -157,7 +157,7 @@ public class VersionUnitTests {
public void rejectsNonNumericPartOnNonLastPosition() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(Matchers.<Throwable> instanceOf(IllegalArgumentException.class));
exception.expectCause(Matchers.instanceOf(IllegalArgumentException.class));
exception.expectMessage("1.RELEASE.2");
Version.parse("1.RELEASE.2");