DATACMNS-867 - Second draft.

src/test/java/org/springframework/data/auditing/config/AuditingBeanDefinitionRegistrarSupportUnitTests.java

@@ -14,7 +14,7 @@
  */
 package org.springframework.data.auditing.config;
 
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.lang.annotation.Annotation;

src/test/java/org/springframework/data/convert/ClassGeneratingEntityInstantiatorUnitTests.java

@@ -16,7 +16,7 @@
 package org.springframework.data.convert;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 import static org.springframework.data.util.ClassTypeInformation.*;
 
@@ -24,9 +24,7 @@ import java.lang.reflect.Constructor;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
-import java.util.stream.Collectors;
 import java.util.stream.IntStream;
-import java.util.stream.Stream;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -279,12 +277,6 @@ public class ClassGeneratingEntityInstantiatorUnitTests<P extends PersistentProp
 		});
 	}
 
-	@Test
-	public void testname() {
-
-		List<String> result = Stream.of("1", null).map(it -> (String) null).collect(Collectors.toList());
-	}
-
 	static class Foo {
 
 		Foo(String foo) {

src/test/java/org/springframework/data/convert/ConfigurableTypeInformationMapperUnitTests.java

@@ -25,9 +25,9 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.data.mapping.Alias;
 import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.data.util.ClassTypeInformation;
-import org.springframework.data.util.TypeInformation;
 
 /**
  * Unit tests for {@link ConfigurableTypeMapper}.
@@ -62,15 +62,14 @@ public class ConfigurableTypeInformationMapperUnitTests<T extends PersistentProp
 	@Test
 	public void writesMapKeyForType() {
 
-		assertThat(mapper.createAliasFor(ClassTypeInformation.from(String.class))).isEqualTo("1");
-		assertThat(mapper.createAliasFor(ClassTypeInformation.from(Object.class))).isNull();
+		assertThat(mapper.createAliasFor(ClassTypeInformation.from(String.class))).isEqualTo(Alias.of("1"));
+		assertThat(mapper.createAliasFor(ClassTypeInformation.from(Object.class))).isEqualTo(Alias.NONE);
 	}
 
 	@Test
-	@SuppressWarnings("rawtypes")
 	public void readsTypeForMapKey() {
 
-		assertThat(mapper.resolveTypeFrom("1")).isEqualTo((TypeInformation) ClassTypeInformation.from(String.class));
-		assertThat(mapper.resolveTypeFrom("unmapped")).isNull();
+		assertThat(mapper.resolveTypeFrom(Alias.of("1"))).hasValue(ClassTypeInformation.from(String.class));
+		assertThat(mapper.resolveTypeFrom(Alias.of("unmapped"))).isEmpty();
 	}
 }

src/test/java/org/springframework/data/convert/DefaultTypeMapperUnitTests.java

@@ -21,13 +21,16 @@ import static org.mockito.Mockito.*;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Map;
+import java.util.Optional;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.data.mapping.Alias;
 import org.springframework.data.util.ClassTypeInformation;
+import org.springframework.data.util.OptionalAssert;
 import org.springframework.data.util.TypeInformation;
 
 /**
@@ -39,10 +42,9 @@ import org.springframework.data.util.TypeInformation;
 public class DefaultTypeMapperUnitTests {
 
 	static final TypeInformation<String> STRING_TYPE_INFO = ClassTypeInformation.from(String.class);
-	static final String STRING = String.class.getName();
+	static final Alias ALIAS = Alias.of(String.class.getName());
 
 	@Mock TypeAliasAccessor<Map<String, String>> accessor;
-
 	@Mock TypeInformationMapper mapper;
 
 	DefaultTypeMapper<Map<String, String>> typeMapper;
@@ -52,29 +54,28 @@ public class DefaultTypeMapperUnitTests {
 	public void setUp() {
 
 		this.typeMapper = new DefaultTypeMapper<Map<String, String>>(accessor, Arrays.asList(mapper));
-		this.source = Collections.singletonMap("key", STRING);
+		this.source = Collections.singletonMap("key", ALIAS.toString());
 
-		doReturn(STRING).when(accessor).readAliasFrom(source);
-		doReturn(STRING_TYPE_INFO).when(mapper).resolveTypeFrom(STRING);
+		doReturn(ALIAS).when(accessor).readAliasFrom(source);
+		doReturn(Optional.of(STRING_TYPE_INFO)).when(mapper).resolveTypeFrom(ALIAS);
 	}
 
 	@Test
-	@SuppressWarnings("rawtypes")
 	public void cachesResolvedTypeInformation() {
 
-		TypeInformation<?> information = typeMapper.readType(source);
-		assertThat(information).isEqualTo((TypeInformation) STRING_TYPE_INFO);
-		verify(mapper, times(1)).resolveTypeFrom(STRING);
+		Optional<TypeInformation<?>> information = typeMapper.readType(source);
+		assertThat(information).hasValue(STRING_TYPE_INFO);
+		verify(mapper, times(1)).resolveTypeFrom(ALIAS);
 
 		typeMapper.readType(source);
-		verify(mapper, times(1)).resolveTypeFrom(STRING);
+		verify(mapper, times(1)).resolveTypeFrom(ALIAS);
 	}
 
 	@Test // DATACMNS-349
 	public void returnsTypeAliasForInformation() {
 
-		Object alias = "alias";
-		when(mapper.createAliasFor(STRING_TYPE_INFO)).thenReturn(alias);
+		Alias alias = Alias.of("alias");
+		doReturn(alias).when(mapper).createAliasFor(STRING_TYPE_INFO);
 
 		assertThat(this.typeMapper.getAliasFor(STRING_TYPE_INFO)).isEqualTo(alias);
 	}
@@ -83,16 +84,22 @@ public class DefaultTypeMapperUnitTests {
 	public void specializesRawSourceTypeUsingGenericContext() {
 
 		ClassTypeInformation<Foo> root = ClassTypeInformation.from(Foo.class);
-		TypeInformation<?> propertyType = root.getProperty("abstractBar");
+		TypeInformation<?> propertyType = root.getProperty("abstractBar")
+				.orElseThrow(() -> new IllegalStateException("Property abstractBar not found!"));
 		TypeInformation<?> barType = ClassTypeInformation.from(Bar.class);
 
-		doReturn(barType).when(accessor).readAliasFrom(source);
-		doReturn(barType).when(mapper).resolveTypeFrom(barType);
+		doReturn(Alias.of(barType)).when(accessor).readAliasFrom(source);
+		doReturn(Optional.of(barType)).when(mapper).resolveTypeFrom(Alias.of(barType));
 
 		TypeInformation<?> result = typeMapper.readType(source, propertyType);
 
-		assertThat(result.getType()).isEqualTo(Bar.class);
-		assertThat(result.getProperty("field").getType()).isEqualTo(Character.class);
+		assertThat(result).isInstanceOf(TypeInformation.class);
+
+		TypeInformation<?> typeInformation = TypeInformation.class.cast(result);
+
+		assertThat(typeInformation.getType()).isEqualTo(Bar.class);
+		OptionalAssert.assertOptional(typeInformation.getProperty("field")).value(nested -> nested.getType())
+				.isEqualTo(Character.class);
 	}
 
 	static class TypeWithAbstractGenericType<T> {

src/test/java/org/springframework/data/convert/MappingContextTypeInformationMapperUnitTests.java

@@ -23,12 +23,12 @@ import java.util.Collections;
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.data.annotation.TypeAlias;
+import org.springframework.data.mapping.Alias;
 import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.context.SampleMappingContext;
 import org.springframework.data.mapping.context.SamplePersistentProperty;
 import org.springframework.data.util.AnnotatedTypeScanner;
 import org.springframework.data.util.ClassTypeInformation;
-import org.springframework.data.util.TypeInformation;
 
 /**
  * Unit tests for {@link MappingContextTypeInformationMapper}.
@@ -58,7 +58,7 @@ public class MappingContextTypeInformationMapperUnitTests {
 
 		mapper = new MappingContextTypeInformationMapper(mappingContext);
 
-		assertThat(mapper.createAliasFor(ClassTypeInformation.from(Entity.class))).isEqualTo("foo");
+		assertThat(mapper.createAliasFor(ClassTypeInformation.from(Entity.class)).hasValue("foo")).isTrue();
 	}
 
 	@Test
@@ -69,7 +69,7 @@ public class MappingContextTypeInformationMapperUnitTests {
 
 		mapper = new MappingContextTypeInformationMapper(mappingContext);
 
-		assertThat(mapper.createAliasFor(from(Entity.class))).isEqualTo("foo");
+		assertThat(mapper.createAliasFor(from(Entity.class)).hasValue("foo")).isTrue();
 	}
 
 	@Test
@@ -79,23 +79,22 @@ public class MappingContextTypeInformationMapperUnitTests {
 		mappingContext.initialize();
 
 		mapper = new MappingContextTypeInformationMapper(mappingContext);
-		assertThat(mapper.createAliasFor(from(String.class))).isNull();
+		assertThat(mapper.createAliasFor(from(String.class)).isPresent()).isFalse();
 	}
 
 	@Test
-	@SuppressWarnings("rawtypes")
 	public void detectsTypeForUnknownEntity() {
 
 		SampleMappingContext mappingContext = new SampleMappingContext();
 		mappingContext.initialize();
 
 		mapper = new MappingContextTypeInformationMapper(mappingContext);
-		assertThat(mapper.resolveTypeFrom("foo")).isNull();
+		assertThat(mapper.resolveTypeFrom(Alias.of("foo"))).isEmpty();
 
-		PersistentEntity<?, SamplePersistentProperty> entity = mappingContext.getPersistentEntity(Entity.class);
+		PersistentEntity<?, SamplePersistentProperty> entity = mappingContext.getRequiredPersistentEntity(Entity.class);
 
 		assertThat(entity).isNotNull();
-		assertThat(mapper.resolveTypeFrom("foo")).isEqualTo((TypeInformation) from(Entity.class));
+		assertThat(mapper.resolveTypeFrom(Alias.of("foo"))).hasValue(from(Entity.class));
 	}
 
 	@Test // DATACMNS-485

src/test/java/org/springframework/data/convert/ReflectionEntityInstantiatorUnitTests.java

@@ -16,7 +16,7 @@
 package org.springframework.data.convert;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 import static org.springframework.data.convert.ReflectionEntityInstantiator.*;
 import static org.springframework.data.util.ClassTypeInformation.*;
@@ -81,7 +81,6 @@ public class ReflectionEntityInstantiatorUnitTests<P extends PersistentProperty<
 		Optional<? extends PreferredConstructor<Foo, P>> constructor = new PreferredConstructorDiscoverer<Foo, P>(Foo.class)
 				.getConstructor();
 
-		doReturn(Foo.class).when(entity).getType();
 		doReturn(constructor).when(entity).getPersistenceConstructor();
 		doReturn(Optional.empty()).when(provider).getParameterValue(any());
 

src/test/java/org/springframework/data/convert/SimpleTypeInformationMapperUnitTests.java

@@ -17,7 +17,10 @@ package org.springframework.data.convert;
 
 import static org.assertj.core.api.Assertions.*;
 
+import java.util.Optional;
+
 import org.junit.Test;
+import org.springframework.data.mapping.Alias;
 import org.springframework.data.util.ClassTypeInformation;
 import org.springframework.data.util.TypeInformation;
 
@@ -28,46 +31,38 @@ import org.springframework.data.util.TypeInformation;
  */
 public class SimpleTypeInformationMapperUnitTests {
 
+	TypeInformationMapper mapper = new SimpleTypeInformationMapper();
+
 	@Test
-	@SuppressWarnings({ "rawtypes" })
 	public void resolvesTypeByLoadingClass() {
 
-		TypeInformationMapper mapper = new SimpleTypeInformationMapper();
-		TypeInformation type = mapper.resolveTypeFrom("java.lang.String");
+		Optional<TypeInformation<?>> type = mapper.resolveTypeFrom(Alias.of("java.lang.String"));
 
-		TypeInformation expected = ClassTypeInformation.from(String.class);
+		TypeInformation<?> expected = ClassTypeInformation.from(String.class);
 
-		assertThat(type).isEqualTo(expected);
+		assertThat(type).hasValue(expected);
 	}
 
 	@Test
 	public void returnsNullForNonStringKey() {
-
-		TypeInformationMapper mapper = new SimpleTypeInformationMapper();
-		assertThat(mapper.resolveTypeFrom(new Object())).isNull();
+		assertThat(mapper.resolveTypeFrom(Alias.of(new Object()))).isEmpty();
 	}
 
 	@Test
 	public void returnsNullForEmptyTypeKey() {
-
-		TypeInformationMapper mapper = new SimpleTypeInformationMapper();
-		assertThat(mapper.resolveTypeFrom("")).isNull();
+		assertThat(mapper.resolveTypeFrom(Alias.of(""))).isEmpty();
 	}
 
 	@Test
 	public void returnsNullForUnloadableClass() {
 
-		TypeInformationMapper mapper = new SimpleTypeInformationMapper();
-		assertThat(mapper.resolveTypeFrom("Foo")).isNull();
+		assertThat(mapper.resolveTypeFrom(Alias.of("Foo"))).isEmpty();
 	}
 
 	@Test
 	public void usesFullyQualifiedClassNameAsTypeKey() {
 
-		TypeInformationMapper mapper = new SimpleTypeInformationMapper();
-		Object alias = mapper.createAliasFor(ClassTypeInformation.from(String.class));
-
-		assertThat(alias).isInstanceOf(String.class);
-		assertThat(alias).isEqualTo(String.class.getName());
+		assertThat(mapper.createAliasFor(ClassTypeInformation.from(String.class)))
+				.isEqualTo(Alias.of(String.class.getName()));
 	}
 }

src/test/java/org/springframework/data/domain/PageImplUnitTests.java

@@ -23,7 +23,6 @@ import java.util.Collections;
 import java.util.List;
 
 import org.junit.Test;
-import org.springframework.core.convert.converter.Converter;
 
 /**
  * Unit test for {@link PageImpl}.
@@ -35,76 +34,76 @@ public class PageImplUnitTests {
 	@Test
 	public void assertEqualsForSimpleSetup() throws Exception {
 
-		PageImpl<String> page = new PageImpl<String>(Arrays.asList("Foo"));
+		PageImpl<String> page = new PageImpl<>(Arrays.asList("Foo"));
 
 		assertEqualsAndHashcode(page, page);
-		assertEqualsAndHashcode(page, new PageImpl<String>(Arrays.asList("Foo")));
+		assertEqualsAndHashcode(page, new PageImpl<>(Arrays.asList("Foo")));
 	}
 
 	@Test
 	public void assertEqualsForComplexSetup() throws Exception {
 
-		Pageable pageable = new PageRequest(0, 10);
+		Pageable pageable = PageRequest.of(0, 10);
 		List<String> content = Arrays.asList("Foo");
 
-		PageImpl<String> page = new PageImpl<String>(content, pageable, 100);
+		PageImpl<String> page = new PageImpl<>(content, pageable, 100);
 
 		assertEqualsAndHashcode(page, page);
-		assertEqualsAndHashcode(page, new PageImpl<String>(content, pageable, 100));
-		assertNotEqualsAndHashcode(page, new PageImpl<String>(content, pageable, 90));
-		assertNotEqualsAndHashcode(page, new PageImpl<String>(content, new PageRequest(1, 10), 100));
-		assertNotEqualsAndHashcode(page, new PageImpl<String>(content, new PageRequest(0, 15), 100));
+		assertEqualsAndHashcode(page, new PageImpl<>(content, pageable, 100));
+		assertNotEqualsAndHashcode(page, new PageImpl<>(content, pageable, 90));
+		assertNotEqualsAndHashcode(page, new PageImpl<>(content, PageRequest.of(1, 10), 100));
+		assertNotEqualsAndHashcode(page, new PageImpl<>(content, PageRequest.of(0, 15), 100));
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void preventsNullContentForSimpleSetup() throws Exception {
-		new PageImpl<Object>(null);
+		new PageImpl<>(null);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void preventsNullContentForAdvancedSetup() throws Exception {
-		new PageImpl<Object>(null, null, 0);
+		new PageImpl<>(null, null, 0);
 	}
 
 	@Test
 	public void returnsNextPageable() {
 
-		Page<Object> page = new PageImpl<Object>(Arrays.asList(new Object()), new PageRequest(0, 1), 10);
+		Page<Object> page = new PageImpl<>(Arrays.asList(new Object()), PageRequest.of(0, 1), 10);
 
 		assertThat(page.isFirst()).isTrue();
 		assertThat(page.hasPrevious()).isFalse();
-		assertThat(page.previousPageable()).isNull();
+		assertThat(page.previousPageable()).isEqualTo(Pageable.NONE);
 
 		assertThat(page.isLast()).isFalse();
 		assertThat(page.hasNext()).isTrue();
-		assertThat(page.nextPageable()).isEqualTo((Pageable) new PageRequest(1, 1));
+		assertThat(page.nextPageable()).isEqualTo((Pageable) PageRequest.of(1, 1));
 	}
 
 	@Test
 	public void returnsPreviousPageable() {
 
-		Page<Object> page = new PageImpl<Object>(Arrays.asList(new Object()), new PageRequest(1, 1), 2);
+		Page<Object> page = new PageImpl<>(Arrays.asList(new Object()), PageRequest.of(1, 1), 2);
 
 		assertThat(page.isFirst()).isFalse();
 		assertThat(page.hasPrevious()).isTrue();
-		assertThat(page.previousPageable()).isEqualTo((Pageable) new PageRequest(0, 1));
+		assertThat(page.previousPageable()).isEqualTo((Pageable) PageRequest.of(0, 1));
 
 		assertThat(page.isLast()).isTrue();
 		assertThat(page.hasNext()).isFalse();
-		assertThat(page.nextPageable()).isNull();
+		assertThat(page.nextPageable()).isEqualTo(Pageable.NONE);
 	}
 
 	@Test
 	public void createsPageForEmptyContentCorrectly() {
 
 		List<String> list = Collections.emptyList();
-		Page<String> page = new PageImpl<String>(list);
+		Page<String> page = new PageImpl<>(list);
 
 		assertThat(page.getContent()).isEqualTo(list);
 		assertThat(page.getNumber()).isEqualTo(0);
 		assertThat(page.getNumberOfElements()).isEqualTo(0);
 		assertThat(page.getSize()).isEqualTo(0);
-		assertThat(page.getSort()).isEqualTo((Sort) null);
+		assertThat(page.getSort()).isEqualTo(Sort.unsorted());
 		assertThat(page.getTotalElements()).isEqualTo(0L);
 		assertThat(page.getTotalPages()).isEqualTo(1);
 		assertThat(page.hasNext()).isFalse();
@@ -117,7 +116,7 @@ public class PageImplUnitTests {
 	@Test // DATACMNS-323
 	public void returnsCorrectTotalPages() {
 
-		Page<String> page = new PageImpl<String>(Arrays.asList("a"));
+		Page<String> page = new PageImpl<>(Arrays.asList("a"));
 
 		assertThat(page.getTotalPages()).isEqualTo(1);
 		assertThat(page.hasNext()).isFalse();
@@ -127,13 +126,8 @@ public class PageImplUnitTests {
 	@Test // DATACMNS-635
 	public void transformsPageCorrectly() {
 
-		Page<Integer> transformed = new PageImpl<String>(Arrays.asList("foo", "bar"), new PageRequest(0, 2), 10)
-				.map(new Converter<String, Integer>() {
-					@Override
-					public Integer convert(String source) {
-						return source.length();
-					}
-				});
+		Page<Integer> transformed = new PageImpl<>(Arrays.asList("foo", "bar"), PageRequest.of(0, 2), 10)
+				.map(source -> source.length());
 
 		assertThat(transformed.getContent()).hasSize(2);
 		assertThat(transformed.getContent()).contains(3, 3);
@@ -141,32 +135,30 @@ public class PageImplUnitTests {
 
 	@Test // DATACMNS-713
 	public void adaptsTotalForLastPageOnIntermediateDeletion() {
-		assertThat(new PageImpl<String>(Arrays.asList("foo", "bar"), new PageRequest(0, 5), 3).getTotalElements())
-				.isEqualTo(2L);
+		assertThat(new PageImpl<>(Arrays.asList("foo", "bar"), PageRequest.of(0, 5), 3).getTotalElements()).isEqualTo(2L);
 	}
 
 	@Test // DATACMNS-713
 	public void adaptsTotalForLastPageOnIntermediateInsertion() {
-		assertThat(new PageImpl<String>(Arrays.asList("foo", "bar"), new PageRequest(0, 5), 1).getTotalElements())
-				.isEqualTo(2L);
+		assertThat(new PageImpl<>(Arrays.asList("foo", "bar"), PageRequest.of(0, 5), 1).getTotalElements()).isEqualTo(2L);
 	}
 
 	@Test // DATACMNS-713
 	public void adaptsTotalForLastPageOnIntermediateDeletionOnLastPate() {
-		assertThat(new PageImpl<String>(Arrays.asList("foo", "bar"), new PageRequest(1, 10), 13).getTotalElements())
+		assertThat(new PageImpl<>(Arrays.asList("foo", "bar"), PageRequest.of(1, 10), 13).getTotalElements())
 				.isEqualTo(12L);
 	}
 
 	@Test // DATACMNS-713
 	public void adaptsTotalForLastPageOnIntermediateInsertionOnLastPate() {
-		assertThat(new PageImpl<String>(Arrays.asList("foo", "bar"), new PageRequest(1, 10), 11).getTotalElements())
+		assertThat(new PageImpl<>(Arrays.asList("foo", "bar"), PageRequest.of(1, 10), 11).getTotalElements())
 				.isEqualTo(12L);
 	}
 
 	@Test // DATACMNS-713
 	public void doesNotAdapttotalIfPageIsEmpty() {
 
-		assertThat(new PageImpl<String>(Collections.<String> emptyList(), new PageRequest(1, 10), 0).getTotalElements())
+		assertThat(new PageImpl<>(Collections.<String>emptyList(), PageRequest.of(1, 10), 0).getTotalElements())
 				.isEqualTo(0L);
 	}
 }

src/test/java/org/springframework/data/domain/PageRequestUnitTests.java

@@ -33,32 +33,32 @@ public class PageRequestUnitTests extends AbstractPageRequestUnitTests {
 	 */
 	@Override
 	public AbstractPageRequest newPageRequest(int page, int size) {
-		return this.newPageRequest(page, size, null);
+		return PageRequest.of(page, size);
 	}
 
 	public AbstractPageRequest newPageRequest(int page, int size, Sort sort) {
-		return new PageRequest(page, size, sort);
+		return PageRequest.of(page, size, sort);
 	}
 
 	@Test
 	public void equalsRegardsSortCorrectly() {
 
 		Sort sort = new Sort(Direction.DESC, "foo");
-		AbstractPageRequest request = new PageRequest(0, 10, sort);
+		AbstractPageRequest request = PageRequest.of(0, 10, sort);
 
 		// Equals itself
 		assertEqualsAndHashcode(request, request);
 
 		// Equals another instance with same setup
-		assertEqualsAndHashcode(request, new PageRequest(0, 10, sort));
+		assertEqualsAndHashcode(request, PageRequest.of(0, 10, sort));
 
 		// Equals without sort entirely
-		assertEqualsAndHashcode(new PageRequest(0, 10), new PageRequest(0, 10));
+		assertEqualsAndHashcode(PageRequest.of(0, 10), PageRequest.of(0, 10));
 
 		// Is not equal to instance without sort
-		assertNotEqualsAndHashcode(request, new PageRequest(0, 10));
+		assertNotEqualsAndHashcode(request, PageRequest.of(0, 10));
 
 		// Is not equal to instance with another sort
-		assertNotEqualsAndHashcode(request, new PageRequest(0, 10, Direction.ASC, "foo"));
+		assertNotEqualsAndHashcode(request, PageRequest.of(0, 10, Direction.ASC, "foo"));
 	}
 }

src/test/java/org/springframework/data/domain/RangeUnitTests.java

@@ -29,13 +29,13 @@ public class RangeUnitTests {
 
 	@Test(expected = IllegalArgumentException.class) // DATACMNS-651
 	public void rejectsNullReferenceValuesForContains() {
-		new Range<Long>(10L, 20L).contains(null);
+		new Range<>(10L, 20L).contains(null);
 	}
 
 	@Test // DATACMNS-651
 	public void usesBoundsInclusivelyByDefault() {
 
-		Range<Long> range = new Range<Long>(10L, 20L);
+		Range<Long> range = new Range<>(10L, 20L);
 
 		assertThat(range.contains(10L)).isTrue();
 		assertThat(range.contains(20L)).isTrue();
@@ -47,7 +47,7 @@ public class RangeUnitTests {
 	@Test // DATACMNS-651
 	public void excludesLowerBoundIfConfigured() {
 
-		Range<Long> range = new Range<Long>(10L, 20L, false, true);
+		Range<Long> range = new Range<>(10L, 20L, false, true);
 
 		assertThat(range.contains(10L)).isFalse();
 		assertThat(range.contains(20L)).isTrue();
@@ -59,7 +59,7 @@ public class RangeUnitTests {
 	@Test // DATACMNS-651
 	public void excludesUpperBoundIfConfigured() {
 
-		Range<Long> range = new Range<Long>(10L, 20L, true, false);
+		Range<Long> range = new Range<>(10L, 20L, true, false);
 
 		assertThat(range.contains(10L)).isTrue();
 		assertThat(range.contains(20L)).isFalse();
@@ -71,7 +71,7 @@ public class RangeUnitTests {
 	@Test // DATACMNS-651
 	public void handlesOpenUpperBoundCorrectly() {
 
-		Range<Long> range = new Range<Long>(10L, null);
+		Range<Long> range = new Range<>(10L, null);
 
 		assertThat(range.contains(10L)).isTrue();
 		assertThat(range.contains(20L)).isTrue();
@@ -83,7 +83,7 @@ public class RangeUnitTests {
 	@Test // DATACMNS-651
 	public void handlesOpenLowerBoundCorrectly() {
 
-		Range<Long> range = new Range<Long>(null, 20L);
+		Range<Long> range = new Range<>(null, 20L);
 
 		assertThat(range.contains(10L)).isTrue();
 		assertThat(range.contains(20L)).isTrue();

src/test/java/org/springframework/data/domain/SortUnitTests.java

@@ -39,7 +39,7 @@ public class SortUnitTests {
 	@Test
 	public void appliesDefaultForOrder() throws Exception {
 
-		assertThat(new Sort("foo").iterator().next().getDirection()).isEqualTo(Sort.DEFAULT_DIRECTION);
+		assertThat(Sort.by("foo").iterator().next().getDirection()).isEqualTo(Sort.DEFAULT_DIRECTION);
 		assertThat(new Sort((Direction) null, "foo").iterator().next().getDirection()).isEqualTo(Sort.DEFAULT_DIRECTION);
 	}
 
@@ -90,14 +90,14 @@ public class SortUnitTests {
 	@Test
 	public void allowsCombiningSorts() {
 
-		Sort sort = new Sort("foo").and(new Sort("bar"));
+		Sort sort = Sort.by("foo").and(Sort.by("bar"));
 		assertThat(sort).containsExactly(new Sort.Order("foo"), new Sort.Order("bar"));
 	}
 
 	@Test
 	public void handlesAdditionalNullSort() {
 
-		Sort sort = new Sort("foo").and(null);
+		Sort sort = Sort.by("foo").and(null);
 		assertThat(sort).containsExactly(new Sort.Order("foo"));
 	}
 
@@ -147,9 +147,9 @@ public class SortUnitTests {
 		Order source = new Order(Direction.DESC, "foo").nullsFirst().ignoreCase();
 		Order result = source.withProperty("bar");
 
-		assertThat(result.getProperty(), is("bar"));
-		assertThat(result.getDirection(), is(source.getDirection()));
-		assertThat(result.getNullHandling(), is(source.getNullHandling()));
-		assertThat(result.isIgnoreCase(), is(source.isIgnoreCase()));
+		assertThat(result.getProperty()).isEqualTo("bar");
+		assertThat(result.getDirection()).isEqualTo(source.getDirection());
+		assertThat(result.getNullHandling()).isEqualTo(source.getNullHandling());
+		assertThat(result.isIgnoreCase()).isEqualTo(source.isIgnoreCase());
 	}
 }

src/test/java/org/springframework/data/domain/jaxb/SpringDataJaxbUnitTests.java

@@ -57,7 +57,7 @@ public class SpringDataJaxbUnitTests {
 	Unmarshaller unmarshaller;
 
 	Sort sort = new Sort(Direction.ASC, "firstname", "lastname");
-	Pageable pageable = new PageRequest(2, 15, sort);
+	Pageable pageable = PageRequest.of(2, 15, sort);
 	Resource resource = new ClassPathResource("pageable.xml", this.getClass());
 	Resource schemaFile = new ClassPathResource("spring-data-jaxb.xsd", this.getClass());
 
@@ -81,7 +81,7 @@ public class SpringDataJaxbUnitTests {
 		Wrapper wrapper = new Wrapper();
 		wrapper.pageable = pageable;
 		wrapper.sort = sort;
-		wrapper.pageableWithoutSort = new PageRequest(10, 20);
+		wrapper.pageableWithoutSort = PageRequest.of(10, 20);
 		marshaller.marshal(wrapper, writer);
 
 		assertThat(new Diff(reference, writer.toString()).similar()).isTrue();
@@ -103,8 +103,8 @@ public class SpringDataJaxbUnitTests {
 		PageWrapper wrapper = new PageWrapper();
 		Content content = new Content();
 		content.name = "Foo";
-		wrapper.page = new PageImpl<Content>(Arrays.asList(content));
-		wrapper.pageWithLinks = new PageImpl<Content>(Arrays.asList(content));
+		wrapper.page = new PageImpl<>(Arrays.asList(content));
+		wrapper.pageWithLinks = new PageImpl<>(Arrays.asList(content));
 
 		marshaller.marshal(wrapper, new StringWriter());
 	}

src/test/java/org/springframework/data/geo/GeoResultUnitTests.java

@@ -28,10 +28,10 @@ import org.springframework.util.SerializationUtils;
  */
 public class GeoResultUnitTests {
 
-	GeoResult<String> first = new GeoResult<String>("Foo", new Distance(2.5));
-	GeoResult<String> second = new GeoResult<String>("Foo", new Distance(2.5));
-	GeoResult<String> third = new GeoResult<String>("Bar", new Distance(2.5));
-	GeoResult<String> fourth = new GeoResult<String>("Foo", new Distance(5.2));
+	GeoResult<String> first = new GeoResult<>("Foo", new Distance(2.5));
+	GeoResult<String> second = new GeoResult<>("Foo", new Distance(2.5));
+	GeoResult<String> third = new GeoResult<>("Bar", new Distance(2.5));
+	GeoResult<String> fourth = new GeoResult<>("Foo", new Distance(5.2));
 
 	@Test // DATACMNS-437
 	public void considersSameInstanceEqual() {
@@ -59,7 +59,7 @@ public class GeoResultUnitTests {
 	@Test // DATACMNS-482
 	public void testSerialization() {
 
-		GeoResult<String> result = new GeoResult<String>("test", new Distance(2));
+		GeoResult<String> result = new GeoResult<>("test", new Distance(2));
 
 		@SuppressWarnings("unchecked")
 		GeoResult<String> serialized = (GeoResult<String>) SerializationUtils.deserialize(SerializationUtils.serialize(result));

src/test/java/org/springframework/data/mapping/MappingMetadataTests.java

@@ -40,7 +40,7 @@ public class MappingMetadataTests {
 	@Test
 	public void testPojoWithId() {
 
-		PersistentEntity<?, SamplePersistentProperty> person = ctx.getPersistentEntity(PersonWithId.class);
+		PersistentEntity<?, SamplePersistentProperty> person = ctx.getRequiredPersistentEntity(PersonWithId.class);
 
 		assertThat(person.getIdProperty()).hasValueSatisfying(it -> assertThat(it.getType()).isEqualTo(String.class));
 	}
@@ -48,7 +48,7 @@ public class MappingMetadataTests {
 	@Test
 	public void testAssociations() {
 
-		PersistentEntity<?, SamplePersistentProperty> person = ctx.getPersistentEntity(PersonWithChildren.class);
+		PersistentEntity<?, SamplePersistentProperty> person = ctx.getRequiredPersistentEntity(PersonWithChildren.class);
 
 		person.doWithAssociations((AssociationHandler<SamplePersistentProperty>) association -> assertThat(
 				association.getInverse().getComponentType()).isEqualTo(Child.class));

src/test/java/org/springframework/data/mapping/context/AbstractMappingContextIntegrationTests.java

@@ -18,10 +18,7 @@ package org.springframework.data.mapping.context;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
-import java.beans.PropertyDescriptor;
-import java.lang.reflect.Field;
 import java.util.Collections;
-import java.util.Optional;
 
 import org.junit.Test;
 import org.springframework.data.annotation.Id;
@@ -29,6 +26,7 @@ import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.data.mapping.PropertyHandler;
 import org.springframework.data.mapping.model.BasicPersistentEntity;
+import org.springframework.data.mapping.model.Property;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
 import org.springframework.data.util.ClassTypeInformation;
 import org.springframework.data.util.TypeInformation;
@@ -64,7 +62,8 @@ public class AbstractMappingContextIntegrationTests<T extends PersistentProperty
 	public void createsPersistentEntityForInterfaceCorrectly() {
 
 		SampleMappingContext context = new SampleMappingContext();
-		PersistentEntity<Object, SamplePersistentProperty> entity = context.getPersistentEntity(InterfaceOnly.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = context
+				.getRequiredPersistentEntity(InterfaceOnly.class);
 
 		assertThat(entity.getIdProperty()).isNotNull();
 	}
@@ -74,25 +73,19 @@ public class AbstractMappingContextIntegrationTests<T extends PersistentProperty
 
 		final DummyMappingContext context = new DummyMappingContext();
 
-		Thread a = new Thread(new Runnable() {
-			public void run() {
-				context.getPersistentEntity(Person.class);
-			}
-		});
+		Thread a = new Thread(() -> context.getPersistentEntity(Person.class));
 
 		Thread b = new Thread(new Runnable() {
 
 			public void run() {
 
-				PersistentEntity<Object, T> entity = context.getPersistentEntity(Person.class);
+				PersistentEntity<Object, T> entity = context.getRequiredPersistentEntity(Person.class);
 
-				entity.doWithProperties(new PropertyHandler<T>() {
-					public void doWithPersistentProperty(T persistentProperty) {
-						try {
-							Thread.sleep(250);
-						} catch (InterruptedException e) {
-							throw new RuntimeException(e);
-						}
+				entity.doWithProperties((PropertyHandler<T>) persistentProperty -> {
+					try {
+						Thread.sleep(250);
+					} catch (InterruptedException e) {
+						throw new RuntimeException(e);
 					}
 				});
 			}
@@ -116,13 +109,13 @@ public class AbstractMappingContextIntegrationTests<T extends PersistentProperty
 
 		@Override
 		@SuppressWarnings({ "rawtypes", "unchecked" })
-		protected T createPersistentProperty(Optional<Field> field, PropertyDescriptor descriptor,
-				final BasicPersistentEntity<Object, T> owner, SimpleTypeHolder simpleTypeHolder) {
+		protected T createPersistentProperty(Property property, BasicPersistentEntity<Object, T> owner,
+				SimpleTypeHolder simpleTypeHolder) {
 
 			PersistentProperty prop = mock(PersistentProperty.class);
 
 			when(prop.getTypeInformation()).thenReturn(owner.getTypeInformation());
-			when(prop.getName()).thenReturn(field.map(Field::getName).orElse(descriptor.getName()));
+			when(prop.getName()).thenReturn(property.getName());
 			when(prop.getPersistentEntityType()).thenReturn(Collections.EMPTY_SET);
 
 			try {

src/test/java/org/springframework/data/mapping/context/AbstractMappingContextUnitTests.java

@@ -111,7 +111,7 @@ public class AbstractMappingContextUnitTests {
 	public void returnsNullPersistentEntityForSimpleTypes() {
 
 		SampleMappingContext context = new SampleMappingContext();
-		assertThat(context.getPersistentEntity(String.class)).isNull();
+		assertThat(context.getPersistentEntity(String.class)).isEmpty();
 	}
 
 	@Test(expected = IllegalArgumentException.class) // DATACMNS-214
@@ -130,7 +130,8 @@ public class AbstractMappingContextUnitTests {
 		SampleMappingContext mappingContext = new SampleMappingContext();
 		mappingContext.initialize();
 
-		PersistentEntity<Object, SamplePersistentProperty> entity = mappingContext.getPersistentEntity(Sample.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = mappingContext
+				.getRequiredPersistentEntity(Sample.class);
 		assertThat(entity.getPersistentProperty("metaClass")).isNotPresent();
 	}
 
@@ -138,7 +139,8 @@ public class AbstractMappingContextUnitTests {
 	public void usesMostConcreteProperty() {
 
 		SampleMappingContext mappingContext = new SampleMappingContext();
-		PersistentEntity<Object, SamplePersistentProperty> entity = mappingContext.getPersistentEntity(Extension.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = mappingContext
+				.getRequiredPersistentEntity(Extension.class);
 
 		assertThat(entity.getPersistentProperty("foo")).hasValueSatisfying(it -> {
 			assertThat(it.isIdProperty()).isTrue();
@@ -150,16 +152,14 @@ public class AbstractMappingContextUnitTests {
 	public void returnsEntityForComponentType() {
 
 		SampleMappingContext mappingContext = new SampleMappingContext();
-		PersistentEntity<Object, SamplePersistentProperty> entity = mappingContext.getPersistentEntity(Sample.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = mappingContext
+				.getRequiredPersistentEntity(Sample.class);
 
 		assertThat(entity.getPersistentProperty("persons")).hasValueSatisfying(it -> {
-
-			PersistentEntity<Object, SamplePersistentProperty> propertyEntity = mappingContext.getPersistentEntity(it);
-
-			assertThat(propertyEntity).isNotNull();
-			assertThat(propertyEntity.getType()).isEqualTo(Person.class);
+			assertThat(mappingContext.getPersistentEntity(it)).hasValueSatisfying(inner -> {
+				assertThat(inner.getType()).isEqualTo(Person.class);
+			});
 		});
-
 	}
 
 	@Test // DATACMNS-380
@@ -197,7 +197,7 @@ public class AbstractMappingContextUnitTests {
 	public void shouldReturnNullForSimpleTypesIfInStrictIsEnabled() {
 
 		context.setStrict(true);
-		assertThat(context.getPersistentEntity(Integer.class)).isNull();
+		assertThat(context.getPersistentEntity(Integer.class)).isEmpty();
 	}
 
 	@Test // DATACMNS-462

src/test/java/org/springframework/data/mapping/context/DefaultPersistenPropertyPathUnitTests.java

@@ -16,7 +16,7 @@
 package org.springframework.data.mapping.context;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Arrays;

src/test/java/org/springframework/data/mapping/context/MappingContextIsNewStrategyFactoryUnitTests.java

@@ -27,8 +27,6 @@ import org.junit.Test;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.annotation.Version;
 import org.springframework.data.domain.Persistable;
-import org.springframework.data.mapping.context.MappingContextIsNewStrategyFactory.PropertyIsNullIsNewStrategy;
-import org.springframework.data.mapping.context.MappingContextIsNewStrategyFactory.PropertyIsNullOrZeroNumberIsNewStrategy;
 import org.springframework.data.support.IsNewStrategy;
 import org.springframework.data.support.IsNewStrategyFactory;
 
@@ -55,7 +53,6 @@ public class MappingContextIsNewStrategyFactoryUnitTests {
 	public void returnsPropertyIsNullOrZeroIsNewStrategyForVersionedEntity() {
 
 		IsNewStrategy strategy = factory.getIsNewStrategy(VersionedEntity.class);
-		assertThat(strategy).isInstanceOf(PropertyIsNullOrZeroNumberIsNewStrategy.class);
 
 		Optional<VersionedEntity> entity = Optional.of(new VersionedEntity());
 		assertThat(strategy.isNew(entity)).isTrue();
@@ -74,7 +71,6 @@ public class MappingContextIsNewStrategyFactoryUnitTests {
 	public void returnsPropertyIsNullOrZeroIsNewStrategyForPrimitiveVersionedEntity() {
 
 		IsNewStrategy strategy = factory.getIsNewStrategy(VersionedEntity.class);
-		assertThat(strategy).isInstanceOf(PropertyIsNullOrZeroNumberIsNewStrategy.class);
 
 		Optional<VersionedEntity> entity = Optional.of(new VersionedEntity());
 		assertThat(strategy.isNew(entity)).isTrue();
@@ -90,7 +86,6 @@ public class MappingContextIsNewStrategyFactoryUnitTests {
 	public void returnsPropertyIsNullIsNewStrategyForEntity() {
 
 		IsNewStrategy strategy = factory.getIsNewStrategy(Entity.class);
-		assertThat(strategy).isInstanceOf(PropertyIsNullIsNewStrategy.class);
 
 		Optional<Entity> entity = Optional.of(new Entity());
 		assertThat(strategy.isNew(entity)).isTrue();

src/test/java/org/springframework/data/mapping/context/PersistentEntitiesUnitTests.java

@@ -52,10 +52,10 @@ public class PersistentEntitiesUnitTests {
 		new PersistentEntities(Arrays.asList(first, second)).getPersistentEntity(Sample.class);
 
 		verify(first, times(1)).hasPersistentEntityFor(Sample.class);
-		verify(first, times(0)).getPersistentEntity(Sample.class);
+		verify(first, times(0)).getRequiredPersistentEntity(Sample.class);
 
 		verify(second, times(1)).hasPersistentEntityFor(Sample.class);
-		verify(second, times(1)).getPersistentEntity(Sample.class);
+		verify(second, times(1)).getRequiredPersistentEntity(Sample.class);
 	}
 
 	@Test // DATACMNS-458
@@ -67,10 +67,14 @@ public class PersistentEntitiesUnitTests {
 
 		PersistentEntities entities = new PersistentEntities(Arrays.asList(context));
 
-		assertThat(entities.getPersistentEntity(Sample.class)).isNotNull();
-		assertThat(entities.getPersistentEntity(Object.class)).isNull();
+		assertThat(entities.getPersistentEntity(Sample.class)).isPresent();
+		assertThat(entities.getPersistentEntity(Object.class)).isNotPresent();
 		assertThat(entities.getManagedTypes()).contains(ClassTypeInformation.from(Sample.class));
-		assertThat(entities).contains(entities.getPersistentEntity(Sample.class));
+
+		assertThat(entities.getPersistentEntity(Sample.class)).hasValueSatisfying(it -> {
+			assertThat(entities).contains(it);
+		});
+
 	}
 
 	static class Sample {

src/test/java/org/springframework/data/mapping/context/SampleMappingContext.java

@@ -1,10 +1,7 @@
 package org.springframework.data.mapping.context;
 
-import java.beans.PropertyDescriptor;
-import java.lang.reflect.Field;
-import java.util.Optional;
-
 import org.springframework.data.mapping.model.BasicPersistentEntity;
+import org.springframework.data.mapping.model.Property;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
 import org.springframework.data.util.TypeInformation;
 
@@ -19,9 +16,9 @@ public class SampleMappingContext
 	}
 
 	@Override
-	protected SamplePersistentProperty createPersistentProperty(Optional<Field> field, PropertyDescriptor descriptor,
+	protected SamplePersistentProperty createPersistentProperty(Property property,
 			BasicPersistentEntity<Object, SamplePersistentProperty> owner, SimpleTypeHolder simpleTypeHolder) {
 
-		return new SamplePersistentProperty(field, descriptor, owner, simpleTypeHolder);
+		return new SamplePersistentProperty(property, owner, simpleTypeHolder);
 	}
 }

src/test/java/org/springframework/data/mapping/context/SamplePersistentProperty.java

@@ -15,24 +15,21 @@
  */
 package org.springframework.data.mapping.context;
 
-import java.beans.PropertyDescriptor;
-import java.lang.reflect.Field;
-import java.util.Optional;
-
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.model.AnnotationBasedPersistentProperty;
 import org.springframework.data.mapping.model.BasicPersistentEntity;
+import org.springframework.data.mapping.model.Property;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
 
 public class SamplePersistentProperty extends AnnotationBasedPersistentProperty<SamplePersistentProperty> {
 
-	public SamplePersistentProperty(Optional<Field> field, PropertyDescriptor propertyDescriptor,
-			BasicPersistentEntity<?, SamplePersistentProperty> owner, SimpleTypeHolder simpleTypeHolder) {
-		super(field, propertyDescriptor, owner, simpleTypeHolder);
+	public SamplePersistentProperty(Property property, BasicPersistentEntity<?, SamplePersistentProperty> owner,
+			SimpleTypeHolder simpleTypeHolder) {
+		super(property, owner, simpleTypeHolder);
 	}
 
 	@Override
 	protected Association<SamplePersistentProperty> createAssociation() {
-		return new Association<SamplePersistentProperty>(this, null);
+		return new Association<>(this, null);
 	}
 }

src/test/java/org/springframework/data/mapping/model/AbstractPersistentPropertyUnitTests.java

@@ -54,53 +54,35 @@ public class AbstractPersistentPropertyUnitTests {
 	public void setUp() {
 
 		typeInfo = ClassTypeInformation.from(TestClassComplex.class);
-		entity = new BasicPersistentEntity<TestClassComplex, SamplePersistentProperty>(typeInfo);
+		entity = new BasicPersistentEntity<>(typeInfo);
 		typeHolder = new SimpleTypeHolder();
 	}
 
 	@Test // DATACMNS-68
 	public void discoversComponentTypeCorrectly() throws Exception {
-
-		Field field = ReflectionUtils.findField(TestClassComplex.class, "testClassSet");
-
-		SamplePersistentProperty property = new SamplePersistentProperty(Optional.of(field), null, entity, typeHolder);
-		property.getComponentType();
+		assertThat(getProperty(TestClassComplex.class, "testClassSet").getComponentType()).isEqualTo(Object.class);
 	}
 
 	@Test // DATACMNS-101
 	public void returnsNestedEntityTypeCorrectly() {
-
-		Field field = ReflectionUtils.findField(TestClassComplex.class, "testClassSet");
-
-		SamplePersistentProperty property = new SamplePersistentProperty(Optional.of(field), null, entity, typeHolder);
-		assertThat(property.getPersistentEntityType().iterator().hasNext()).isFalse();
+		assertThat(getProperty(TestClassComplex.class, "testClassSet").getPersistentEntityType()).isEmpty();
 	}
 
 	@Test // DATACMNS-132
 	public void isEntityWorksForUntypedMaps() throws Exception {
-
-		Field field = ReflectionUtils.findField(TestClassComplex.class, "map");
-		SamplePersistentProperty property = new SamplePersistentProperty(Optional.of(field), null, entity, typeHolder);
-		assertThat(property.isEntity()).isFalse();
+		assertThat(getProperty(TestClassComplex.class, "map").isEntity()).isFalse();
 	}
 
 	@Test // DATACMNS-132
 	public void isEntityWorksForUntypedCollection() throws Exception {
-
-		Field field = ReflectionUtils.findField(TestClassComplex.class, "collection");
-		SamplePersistentProperty property = new SamplePersistentProperty(Optional.of(field), null, entity, typeHolder);
-		assertThat(property.isEntity()).isFalse();
+		assertThat(getProperty(TestClassComplex.class, "collection").isEntity()).isFalse();
 	}
 
 	@Test // DATACMNS-121
 	public void considersPropertiesEqualIfFieldEquals() {
 
-		Field first = ReflectionUtils.findField(FirstConcrete.class, "genericField");
-		Field second = ReflectionUtils.findField(SecondConcrete.class, "genericField");
-
-		SamplePersistentProperty firstProperty = new SamplePersistentProperty(Optional.of(first), null, entity, typeHolder);
-		SamplePersistentProperty secondProperty = new SamplePersistentProperty(Optional.of(second), null, entity,
-				typeHolder);
+		SamplePersistentProperty firstProperty = getProperty(FirstConcrete.class, "genericField");
+		SamplePersistentProperty secondProperty = getProperty(SecondConcrete.class, "genericField");
 
 		assertThat(firstProperty).isEqualTo(secondProperty);
 		assertThat(firstProperty.hashCode()).isEqualTo(secondProperty.hashCode());
@@ -108,67 +90,54 @@ public class AbstractPersistentPropertyUnitTests {
 
 	@Test // DATACMNS-180
 	public void doesNotConsiderJavaTransientFieldsTransient() {
-
-		Field transientField = ReflectionUtils.findField(TestClassComplex.class, "transientField");
-
-		PersistentProperty<?> property = new SamplePersistentProperty(Optional.of(transientField), null, entity,
-				typeHolder);
-		assertThat(property.isTransient()).isFalse();
+		assertThat(getProperty(TestClassComplex.class, "transientField").isTransient()).isFalse();
 	}
 
 	@Test // DATACMNS-206
 	public void findsSimpleGettersAndASetters() {
 
-		Field field = ReflectionUtils.findField(AccessorTestClass.class, "id");
-		PersistentProperty<SamplePersistentProperty> property = new SamplePersistentProperty(Optional.of(field),
-				getPropertyDescriptor(AccessorTestClass.class, "id"), entity, typeHolder);
+		SamplePersistentProperty property = getProperty(AccessorTestClass.class, "id");
 
-		assertThat(property.getGetter()).isNotNull();
-		assertThat(property.getSetter()).isNotNull();
+		assertThat(property.getGetter()).isPresent();
+		assertThat(property.getSetter()).isPresent();
 	}
 
 	@Test // DATACMNS-206
 	public void doesNotUseInvalidGettersAndASetters() {
 
-		Field field = ReflectionUtils.findField(AccessorTestClass.class, "anotherId");
-		PersistentProperty<SamplePersistentProperty> property = new SamplePersistentProperty(Optional.of(field),
-				getPropertyDescriptor(AccessorTestClass.class, "anotherId"), entity, typeHolder);
+		SamplePersistentProperty property = getProperty(AccessorTestClass.class, "anotherId");
 
-		assertThat(property.getGetter()).isNull();
-		assertThat(property.getSetter()).isNull();
+		assertThat(property.getGetter()).isNotPresent();
+		assertThat(property.getSetter()).isNotPresent();
 	}
 
 	@Test // DATACMNS-206
 	public void usesCustomGetter() {
 
-		Field field = ReflectionUtils.findField(AccessorTestClass.class, "yetAnotherId");
-		PersistentProperty<SamplePersistentProperty> property = new SamplePersistentProperty(Optional.of(field),
-				getPropertyDescriptor(AccessorTestClass.class, "yetAnotherId"), entity, typeHolder);
+		SamplePersistentProperty property = getProperty(AccessorTestClass.class, "yetAnotherId");
 
-		assertThat(property.getGetter()).isNotNull();
-		assertThat(property.getSetter()).isNull();
+		assertThat(property.getGetter()).isPresent();
+		assertThat(property.getSetter()).isNotPresent();
 	}
 
 	@Test // DATACMNS-206
 	public void usesCustomSetter() {
 
-		Field field = ReflectionUtils.findField(AccessorTestClass.class, "yetYetAnotherId");
-		PersistentProperty<SamplePersistentProperty> property = new SamplePersistentProperty(Optional.of(field),
-				getPropertyDescriptor(AccessorTestClass.class, "yetYetAnotherId"), entity, typeHolder);
+		SamplePersistentProperty property = getProperty(AccessorTestClass.class, "yetYetAnotherId");
 
-		assertThat(property.getGetter()).isNull();
-		assertThat(property.getSetter()).isNotNull();
+		assertThat(property.getGetter()).isNotPresent();
+		assertThat(property.getSetter()).isPresent();
 	}
 
 	@Test // DATACMNS-206
-	public void returnsNullGetterAndSetterIfNoPropertyDescriptorGiven() {
+	public void doesNotDiscoverGetterAndSetterIfNoPropertyDescriptorGiven() {
 
 		Field field = ReflectionUtils.findField(AccessorTestClass.class, "id");
-		PersistentProperty<SamplePersistentProperty> property = new SamplePersistentProperty(Optional.of(field), null,
-				entity, typeHolder);
+		PersistentProperty<SamplePersistentProperty> property = new SamplePersistentProperty(Property.of(field),
+				getEntity(AccessorTestClass.class), typeHolder);
 
-		assertThat(property.getGetter()).isNull();
-		assertThat(property.getSetter()).isNull();
+		assertThat(property.getGetter()).isNotPresent();
+		assertThat(property.getSetter()).isNotPresent();
 	}
 
 	@Test // DATACMNS-337
@@ -223,25 +192,31 @@ public class AbstractPersistentPropertyUnitTests {
 		assertThat(property.isEntity()).isFalse();
 	}
 
-	private <T> SamplePersistentProperty getProperty(Class<T> type, String name) {
-
-		BasicPersistentEntity<T, SamplePersistentProperty> entity = new BasicPersistentEntity<T, SamplePersistentProperty>(
-				ClassTypeInformation.from(type));
-
-		Field field = ReflectionUtils.findField(type, name);
-		return new SamplePersistentProperty(Optional.of(field), null, entity, typeHolder);
+	private <T> BasicPersistentEntity<T, SamplePersistentProperty> getEntity(Class<T> type) {
+		return new BasicPersistentEntity<>(ClassTypeInformation.from(type));
 	}
 
-	private static PropertyDescriptor getPropertyDescriptor(Class<?> type, String propertyName) {
+	private <T> SamplePersistentProperty getProperty(Class<T> type, String name) {
+
+		Optional<Field> field = Optional.ofNullable(ReflectionUtils.findField(type, name));
+
+		Property property = field.map(it -> Property.of(it, getPropertyDescriptor(type, name)))
+				.orElseGet(() -> Property.of(getPropertyDescriptor(type, name).orElseThrow(
+						() -> new IllegalArgumentException(String.format("Couldn't find property %s on %s!", name, type)))));
+
+		return new SamplePersistentProperty(property, getEntity(type), typeHolder);
+	}
+
+	private static Optional<PropertyDescriptor> getPropertyDescriptor(Class<?> type, String propertyName) {
 
 		try {
 
 			return Arrays.stream(Introspector.getBeanInfo(type).getPropertyDescriptors())//
 					.filter(it -> it.getName().equals(propertyName))//
-					.findFirst().orElse(null);
+					.findFirst();
 
-		} catch (IntrospectionException e) {
-			return null;
+		} catch (IntrospectionException o_O) {
+			throw new RuntimeException(o_O);
 		}
 	}
 
@@ -311,9 +286,9 @@ public class AbstractPersistentPropertyUnitTests {
 
 	class SamplePersistentProperty extends AbstractPersistentProperty<SamplePersistentProperty> {
 
-		public SamplePersistentProperty(Optional<Field> field, PropertyDescriptor propertyDescriptor,
-				PersistentEntity<?, SamplePersistentProperty> owner, SimpleTypeHolder simpleTypeHolder) {
-			super(field, propertyDescriptor, owner, simpleTypeHolder);
+		public SamplePersistentProperty(Property property, PersistentEntity<?, SamplePersistentProperty> owner,
+				SimpleTypeHolder simpleTypeHolder) {
+			super(property, owner, simpleTypeHolder);
 		}
 
 		public boolean isIdProperty() {

src/test/java/org/springframework/data/mapping/model/AnnotationBasedPersistentPropertyUnitTests.java

@@ -55,7 +55,7 @@ public class AnnotationBasedPersistentPropertyUnitTests<P extends AnnotationBase
 	public void setUp() {
 
 		context = new SampleMappingContext();
-		entity = context.getPersistentEntity(Sample.class);
+		entity = context.getRequiredPersistentEntity(Sample.class);
 	}
 
 	@Test // DATACMNS-269
@@ -215,7 +215,7 @@ public class AnnotationBasedPersistentPropertyUnitTests<P extends AnnotationBase
 	}
 
 	private SamplePersistentProperty getProperty(Class<?> type, String name) {
-		return context.getPersistentEntity(type).getPersistentProperty(name).orElse(null);
+		return context.getRequiredPersistentEntity(type).getPersistentProperty(name).orElse(null);
 	}
 
 	static class Sample {

src/test/java/org/springframework/data/mapping/model/BasicPersistentEntityUnitTests.java

@@ -16,9 +16,6 @@
 package org.springframework.data.mapping.model;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.hamcrest.CoreMatchers.*;
-import static org.hamcrest.CoreMatchers.not;
-import static org.junit.Assume.*;
 import static org.mockito.Mockito.*;
 
 import java.lang.annotation.Retention;
@@ -28,8 +25,6 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Optional;
 
-import org.hamcrest.CoreMatchers;
-import org.junit.Assert;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -42,6 +37,7 @@ import org.springframework.data.annotation.CreatedBy;
 import org.springframework.data.annotation.CreatedDate;
 import org.springframework.data.annotation.LastModifiedBy;
 import org.springframework.data.annotation.TypeAlias;
+import org.springframework.data.mapping.Alias;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.PersistentEntitySpec;
@@ -86,25 +82,22 @@ public class BasicPersistentEntityUnitTests<T extends PersistentProperty<T>> {
 	public void returnsNullForTypeAliasIfNoneConfigured() {
 
 		PersistentEntity<Entity, T> entity = createEntity(Entity.class);
-		assertThat(entity.getTypeAlias()).isNotPresent();
+		assertThat(entity.getTypeAlias()).isEqualTo(Alias.NONE);
 	}
 
 	@Test
 	public void returnsTypeAliasIfAnnotated() {
 
 		PersistentEntity<AliasedEntity, T> entity = createEntity(AliasedEntity.class);
-		assertThat(entity.getTypeAlias()).isEqualTo("foo");
+		assertThat(entity.getTypeAlias()).isEqualTo(Alias.of("foo"));
 	}
 
 	@Test // DATACMNS-50
 	@SuppressWarnings("unchecked")
 	public void considersComparatorForPropertyOrder() {
 
-		BasicPersistentEntity<Person, T> entity = createEntity(Person.class, new Comparator<T>() {
-			public int compare(T o1, T o2) {
-				return o1.getName().compareTo(o2.getName());
-			}
-		});
+		BasicPersistentEntity<Person, T> entity = createEntity(Person.class,
+				Comparator.comparing(PersistentProperty::getName));
 
 		T lastName = (T) Mockito.mock(PersistentProperty.class);
 		when(lastName.getName()).thenReturn("lastName");
@@ -124,20 +117,21 @@ public class BasicPersistentEntityUnitTests<T extends PersistentProperty<T>> {
 
 		assertThat(properties).hasSize(3);
 		Iterator<T> iterator = properties.iterator();
-		assertThat(iterator.next()).isEqualTo(entity.getPersistentProperty("firstName"));
-		assertThat(iterator.next()).isEqualTo(entity.getPersistentProperty("lastName"));
-		assertThat(iterator.next()).isEqualTo(entity.getPersistentProperty("ssn"));
+
+		assertThat(entity.getPersistentProperty("firstName")).hasValue(iterator.next());
+		assertThat(entity.getPersistentProperty("lastName")).hasValue(iterator.next());
+		assertThat(entity.getPersistentProperty("ssn")).hasValue(iterator.next());
 	}
 
 	@Test // DATACMNS-186
 	public void addingAndIdPropertySetsIdPropertyInternally() {
 
 		MutablePersistentEntity<Person, T> entity = createEntity(Person.class);
-		assertThat(entity.getIdProperty()).isNull();
+		assertThat(entity.getIdProperty()).isNotPresent();
 
 		when(property.isIdProperty()).thenReturn(true);
 		entity.addPersistentProperty(property);
-		assertThat(entity.getIdProperty()).isEqualTo(property);
+		assertThat(entity.getIdProperty()).hasValue(property);
 	}
 
 	@Test // DATACMNS-186
@@ -157,7 +151,7 @@ public class BasicPersistentEntityUnitTests<T extends PersistentProperty<T>> {
 	public void detectsPropertyWithAnnotation() {
 
 		SampleMappingContext context = new SampleMappingContext();
-		PersistentEntity<Object, SamplePersistentProperty> entity = context.getPersistentEntity(Entity.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = context.getRequiredPersistentEntity(Entity.class);
 
 		Optional<SamplePersistentProperty> property = entity.getPersistentProperty(LastModifiedBy.class);
 
@@ -192,15 +186,13 @@ public class BasicPersistentEntityUnitTests<T extends PersistentProperty<T>> {
 	@Test // DATACMNS-809
 	public void returnsGeneratedPropertyAccessorForPropertyAccessor() {
 
-		assumeThat(System.getProperty("java.version"), not(CoreMatchers.startsWith("1.6")));
-
 		SampleMappingContext context = new SampleMappingContext();
-		PersistentEntity<Object, SamplePersistentProperty> entity = context.getPersistentEntity(Entity.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = context.getRequiredPersistentEntity(Entity.class);
 
 		Entity value = new Entity();
 		PersistentPropertyAccessor accessor = entity.getPropertyAccessor(value);
 
-		assertThat(accessor).isNotEqualTo(instanceOf(BeanWrapper.class));
+		assertThat(accessor).isNotInstanceOf(BeanWrapper.class);
 		assertThat(accessor.getClass().getName()).contains("_Accessor_");
 		assertThat(accessor.getBean()).isEqualTo(value);
 	}
@@ -209,7 +201,7 @@ public class BasicPersistentEntityUnitTests<T extends PersistentProperty<T>> {
 	public void rejectsNullBeanForPropertyAccessor() {
 
 		SampleMappingContext context = new SampleMappingContext();
-		PersistentEntity<Object, SamplePersistentProperty> entity = context.getPersistentEntity(Entity.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = context.getRequiredPersistentEntity(Entity.class);
 
 		entity.getPropertyAccessor(null);
 	}
@@ -218,7 +210,7 @@ public class BasicPersistentEntityUnitTests<T extends PersistentProperty<T>> {
 	public void rejectsNonMatchingBeanForPropertyAccessor() {
 
 		SampleMappingContext context = new SampleMappingContext();
-		PersistentEntity<Object, SamplePersistentProperty> entity = context.getPersistentEntity(Entity.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = context.getRequiredPersistentEntity(Entity.class);
 
 		entity.getPropertyAccessor("foo");
 	}
@@ -227,7 +219,7 @@ public class BasicPersistentEntityUnitTests<T extends PersistentProperty<T>> {
 	public void supportsSubtypeInstancesOnPropertyAccessorLookup() {
 
 		SampleMappingContext context = new SampleMappingContext();
-		PersistentEntity<Object, SamplePersistentProperty> entity = context.getPersistentEntity(Entity.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = context.getRequiredPersistentEntity(Entity.class);
 
 		assertThat(entity.getPropertyAccessor(new Subtype())).isNotNull();
 	}
@@ -237,7 +229,7 @@ public class BasicPersistentEntityUnitTests<T extends PersistentProperty<T>> {
 
 		PersistentEntity<AliasEntityUsingComposedAnnotation, T> entity = createEntity(
 				AliasEntityUsingComposedAnnotation.class);
-		assertThat(entity.getTypeAlias()).isEqualTo("bar");
+		assertThat(entity.getTypeAlias()).isEqualTo(Alias.of("bar"));
 	}
 
 	@Test // DATACMNS-866

src/test/java/org/springframework/data/mapping/model/ClassGeneratingPropertyAccessorFactoryDatatypeTests.java

@@ -65,7 +65,8 @@ public class ClassGeneratingPropertyAccessorFactoryDatatypeTests {
 	public static List<Object[]> parameters() throws Exception {
 
 		List<Object[]> parameters = new ArrayList<>();
-		List<Class<?>> types = Arrays.asList(FieldAccess.class, PropertyAccess.class, PrivateFinalFieldAccess.class, PrivateFinalPropertyAccess.class);
+		List<Class<?>> types = Arrays.asList(FieldAccess.class, PropertyAccess.class, PrivateFinalFieldAccess.class,
+				PrivateFinalPropertyAccess.class);
 
 		parameters.addAll(parameters(types, "primitiveInteger", Integer.valueOf(1)));
 		parameters.addAll(parameters(types, "primitiveIntegerArray", new int[] { 1, 2, 3 }));
@@ -113,8 +114,8 @@ public class ClassGeneratingPropertyAccessorFactoryDatatypeTests {
 
 			Constructor<?>[] constructors = type.getDeclaredConstructors();
 			constructors[0].setAccessible(true);
-			parameters
-					.add(new Object[] { constructors[0].newInstance(), propertyName, value, type.getSimpleName() + "/" + propertyName });
+			parameters.add(new Object[] { constructors[0].newInstance(), propertyName, value,
+					type.getSimpleName() + "/" + propertyName });
 		}
 
 		return parameters;
@@ -136,20 +137,20 @@ public class ClassGeneratingPropertyAccessorFactoryDatatypeTests {
 	public void shouldUseClassPropertyAccessorFactory() throws Exception {
 
 		BasicPersistentEntity<Object, SamplePersistentProperty> persistentEntity = mappingContext
-				.getPersistentEntity(bean.getClass());
+				.getRequiredPersistentEntity(bean.getClass());
 
 		assertThat(ReflectionTestUtils.getField(persistentEntity, "propertyAccessorFactory"))
 				.isInstanceOf(ClassGeneratingPropertyAccessorFactory.class);
 	}
 
 	private PersistentPropertyAccessor getPersistentPropertyAccessor(Object bean) {
-		return factory.getPropertyAccessor(mappingContext.getPersistentEntity(bean.getClass()), bean);
+		return factory.getPropertyAccessor(mappingContext.getRequiredPersistentEntity(bean.getClass()), bean);
 	}
 
 	private Optional<? extends PersistentProperty<?>> getProperty(Object bean, String name) {
 
 		BasicPersistentEntity<Object, SamplePersistentProperty> persistentEntity = mappingContext
-				.getPersistentEntity(bean.getClass());
+				.getRequiredPersistentEntity(bean.getClass());
 		return persistentEntity.getPersistentProperty(name);
 	}
 

src/test/java/org/springframework/data/mapping/model/ClassGeneratingPropertyAccessorFactoryEntityTypeTests.java

@@ -42,7 +42,7 @@ public class ClassGeneratingPropertyAccessorFactoryEntityTypeTests {
 
 		Algorithm quickSort = new QuickSort();
 
-		assertThat(getEntityInformation(Algorithm.class).getId(quickSort)).isEqualTo(quickSort.getName());
+		assertThat(getEntityInformation(Algorithm.class).getId(quickSort)).hasValue(quickSort.getName());
 	}
 
 	@Test // DATACMNS-853
@@ -50,12 +50,12 @@ public class ClassGeneratingPropertyAccessorFactoryEntityTypeTests {
 
 		Person jonDoe = new Person("JonDoe");
 
-		assertThat(getEntityInformation(Person.class).getId(jonDoe)).isEqualTo(jonDoe.name);
+		assertThat(getEntityInformation(Person.class).getId(jonDoe)).hasValue(jonDoe.name);
 	}
 
-	private EntityInformation<Object, ?> getEntityInformation(Class<?> type) {
+	private EntityInformation<Object, Serializable> getEntityInformation(Class<?> type) {
 
-		PersistentEntity<Object, SamplePersistentProperty> entity = mappingContext.getPersistentEntity(type);
+		PersistentEntity<Object, SamplePersistentProperty> entity = mappingContext.getRequiredPersistentEntity(type);
 		return new PersistentEntityInformation<Object, Serializable>(entity);
 	}
 

src/test/java/org/springframework/data/mapping/model/ClassGeneratingPropertyAccessorFactoryTests.java

@@ -16,7 +16,8 @@
 
 package org.springframework.data.mapping.model;
 
-import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
 import java.lang.reflect.Constructor;
 import java.util.ArrayList;
@@ -28,6 +29,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
+
 import org.springframework.data.annotation.AccessType;
 import org.springframework.data.annotation.AccessType.Type;
 import org.springframework.data.mapping.PersistentProperty;
@@ -68,7 +70,8 @@ public class ClassGeneratingPropertyAccessorFactoryTests {
 				"privateProperty", "packageDefaultProperty", "protectedProperty", "publicProperty", "syntheticProperty");
 
 		parameters.addAll(parameters(new InnerPrivateType(), propertyNames, Object.class));
-		parameters.addAll(parameters(new InnerTypeWithPrivateAncestor(), propertyNames, InnerTypeWithPrivateAncestor.class));
+		parameters
+				.addAll(parameters(new InnerTypeWithPrivateAncestor(), propertyNames, InnerTypeWithPrivateAncestor.class));
 		parameters.addAll(parameters(new InnerPackageDefaultType(), propertyNames, InnerPackageDefaultType.class));
 		parameters.addAll(parameters(new InnerProtectedType(), propertyNames, InnerProtectedType.class));
 		parameters.addAll(parameters(new InnerPublicType(), propertyNames, InnerPublicType.class));
@@ -119,10 +122,10 @@ public class ClassGeneratingPropertyAccessorFactoryTests {
 
 	@Test(expected = IllegalArgumentException.class) // DATACMNS-809
 	public void shouldFailOnNullBean() {
-		factory.getPropertyAccessor(mappingContext.getPersistentEntity(bean.getClass()), null);
+		factory.getPropertyAccessor(mappingContext.getRequiredPersistentEntity(bean.getClass()), null);
 	}
 
-	@Test(expected = UnsupportedOperationException.class) // DATACMNS-809
+	@Test // DATACMNS-809
 	public void getPropertyShouldFailOnUnhandledProperty() {
 
 		assertThat(getProperty(new Dummy(), "dummy")).hasValueSatisfying(property -> {
@@ -132,33 +135,34 @@ public class ClassGeneratingPropertyAccessorFactoryTests {
 		});
 	}
 
-	@Test(expected = UnsupportedOperationException.class) // DATACMNS-809
+	@Test // DATACMNS-809
 	public void setPropertyShouldFailOnUnhandledProperty() {
 
 		assertThat(getProperty(new Dummy(), "dummy")).hasValueSatisfying(property -> {
-			getPersistentPropertyAccessor(bean).setProperty(property, Optional.empty());
-		});
 
+			assertThatExceptionOfType(UnsupportedOperationException.class)//
+					.isThrownBy(() -> getPersistentPropertyAccessor(bean).setProperty(property, Optional.empty()));
+		});
 	}
 
 	@Test // DATACMNS-809
 	public void shouldUseClassPropertyAccessorFactory() throws Exception {
 
 		BasicPersistentEntity<Object, SamplePersistentProperty> persistentEntity = mappingContext
-				.getPersistentEntity(bean.getClass());
+				.getRequiredPersistentEntity(bean.getClass());
 
 		assertThat(ReflectionTestUtils.getField(persistentEntity, "propertyAccessorFactory"))
 				.isInstanceOf(ClassGeneratingPropertyAccessorFactory.class);
 	}
 
 	private PersistentPropertyAccessor getPersistentPropertyAccessor(Object bean) {
-		return factory.getPropertyAccessor(mappingContext.getPersistentEntity(bean.getClass()), bean);
+		return factory.getPropertyAccessor(mappingContext.getRequiredPersistentEntity(bean.getClass()), bean);
 	}
 
 	private Optional<? extends PersistentProperty<?>> getProperty(Object bean, String name) {
 
 		BasicPersistentEntity<Object, SamplePersistentProperty> persistentEntity = mappingContext
-				.getPersistentEntity(bean.getClass());
+				.getRequiredPersistentEntity(bean.getClass());
 		return persistentEntity.getPersistentProperty(name);
 	}
 

src/test/java/org/springframework/data/mapping/model/ConvertingPropertyAccessorUnitTests.java

@@ -43,7 +43,7 @@ public class ConvertingPropertyAccessorUnitTests {
 
 	@Test(expected = IllegalArgumentException.class) // DATACMNS-596
 	public void rejectsNullConversionService() {
-		new ConvertingPropertyAccessor(new BeanWrapper<Object>(new Object()), null);
+		new ConvertingPropertyAccessor(new BeanWrapper<>(new Object()), null);
 	}
 
 	@Test // DATACMNS-596
@@ -111,14 +111,15 @@ public class ConvertingPropertyAccessorUnitTests {
 
 	private static ConvertingPropertyAccessor getAccessor(Object entity, ConversionService conversionService) {
 
-		PersistentPropertyAccessor wrapper = new BeanWrapper<Object>(entity);
+		PersistentPropertyAccessor wrapper = new BeanWrapper<>(entity);
 		return new ConvertingPropertyAccessor(wrapper, conversionService);
 	}
 
 	private static Optional<SamplePersistentProperty> getIdProperty() {
 
 		SampleMappingContext mappingContext = new SampleMappingContext();
-		BasicPersistentEntity<Object, SamplePersistentProperty> entity = mappingContext.getPersistentEntity(Entity.class);
+		BasicPersistentEntity<Object, SamplePersistentProperty> entity = mappingContext
+				.getRequiredPersistentEntity(Entity.class);
 		return entity.getPersistentProperty("id");
 	}
 

src/test/java/org/springframework/data/mapping/model/IdPropertyIdentifierAccessorUnitTests.java

@@ -32,13 +32,13 @@ public class IdPropertyIdentifierAccessorUnitTests {
 	@Test(expected = IllegalArgumentException.class) // DATACMNS-599
 	public void rejectsEntityWithoutIdentifierProperty() {
 
-		new IdPropertyIdentifierAccessor(mappingContext.getPersistentEntity(Sample.class), new Sample());
+		new IdPropertyIdentifierAccessor(mappingContext.getRequiredPersistentEntity(Sample.class), new Sample());
 	}
 
 	@Test(expected = IllegalArgumentException.class) // DATACMNS-599
 	public void rejectsNullBean() {
 
-		new IdPropertyIdentifierAccessor(mappingContext.getPersistentEntity(SampleWithId.class), null);
+		new IdPropertyIdentifierAccessor(mappingContext.getRequiredPersistentEntity(SampleWithId.class), null);
 	}
 
 	@Test // DATACMNS-599
@@ -48,9 +48,9 @@ public class IdPropertyIdentifierAccessorUnitTests {
 		sample.id = 1L;
 
 		IdentifierAccessor accessor = new IdPropertyIdentifierAccessor(
-				mappingContext.getPersistentEntity(SampleWithId.class), sample);
+				mappingContext.getRequiredPersistentEntity(SampleWithId.class), sample);
 
-		assertThat(accessor.getIdentifier()).isEqualTo(sample.id);
+		assertThat(accessor.getIdentifier()).hasValue(sample.id);
 	}
 
 	static class Sample {}

src/test/java/org/springframework/data/mapping/model/PersistentEntityParameterValueProviderUnitTests.java

@@ -16,7 +16,7 @@
 package org.springframework.data.mapping.model;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Iterator;

src/test/java/org/springframework/data/mapping/model/SpelExpressionParameterProviderUnitTests.java

@@ -16,6 +16,7 @@
 package org.springframework.data.mapping.model;
 
 import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Optional;
@@ -24,7 +25,6 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.Mockito;
 import org.mockito.runners.MockitoJUnitRunner;
 import org.springframework.core.convert.ConversionService;
 import org.springframework.data.mapping.PreferredConstructor.Parameter;
@@ -47,11 +47,9 @@ public class SpelExpressionParameterProviderUnitTests {
 	@Before
 	@SuppressWarnings("unchecked")
 	public void setUp() {
-		provider = new SpELExpressionParameterValueProvider<SamplePersistentProperty>(evaluator, conversionService,
-				delegate);
+		provider = new SpELExpressionParameterValueProvider<>(evaluator, conversionService, delegate);
 
 		parameter = mock(Parameter.class);
-		when(parameter.hasSpelExpression()).thenReturn(true);
 		when(parameter.getSpelExpression()).thenReturn(Optional.empty());
 		when(parameter.getRawType()).thenReturn(Object.class);
 	}
@@ -61,7 +59,6 @@ public class SpelExpressionParameterProviderUnitTests {
 	public void delegatesIfParameterDoesNotHaveASpELExpression() {
 
 		Parameter<Object, SamplePersistentProperty> parameter = mock(Parameter.class);
-		when(parameter.hasSpelExpression()).thenReturn(false);
 
 		provider.getParameterValue(parameter);
 		verify(delegate, times(1)).getParameterValue(parameter);
@@ -81,9 +78,11 @@ public class SpelExpressionParameterProviderUnitTests {
 	@Test
 	public void handsSpELValueToConversionService() {
 
-		when(evaluator.evaluate(Mockito.any(String.class))).thenReturn("value");
+		doReturn(Optional.of("source")).when(parameter).getSpelExpression();
+		doReturn("value").when(evaluator).evaluate(any());
 
 		provider.getParameterValue(parameter);
+
 		verify(delegate, times(0)).getParameterValue(parameter);
 		verify(conversionService, times(1)).convert("value", Object.class);
 	}
@@ -91,9 +90,11 @@ public class SpelExpressionParameterProviderUnitTests {
 	@Test
 	public void doesNotConvertNullValue() {
 
-		when(evaluator.evaluate(Mockito.any(String.class))).thenReturn(null);
+		doReturn(Optional.of("source")).when(parameter).getSpelExpression();
+		doReturn(null).when(evaluator).evaluate(any());
 
 		provider.getParameterValue(parameter);
+
 		verify(delegate, times(0)).getParameterValue(parameter);
 		verify(conversionService, times(0)).convert("value", Object.class);
 	}
@@ -103,6 +104,7 @@ public class SpelExpressionParameterProviderUnitTests {
 
 		provider = new SpELExpressionParameterValueProvider<SamplePersistentProperty>(evaluator, conversionService,
 				delegate) {
+
 			@Override
 			@SuppressWarnings("unchecked")
 			protected <T> T potentiallyConvertSpelValue(Object object, Parameter<T, SamplePersistentProperty> parameter) {
@@ -110,10 +112,11 @@ public class SpelExpressionParameterProviderUnitTests {
 			}
 		};
 
-		when(evaluator.evaluate(Mockito.anyString())).thenReturn("value");
+		doReturn(Optional.of("source")).when(parameter).getSpelExpression();
+		doReturn("value").when(evaluator).evaluate(any());
+
+		assertThat(provider.getParameterValue(parameter)).hasValue("FOO");
 
-		Object result = provider.getParameterValue(parameter);
-		assertThat(result).isEqualTo("FOO");
 		verify(delegate, times(0)).getParameterValue(parameter);
 	}
 }

src/test/java/org/springframework/data/projection/ProjectingMethodInterceptorUnitTests.java

@@ -16,7 +16,7 @@
 package org.springframework.data.projection;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Collection;

src/test/java/org/springframework/data/projection/SpelEvaluatingMethodInterceptorUnitTests.java

@@ -86,12 +86,8 @@ public class SpelEvaluatingMethodInterceptorUnitTests {
 	@Test(expected = IllegalStateException.class) // DATACMNS-630
 	public void rejectsEmptySpelExpression() throws Throwable {
 
-		when(invocation.getMethod()).thenReturn(InvalidProjection.class.getMethod("getAddress"));
-
-		SpelEvaluatingMethodInterceptor interceptor = new SpelEvaluatingMethodInterceptor(delegate, new Target(),
-				new DefaultListableBeanFactory(), parser, InvalidProjection.class);
-
-		interceptor.invoke(invocation);
+		new SpelEvaluatingMethodInterceptor(delegate, new Target(), new DefaultListableBeanFactory(), parser,
+				InvalidProjection.class);
 	}
 
 	@Test // DATACMNS-630

src/test/java/org/springframework/data/querydsl/QPageRequestUnitTests.java

@@ -40,15 +40,15 @@ public class QPageRequestUnitTests extends AbstractPageRequestUnitTests {
 		QUser user = QUser.user;
 		QPageRequest pageRequest = new QPageRequest(0, 10, user.firstname.asc());
 
-		assertThat(pageRequest.getSort()).isEqualTo(new QSort(user.firstname.asc()));
+		assertThat(pageRequest.getSort()).isEqualTo(QSort.by(user.firstname.asc()));
 	}
 
 	@Test
 	public void constructsQPageRequestWithQSort() {
 
 		QUser user = QUser.user;
-		QPageRequest pageRequest = new QPageRequest(0, 10, new QSort(user.firstname.asc()));
+		QPageRequest pageRequest = new QPageRequest(0, 10, QSort.by(user.firstname.asc()));
 
-		assertThat(pageRequest.getSort()).isEqualTo(new QSort(user.firstname.asc()));
+		assertThat(pageRequest.getSort()).isEqualTo(QSort.by(user.firstname.asc()));
 	}
 }

src/test/java/org/springframework/data/querydsl/QSortUnitTests.java

@@ -41,11 +41,6 @@ import com.querydsl.core.types.dsl.StringPath;
  */
 public class QSortUnitTests {
 
-	@Test(expected = IllegalArgumentException.class) // DATACMNS-402
-	public void shouldThrowIfNoOrderSpecifiersAreGiven() {
-		new QSort();
-	}
-
 	@Test(expected = IllegalArgumentException.class) // DATACMNS-402
 	public void shouldThrowIfNullIsGiven() {
 		new QSort((List<OrderSpecifier<?>>) null);
@@ -165,7 +160,7 @@ public class QSortUnitTests {
 
 		StringPath path = new PathBuilderFactory().create(User.class).getString("firstname");
 
-		QSort sort = new QSort(new OrderSpecifier<String>(com.querydsl.core.types.Order.ASC, path));
+		QSort sort = new QSort(new OrderSpecifier<>(com.querydsl.core.types.Order.ASC, path));
 
 		assertThat(sort).contains(new Order(Direction.ASC, "firstname"));
 	}

src/test/java/org/springframework/data/querydsl/QuerydslRepositoryInvokerAdapterUnitTests.java

@@ -15,11 +15,10 @@
  */
 package org.springframework.data.querydsl;
 
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.io.Serializable;
-import java.lang.reflect.Method;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -27,10 +26,8 @@ import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 import org.springframework.data.domain.PageRequest;
-import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.repository.support.RepositoryInvoker;
-import org.springframework.util.MultiValueMap;
 
 import com.querydsl.core.types.Predicate;
 
@@ -57,7 +54,7 @@ public class QuerydslRepositoryInvokerAdapterUnitTests {
 	@Test // DATACMNS-669
 	public void forwardsFindAllToExecutorWithPredicate() {
 
-		Sort sort = new Sort("firstname");
+		Sort sort = Sort.by("firstname");
 		adapter.invokeFindAll(sort);
 
 		verify(executor, times(1)).findAll(predicate, sort);
@@ -67,7 +64,7 @@ public class QuerydslRepositoryInvokerAdapterUnitTests {
 	@Test // DATACMNS-669
 	public void forwardsFindAllWithPageableToExecutorWithPredicate() {
 
-		PageRequest pageable = new PageRequest(0, 10);
+		PageRequest pageable = PageRequest.of(0, 10);
 		adapter.invokeFindAll(pageable);
 
 		verify(executor, times(1)).findAll(predicate, pageable);
@@ -91,15 +88,14 @@ public class QuerydslRepositoryInvokerAdapterUnitTests {
 		verify(delegate, times(1)).hasSaveMethod();
 
 		adapter.invokeDelete(any(Serializable.class));
-		verify(delegate, times(1)).invokeDelete(any(Serializable.class));
+		verify(delegate, times(1)).invokeDelete(any());
 
 		adapter.invokeFindOne(any(Serializable.class));
-		verify(delegate, times(1)).invokeFindOne(any(Serializable.class));
+		verify(delegate, times(1)).invokeFindOne(any());
 
-		adapter.invokeQueryMethod(any(Method.class), (MultiValueMap<String, String>) any(MultiValueMap.class),
-				any(Pageable.class), any(Sort.class));
-		verify(delegate, times(1)).invokeQueryMethod(any(Method.class),
-				(MultiValueMap<String, String>) any(MultiValueMap.class), any(Pageable.class), any(Sort.class));
+		adapter.invokeQueryMethod(any(), any(), any(), any());
+
+		verify(delegate, times(1)).invokeQueryMethod(any(), any(), any(), any());
 
 		adapter.invokeSave(any());
 		verify(delegate, times(1)).invokeSave(any());

src/test/java/org/springframework/data/querydsl/binding/QuerydslPredicateBuilderUnitTests.java

@@ -173,7 +173,7 @@ public class QuerydslPredicateBuilderUnitTests {
 
 		Predicate predicate = builder.getPredicate(USER_TYPE, values, DEFAULT_BINDINGS);
 
-		assertThat(predicate).isEqualTo((Predicate) QUser.user.addresses.any().street.eq("VALUE"));
+		assertThat(predicate).isEqualTo(QUser.user.addresses.any().street.eq("VALUE"));
 	}
 
 	@Test // DATACMNS-941

src/test/java/org/springframework/data/repository/cdi/CdiRepositoryBeanUnitTests.java

@@ -53,23 +53,23 @@ public class CdiRepositoryBeanUnitTests {
 
 	@Test(expected = IllegalArgumentException.class)
 	public void voidRejectsNullQualifiers() {
-		new DummyCdiRepositoryBean<SampleRepository>(null, SampleRepository.class, beanManager);
+		new DummyCdiRepositoryBean<>(null, SampleRepository.class, beanManager);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void voidRejectsNullRepositoryType() {
-		new DummyCdiRepositoryBean<SampleRepository>(NO_ANNOTATIONS, null, beanManager);
+		new DummyCdiRepositoryBean<>(NO_ANNOTATIONS, null, beanManager);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void voidRejectsNullBeanManager() {
-		new DummyCdiRepositoryBean<SampleRepository>(NO_ANNOTATIONS, SampleRepository.class, null);
+		new DummyCdiRepositoryBean<>(NO_ANNOTATIONS, SampleRepository.class, null);
 	}
 
 	@Test
 	public void returnsBasicMetadata() {
 
-		DummyCdiRepositoryBean<SampleRepository> bean = new DummyCdiRepositoryBean<SampleRepository>(NO_ANNOTATIONS,
+		DummyCdiRepositoryBean<SampleRepository> bean = new DummyCdiRepositoryBean<>(NO_ANNOTATIONS,
 				SampleRepository.class, beanManager);
 
 		assertThat(bean.getBeanClass()).isEqualTo(SampleRepository.class);
@@ -80,7 +80,7 @@ public class CdiRepositoryBeanUnitTests {
 	@Test
 	public void returnsAllImplementedTypes() {
 
-		DummyCdiRepositoryBean<SampleRepository> bean = new DummyCdiRepositoryBean<SampleRepository>(NO_ANNOTATIONS,
+		DummyCdiRepositoryBean<SampleRepository> bean = new DummyCdiRepositoryBean<>(NO_ANNOTATIONS,
 				SampleRepository.class, beanManager);
 
 		Set<Type> types = bean.getTypes();
@@ -91,7 +91,7 @@ public class CdiRepositoryBeanUnitTests {
 	@SuppressWarnings("unchecked")
 	public void detectsStereotypes() {
 
-		DummyCdiRepositoryBean<StereotypedSampleRepository> bean = new DummyCdiRepositoryBean<StereotypedSampleRepository>(
+		DummyCdiRepositoryBean<StereotypedSampleRepository> bean = new DummyCdiRepositoryBean<>(
 				NO_ANNOTATIONS, StereotypedSampleRepository.class, beanManager);
 
 		assertThat(bean.getStereotypes()).containsExactly(StereotypeAnnotation.class);
@@ -101,7 +101,7 @@ public class CdiRepositoryBeanUnitTests {
 	@SuppressWarnings("rawtypes")
 	public void scopeDefaultsToApplicationScoped() {
 
-		Bean<SampleRepository> bean = new DummyCdiRepositoryBean<SampleRepository>(NO_ANNOTATIONS, SampleRepository.class,
+		Bean<SampleRepository> bean = new DummyCdiRepositoryBean<>(NO_ANNOTATIONS, SampleRepository.class,
 				beanManager);
 		assertThat(bean.getScope()).isEqualTo(ApplicationScoped.class);
 	}
@@ -109,7 +109,7 @@ public class CdiRepositoryBeanUnitTests {
 	@Test // DATACMNS-322
 	public void createsPassivationId() {
 
-		CdiRepositoryBean<SampleRepository> bean = new DummyCdiRepositoryBean<SampleRepository>(SINGLE_ANNOTATION,
+		CdiRepositoryBean<SampleRepository> bean = new DummyCdiRepositoryBean<>(SINGLE_ANNOTATION,
 				SampleRepository.class, beanManager);
 		assertThat(bean.getId()).isEqualTo(PASSIVATION_ID);
 	}

src/test/java/org/springframework/data/repository/config/AnnotationRepositoryConfigurationSourceUnitTests.java

@@ -101,7 +101,7 @@ public class AnnotationRepositoryConfigurationSourceUnitTests {
 	public void findsStringAttributeByName() {
 
 		RepositoryConfigurationSource source = getConfigSource(DefaultConfigurationWithBasePackage.class);
-		assertThat(source.getAttribute("namedQueriesLocation")).isEqualTo("bar");
+		assertThat(source.getAttribute("namedQueriesLocation")).hasValue("bar");
 	}
 
 	@Test // DATACMNS-502
@@ -129,7 +129,7 @@ public class AnnotationRepositoryConfigurationSourceUnitTests {
 		RepositoryConfigurationSource configurationSource = new AnnotationRepositoryConfigurationSource(metadata,
 				SampleAnnotation.class, resourceLoader, environment);
 
-		assertThat(configurationSource.getRepositoryBaseClassName()).isNull();
+		assertThat(configurationSource.getRepositoryBaseClassName()).isNotPresent();
 	}
 
 	private AnnotationRepositoryConfigurationSource getConfigSource(Class<?> type) {

src/test/java/org/springframework/data/repository/config/DefaultRepositoryConfigurationUnitTests.java

@@ -37,7 +37,7 @@ public class DefaultRepositoryConfigurationUnitTests {
 	@Test
 	public void supportsBasicConfiguration() {
 
-		RepositoryConfiguration<RepositoryConfigurationSource> configuration = new DefaultRepositoryConfiguration<RepositoryConfigurationSource>(
+		RepositoryConfiguration<RepositoryConfigurationSource> configuration = new DefaultRepositoryConfiguration<>(
 				source, new RootBeanDefinition("com.acme.MyRepository"));
 
 		assertThat(configuration.getConfigurationSource()).isEqualTo(source);

src/test/java/org/springframework/data/repository/config/RepositoryBeanDefinitionRegistrarSupportUnitTests.java

@@ -15,7 +15,7 @@
  */
 package org.springframework.data.repository.config;
 
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.lang.annotation.Annotation;
@@ -31,7 +31,7 @@ import org.springframework.core.env.StandardEnvironment;
 import org.springframework.core.io.DefaultResourceLoader;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.core.type.StandardAnnotationMetadata;
-import org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport;
+import org.springframework.data.repository.core.support.DummyRepositoryFactoryBean;
 
 /**
  * Integration test for {@link RepositoryBeanDefinitionRegistrarSupport}.
@@ -122,7 +122,7 @@ public class RepositoryBeanDefinitionRegistrarSupportUnitTests {
 	static class DummyConfigurationExtension extends RepositoryConfigurationExtensionSupport {
 
 		public String getRepositoryFactoryClassName() {
-			return RepositoryFactoryBeanSupport.class.getName();
+			return DummyRepositoryFactoryBean.class.getName();
 		}
 
 		@Override

src/test/java/org/springframework/data/repository/config/XmlRepositoryConfigurationSourceUnitTests.java

@@ -16,7 +16,7 @@
 package org.springframework.data.repository.config;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import org.junit.Test;
@@ -45,6 +45,6 @@ public class XmlRepositoryConfigurationSourceUnitTests {
 
 		when(element.getAttribute("some-xml-attribute")).thenReturn("value");
 
-		assertThat(source.getAttribute("someXmlAttribute")).isEqualTo("value");
+		assertThat(source.getAttribute("someXmlAttribute")).hasValue("value");
 	}
 }

src/test/java/org/springframework/data/repository/core/support/AbstractEntityInformationUnitTests.java

@@ -18,10 +18,9 @@ package org.springframework.data.repository.core.support;
 import static org.assertj.core.api.Assertions.*;
 
 import java.io.Serializable;
+import java.util.Optional;
 
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.repository.core.EntityInformation;
 import org.springframework.test.util.ReflectionTestUtils;
@@ -35,18 +34,16 @@ import org.springframework.util.ReflectionUtils;
  */
 public class AbstractEntityInformationUnitTests {
 
-	@Rule public ExpectedException exception = ExpectedException.none();
-
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsNullDomainClass() throws Exception {
-
-		new DummyEntityInformation<Object>(null);
+		new DummyEntityInformation<>(null);
 	}
 
 	@Test
 	public void considersEntityNewIfGetIdReturnsNull() throws Exception {
 
-		EntityInformation<Object, Serializable> metadata = new DummyEntityInformation<Object>(Object.class);
+		EntityInformation<Object, Serializable> metadata = new DummyEntityInformation<>(Object.class);
+
 		assertThat(metadata.isNew(null)).isTrue();
 		assertThat(metadata.isNew(new Object())).isFalse();
 	}
@@ -54,7 +51,8 @@ public class AbstractEntityInformationUnitTests {
 	@Test // DATACMNS-357
 	public void detectsNewStateForPrimitiveIds() {
 
-		FooEn<PrimitiveIdEntity, Serializable> fooEn = new FooEn<PrimitiveIdEntity, Serializable>(PrimitiveIdEntity.class);
+		CustomEntityInformation<PrimitiveIdEntity, Serializable> fooEn = new CustomEntityInformation<PrimitiveIdEntity, Serializable>(
+				PrimitiveIdEntity.class);
 
 		PrimitiveIdEntity entity = new PrimitiveIdEntity();
 		assertThat(fooEn.isNew(entity)).isTrue();
@@ -66,7 +64,7 @@ public class AbstractEntityInformationUnitTests {
 	@Test // DATACMNS-357
 	public void detectsNewStateForPrimitiveWrapperIds() {
 
-		FooEn<PrimitiveWrapperIdEntity, Serializable> fooEn = new FooEn<PrimitiveWrapperIdEntity, Serializable>(
+		CustomEntityInformation<PrimitiveWrapperIdEntity, Serializable> fooEn = new CustomEntityInformation<PrimitiveWrapperIdEntity, Serializable>(
 				PrimitiveWrapperIdEntity.class);
 
 		PrimitiveWrapperIdEntity entity = new PrimitiveWrapperIdEntity();
@@ -79,12 +77,12 @@ public class AbstractEntityInformationUnitTests {
 	@Test // DATACMNS-357
 	public void rejectsUnsupportedPrimitiveIdType() {
 
-		FooEn<UnsupportedPrimitiveIdEntity, ?> information = new FooEn<UnsupportedPrimitiveIdEntity, Boolean>(
+		CustomEntityInformation<UnsupportedPrimitiveIdEntity, ?> information = new CustomEntityInformation<UnsupportedPrimitiveIdEntity, Boolean>(
 				UnsupportedPrimitiveIdEntity.class);
 
-		exception.expect(IllegalArgumentException.class);
-		exception.expectMessage(boolean.class.getName());
-		information.isNew(new UnsupportedPrimitiveIdEntity());
+		assertThatExceptionOfType(IllegalArgumentException.class)//
+				.isThrownBy(() -> information.isNew(new UnsupportedPrimitiveIdEntity()))//
+				.withMessageContaining(boolean.class.getName());
 	}
 
 	static class PrimitiveIdEntity {
@@ -102,19 +100,19 @@ public class AbstractEntityInformationUnitTests {
 		@Id boolean id;
 	}
 
-	static class FooEn<T, ID extends Serializable> extends AbstractEntityInformation<T, ID> {
+	static class CustomEntityInformation<T, ID extends Serializable> extends AbstractEntityInformation<T, ID> {
 
 		private final Class<T> type;
 
-		private FooEn(Class<T> type) {
+		private CustomEntityInformation(Class<T> type) {
 			super(type);
 			this.type = type;
 		}
 
 		@Override
 		@SuppressWarnings("unchecked")
-		public ID getId(T entity) {
-			return (ID) ReflectionTestUtils.getField(entity, "id");
+		public Optional<ID> getId(T entity) {
+			return Optional.ofNullable((ID) ReflectionTestUtils.getField(entity, "id"));
 		}
 
 		@Override

src/test/java/org/springframework/data/repository/core/support/DefaultCrudMethodsUnitTests.java

@@ -142,7 +142,7 @@ public class DefaultCrudMethodsUnitTests {
 
 		RepositoryMetadata metadata = new DefaultRepositoryMetadata(repositoryInterface);
 		RepositoryInformation information = new DefaultRepositoryInformation(metadata, PagingAndSortingRepository.class,
-				null);
+				Optional.empty());
 
 		return new DefaultCrudMethods(information);
 	}

src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryInformationUnitTests.java

@@ -231,7 +231,7 @@ public class DefaultRepositoryInformationUnitTests {
 		GenericsSaveRepositoryImpl customImplementation = new GenericsSaveRepositoryImpl();
 		RepositoryMetadata metadata = new DefaultRepositoryMetadata(GenericsSaveRepository.class);
 		RepositoryInformation information = new DefaultRepositoryInformation(metadata, RepositoryFactorySupport.class,
-				customImplementation.getClass());
+				Optional.of(customImplementation.getClass()));
 
 		Method customBaseRepositoryMethod = GenericsSaveRepository.class.getMethod("save", Object.class);
 		assertThat(information.isCustomMethod(customBaseRepositoryMethod), is(true));

src/test/java/org/springframework/data/repository/core/support/DummyEntityInformation.java

@@ -16,6 +16,7 @@
 package org.springframework.data.repository.core.support;
 
 import java.io.Serializable;
+import java.util.Optional;
 
 /**
  * Dummy implementation of {@link AbstractEntityInformation}.
@@ -37,8 +38,8 @@ public class DummyEntityInformation<T> extends AbstractEntityInformation<T, Seri
 	 * (non-Javadoc)
 	 * @see org.springframework.data.repository.core.EntityInformation#getId(java.lang.Object)
 	 */
-	public Serializable getId(Object entity) {
-		return entity == null ? null : entity.toString();
+	public Optional<Serializable> getId(Object entity) {
+		return Optional.ofNullable(entity == null ? null : entity.toString());
 	}
 
 	/*
@@ -48,4 +49,4 @@ public class DummyEntityInformation<T> extends AbstractEntityInformation<T, Seri
 	public Class<Serializable> getIdType() {
 		return Serializable.class;
 	}
-}
+}

src/test/java/org/springframework/data/repository/core/support/ExampleSpecificationAccessorUnitTests.java

@@ -21,8 +21,6 @@ import static org.springframework.data.domain.ExampleMatcher.GenericPropertyMatc
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.data.domain.ExampleMatcher;
-import org.springframework.data.domain.ExampleMatcher.GenericPropertyMatcher;
-import org.springframework.data.domain.ExampleMatcher.MatcherConfigurer;
 import org.springframework.data.domain.ExampleMatcher.NoOpPropertyValueTransformer;
 import org.springframework.data.domain.ExampleMatcher.NullHandler;
 import org.springframework.data.domain.ExampleMatcher.PropertyValueTransformer;
@@ -155,12 +153,7 @@ public class ExampleSpecificationAccessorUnitTests {
 
 		specification = ExampleMatcher.matching().withStringMatcher(StringMatcher.ENDING)
 				.withMatcher("firstname", contains()).withMatcher("address.city", startsWith())
-				.withMatcher("lastname", new MatcherConfigurer<GenericPropertyMatcher>() {
-					@Override
-					public void configureMatcher(GenericPropertyMatcher matcher) {
-						matcher.ignoreCase();
-					}
-				});
+				.withMatcher("lastname", matcher -> matcher.ignoreCase());
 
 		exampleSpecificationAccessor = new ExampleMatcherAccessor(specification);
 
@@ -175,12 +168,7 @@ public class ExampleSpecificationAccessorUnitTests {
 
 		specification = ExampleMatcher.matching().//
 				withStringMatcher(StringMatcher.STARTING).//
-				withMatcher("firstname", new MatcherConfigurer<GenericPropertyMatcher>() {
-					@Override
-					public void configureMatcher(GenericPropertyMatcher matcher) {
-						matcher.ignoreCase();
-					}
-				});
+				withMatcher("firstname", matcher -> matcher.ignoreCase());
 
 		exampleSpecificationAccessor = new ExampleMatcherAccessor(specification);
 

src/test/java/org/springframework/data/repository/core/support/PersistableEntityInformationUnitTests.java

@@ -43,9 +43,10 @@ public class PersistableEntityInformationUnitTests {
 	public void usesPersistablesGetId() throws Exception {
 
 		when(persistable.getId()).thenReturn(2L, 1L, 3L);
-		assertThat(metadata.getId(persistable)).isEqualTo(2L);
-		assertThat(metadata.getId(persistable)).isEqualTo(1L);
-		assertThat(metadata.getId(persistable)).isEqualTo(3L);
+
+		assertThat(metadata.getId(persistable)).hasValue(2L);
+		assertThat(metadata.getId(persistable)).hasValue(1L);
+		assertThat(metadata.getId(persistable)).hasValue(3L);
 	}
 
 	@Test
@@ -53,6 +54,7 @@ public class PersistableEntityInformationUnitTests {
 	public void usesPersistablesIsNew() throws Exception {
 
 		when(persistable.isNew()).thenReturn(true, false);
+
 		assertThat(metadata.isNew(persistable)).isTrue();
 		assertThat(metadata.isNew(persistable)).isFalse();
 	}

src/test/java/org/springframework/data/repository/core/support/PersistenceExceptionTranslationRepositoryProxyPostProcessorUnitTests.java

@@ -15,13 +15,9 @@
  */
 package org.springframework.data.repository.core.support;
 
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
-import java.util.HashMap;
-import java.util.Map;
-
-import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -29,7 +25,6 @@ import org.mockito.runners.MockitoJUnitRunner;
 import org.springframework.aop.framework.ProxyFactory;
 import org.springframework.beans.factory.ListableBeanFactory;
 import org.springframework.dao.support.PersistenceExceptionTranslationInterceptor;
-import org.springframework.dao.support.PersistenceExceptionTranslator;
 
 /**
  * Unit test for {@link TransactionalRepositoryProxyPostProcessor}.
@@ -43,18 +38,8 @@ public class PersistenceExceptionTranslationRepositoryProxyPostProcessorUnitTest
 	@Mock ListableBeanFactory beanFactory;
 	@Mock ProxyFactory proxyFactory;
 
-	@Before
-	public void setUp() {
-
-		Map<String, PersistenceExceptionTranslator> beans = new HashMap<String, PersistenceExceptionTranslator>();
-		beans.put("foo", mock(PersistenceExceptionTranslator.class));
-		when(beanFactory.getBeansOfType(eq(PersistenceExceptionTranslator.class), anyBoolean(), anyBoolean())).thenReturn(
-				beans);
-	}
-
 	@Test(expected = IllegalArgumentException.class) // DATACMNS-318
 	public void rejectsNullBeanFactory() throws Exception {
-
 		new PersistenceExceptionTranslationRepositoryProxyPostProcessor(null);
 	}
 

src/test/java/org/springframework/data/repository/core/support/PersistentEntityInformationUnitTests.java

@@ -37,7 +37,7 @@ public class PersistentEntityInformationUnitTests {
 	public void obtainsIdAndIdTypeInformationFromPersistentEntity() {
 
 		SampleMappingContext context = new SampleMappingContext();
-		PersistentEntity<Object, SamplePersistentProperty> entity = context.getPersistentEntity(Sample.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = context.getRequiredPersistentEntity(Sample.class);
 
 		EntityInformation<Object, Long> information = new PersistentEntityInformation<Object, Long>(entity);
 		assertThat(information.getIdType()).isEqualTo(Long.class);
@@ -45,18 +45,19 @@ public class PersistentEntityInformationUnitTests {
 		Sample sample = new Sample();
 		sample.id = 5L;
 
-		assertThat(information.getId(sample)).isEqualTo(5L);
+		assertThat(information.getId(sample)).hasValue(5L);
 	}
 
 	@Test // DATACMNS-596
 	public void returnsNullIfNoIdPropertyPresent() {
 
 		SampleMappingContext context = new SampleMappingContext();
-		PersistentEntity<Object, SamplePersistentProperty> entity = context.getPersistentEntity(EntityWithoutId.class);
+		PersistentEntity<Object, SamplePersistentProperty> entity = context
+				.getRequiredPersistentEntity(EntityWithoutId.class);
 
 		PersistentEntityInformation<Object, Serializable> information = new PersistentEntityInformation<Object, Serializable>(
 				entity);
-		assertThat(information.getId(new EntityWithoutId())).isNull();
+		assertThat(information.getId(new EntityWithoutId())).isNotPresent();
 	}
 
 	static class Sample {

src/test/java/org/springframework/data/repository/core/support/QueryExecutionResultHandlerUnitTests.java

@@ -98,7 +98,7 @@ public class QueryExecutionResultHandlerUnitTests {
 
 	@Test // DATACMNS-917
 	public void defaultsNullToEmptyMap() throws Exception {
-		assertThat(handler.postProcessInvocationResult(null, getTypeDescriptorFor("map")), is(instanceOf(Map.class)));
+		assertThat(handler.postProcessInvocationResult(null, getTypeDescriptorFor("map"))).isInstanceOf(Map.class);
 	}
 
 	@Test // DATACMNS-836

src/test/java/org/springframework/data/repository/core/support/QueryExecutorMethodInterceptorUnitTests.java

@@ -15,7 +15,7 @@
  */
 package org.springframework.data.repository.core.support;
 
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Optional;

src/test/java/org/springframework/data/repository/core/support/RepositoryFactorySupportUnitTests.java

@@ -25,7 +25,6 @@ import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Future;
@@ -37,9 +36,7 @@ import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.invocation.InvocationOnMock;
 import org.mockito.runners.MockitoJUnitRunner;
-import org.mockito.stubbing.Answer;
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.core.SpringVersion;
 import org.springframework.data.domain.Page;
@@ -121,7 +118,7 @@ public class RepositoryFactorySupportUnitTests {
 	@Test
 	public void invokesCustomMethodIfItRedeclaresACRUDOne() {
 
-		ObjectRepository repository = factory.getRepository(ObjectRepository.class, Optional.of(customImplementation));
+		ObjectRepository repository = factory.getRepository(ObjectRepository.class, customImplementation);
 		repository.findOne(1);
 
 		verify(customImplementation, times(1)).findOne(1);
@@ -132,7 +129,7 @@ public class RepositoryFactorySupportUnitTests {
 	public void createsRepositoryInstanceWithCustomIntermediateRepository() {
 
 		CustomRepository repository = factory.getRepository(CustomRepository.class);
-		Pageable pageable = new PageRequest(0, 10);
+		Pageable pageable = PageRequest.of(0, 10);
 		repository.findAll(pageable);
 
 		verify(backingRepo, times(1)).findAll(pageable);
@@ -160,12 +157,9 @@ public class RepositoryFactorySupportUnitTests {
 
 		final Object reference = new Object();
 
-		when(factory.queryOne.execute(Mockito.any(Object[].class))).then(new Answer<Object>() {
-			@Override
-			public Object answer(InvocationOnMock invocation) throws Throwable {
-				Thread.sleep(500);
-				return reference;
-			}
+		when(factory.queryOne.execute(Mockito.any(Object[].class))).then(invocation -> {
+			Thread.sleep(500);
+			return reference;
 		});
 
 		ConvertingRepository repository = factory.getRepository(ConvertingRepository.class);
@@ -295,13 +289,9 @@ public class RepositoryFactorySupportUnitTests {
 
 	private ConvertingRepository prepareConvertingRepository(final Object expectedValue) {
 
-		when(factory.queryOne.execute(Mockito.any(Object[].class))).then(new Answer<Object>() {
-
-			@Override
-			public Object answer(InvocationOnMock invocation) throws Throwable {
-				Thread.sleep(200);
-				return expectedValue;
-			}
+		when(factory.queryOne.execute(Mockito.any(Object[].class))).then(invocation -> {
+			Thread.sleep(200);
+			return expectedValue;
 		});
 
 		AsyncAnnotationBeanPostProcessor processor = new AsyncAnnotationBeanPostProcessor();

src/test/java/org/springframework/data/repository/core/support/TransactionRepositoryProxyPostProcessorUnitTests.java

@@ -16,15 +16,11 @@
 package org.springframework.data.repository.core.support;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.io.Serializable;
 import java.lang.reflect.Method;
-import java.util.HashMap;
-import java.util.Map;
 
-import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -32,7 +28,6 @@ import org.mockito.Mockito;
 import org.mockito.runners.MockitoJUnitRunner;
 import org.springframework.aop.framework.ProxyFactory;
 import org.springframework.beans.factory.ListableBeanFactory;
-import org.springframework.dao.support.PersistenceExceptionTranslator;
 import org.springframework.data.repository.Repository;
 import org.springframework.data.repository.core.RepositoryInformation;
 import org.springframework.data.repository.core.support.TransactionalRepositoryProxyPostProcessor.CustomAnnotationTransactionAttributeSource;
@@ -53,15 +48,6 @@ public class TransactionRepositoryProxyPostProcessorUnitTests {
 	@Mock ProxyFactory proxyFactory;
 	@Mock RepositoryInformation repositoryInformation;
 
-	@Before
-	public void setUp() {
-
-		Map<String, PersistenceExceptionTranslator> beans = new HashMap<String, PersistenceExceptionTranslator>();
-		beans.put("foo", mock(PersistenceExceptionTranslator.class));
-		when(beanFactory.getBeansOfType(eq(PersistenceExceptionTranslator.class), anyBoolean(), anyBoolean()))
-				.thenReturn(beans);
-	}
-
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsNullBeanFactory() throws Exception {
 		new TransactionalRepositoryProxyPostProcessor(null, "transactionManager", true);

src/test/java/org/springframework/data/repository/init/ResourceReaderRepositoryInitializerUnitTests.java

@@ -15,7 +15,7 @@
  */
 package org.springframework.data.repository.init;
 
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Collection;

src/test/java/org/springframework/data/repository/query/ExtensionAwareEvaluationContextProviderUnitTests.java

@@ -55,7 +55,7 @@ public class ExtensionAwareEvaluationContextProviderUnitTests {
 	public void setUp() throws Exception {
 
 		this.method = SampleRepo.class.getMethod("findByFirstname", String.class);
-		this.provider = new ExtensionAwareEvaluationContextProvider(Collections.<EvaluationContextExtension> emptyList());
+		this.provider = new ExtensionAwareEvaluationContextProvider(Collections.<EvaluationContextExtension>emptyList());
 	}
 
 	@Test // DATACMNS-533
@@ -70,7 +70,7 @@ public class ExtensionAwareEvaluationContextProviderUnitTests {
 	@Test // DATACMNS-533
 	public void secondExtensionOverridesFirstOne() {
 
-		List<EvaluationContextExtension> extensions = new ArrayList<EvaluationContextExtension>();
+		List<EvaluationContextExtension> extensions = new ArrayList<>();
 		extensions.add(new DummyExtension("_first", "first"));
 		extensions.add(new DummyExtension("_second", "second"));
 
@@ -82,7 +82,7 @@ public class ExtensionAwareEvaluationContextProviderUnitTests {
 	@Test // DATACMNS-533
 	public void allowsDirectAccessToExtensionViaKey() {
 
-		List<EvaluationContextExtension> extensions = new ArrayList<EvaluationContextExtension>();
+		List<EvaluationContextExtension> extensions = new ArrayList<>();
 		extensions.add(new DummyExtension("_first", "first"));
 		extensions.add(new DummyExtension("_second", "second"));
 
@@ -121,9 +121,9 @@ public class ExtensionAwareEvaluationContextProviderUnitTests {
 	public void exposesPageableParameter() throws Exception {
 
 		this.method = SampleRepo.class.getMethod("findByFirstname", String.class, Pageable.class);
-		PageRequest pageable = new PageRequest(2, 3, new Sort(Direction.DESC, "lastname"));
+		PageRequest pageable = PageRequest.of(2, 3, new Sort(Direction.DESC, "lastname"));
 
-		assertThat(evaluateExpression("#pageable.offset", new Object[] { "test", pageable })).isEqualTo(6);
+		assertThat(evaluateExpression("#pageable.offset", new Object[] { "test", pageable })).isEqualTo(6L);
 		assertThat(evaluateExpression("#pageable.pageSize", new Object[] { "test", pageable })).isEqualTo(3);
 		assertThat(evaluateExpression("#pageable.sort.toString()", new Object[] { "test", pageable }))
 				.isEqualTo("lastname: DESC");

src/test/java/org/springframework/data/repository/query/ParametersParameterAccessorUnitTests.java

@@ -72,7 +72,7 @@ public class ParametersParameterAccessorUnitTests {
 		DefaultParameters parameters = new DefaultParameters(method);
 
 		ParametersParameterAccessor accessor = new ParametersParameterAccessor(parameters,
-				new Object[] { new PageRequest(0, 10), "Foo" });
+				new Object[] { PageRequest.of(0, 10), "Foo" });
 
 		assertThat(accessor).hasSize(1);
 	}

src/test/java/org/springframework/data/repository/query/ResultProcessorUnitTests.java

@@ -29,6 +29,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -107,7 +108,7 @@ public class ResultProcessorUnitTests {
 
 		ResultProcessor information = getProcessor("findAllProjection");
 
-		List<Sample> source = new ArrayList<Sample>(Arrays.asList(new Sample("Dave", "Matthews")));
+		List<Sample> source = new ArrayList<>(Arrays.asList(new Sample("Dave", "Matthews")));
 		List<SampleProjection> result = information.processResult(source);
 
 		assertThat(result).hasSize(1);
@@ -119,7 +120,7 @@ public class ResultProcessorUnitTests {
 
 		ResultProcessor information = getProcessor("findPageProjection", Pageable.class);
 
-		Page<Sample> source = new PageImpl<Sample>(Arrays.asList(new Sample("Dave", "Matthews")));
+		Page<Sample> source = new PageImpl<>(Arrays.asList(new Sample("Dave", "Matthews")));
 		Page<SampleProjection> result = information.processResult(source);
 
 		assertThat(result.getContent()).hasSize(1);
@@ -143,12 +144,12 @@ public class ResultProcessorUnitTests {
 		ParameterAccessor accessor = mock(ParameterAccessor.class);
 
 		ResultProcessor factory = getProcessor("findOneDynamic", Class.class);
-		assertThat(factory.withDynamicProjection(null)).isEqualTo(factory);
-		assertThat(factory.withDynamicProjection(accessor)).isEqualTo(factory);
+		assertThat(factory.withDynamicProjection(Optional.empty())).isEqualTo(factory);
+		assertThat(factory.withDynamicProjection(Optional.of(accessor))).isEqualTo(factory);
 
-		doReturn(SampleProjection.class).when(accessor).getDynamicProjection();
+		doReturn(Optional.of(SampleProjection.class)).when(accessor).getDynamicProjection();
 
-		ResultProcessor processor = factory.withDynamicProjection(accessor);
+		ResultProcessor processor = factory.withDynamicProjection(Optional.of(accessor));
 		assertThat(processor.getReturnedType().getReturnedType()).isEqualTo(SampleProjection.class);
 	}
 
@@ -170,7 +171,7 @@ public class ResultProcessorUnitTests {
 	@Test // DATACMNS-842
 	public void supportsSlicesAsReturnWrapper() throws Exception {
 
-		Slice<Sample> slice = new SliceImpl<Sample>(Collections.singletonList(new Sample("Dave", "Matthews")));
+		Slice<Sample> slice = new SliceImpl<>(Collections.singletonList(new Sample("Dave", "Matthews")));
 
 		Object result = getProcessor("findSliceProjection", Pageable.class).processResult(slice);
 

src/test/java/org/springframework/data/repository/query/SimpleParameterAccessorUnitTests.java

@@ -42,7 +42,6 @@ public class SimpleParameterAccessorUnitTests {
 
 	@Test
 	public void testname() throws Exception {
-
 		new ParametersParameterAccessor(parameters, new Object[] { "test" });
 	}
 
@@ -54,19 +53,16 @@ public class SimpleParameterAccessorUnitTests {
 
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsNullValues() throws Exception {
-
 		new ParametersParameterAccessor(parameters, null);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsTooLittleNumberOfArguments() throws Exception {
-
 		new ParametersParameterAccessor(parameters, new Object[0]);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsTooManyArguments() throws Exception {
-
 		new ParametersParameterAccessor(parameters, new Object[] { "test", "test" });
 	}
 
@@ -74,34 +70,38 @@ public class SimpleParameterAccessorUnitTests {
 	public void returnsNullForPageableAndSortIfNoneAvailable() throws Exception {
 
 		ParameterAccessor accessor = new ParametersParameterAccessor(parameters, new Object[] { "test" });
-		assertThat(accessor.getPageable()).isNull();
-		assertThat(accessor.getSort()).isNull();
+
+		assertThat(accessor.getPageable()).isEqualTo(Pageable.NONE);
+		assertThat(accessor.getSort().isSorted()).isFalse();
 	}
 
 	@Test
 	public void returnsSortIfAvailable() {
 
-		Sort sort = new Sort("foo");
+		Sort sort = Sort.by("foo");
 		ParameterAccessor accessor = new ParametersParameterAccessor(sortParameters, new Object[] { "test", sort });
+
 		assertThat(accessor.getSort()).isEqualTo(sort);
-		assertThat(accessor.getPageable()).isNull();
+		assertThat(accessor.getPageable()).isEqualTo(Pageable.NONE);
 	}
 
 	@Test
 	public void returnsPageableIfAvailable() {
 
-		Pageable pageable = new PageRequest(0, 10);
+		Pageable pageable = PageRequest.of(0, 10);
 		ParameterAccessor accessor = new ParametersParameterAccessor(pageableParameters, new Object[] { "test", pageable });
+
 		assertThat(accessor.getPageable()).isEqualTo(pageable);
-		assertThat(accessor.getSort()).isNull();
+		assertThat(accessor.getSort().isSorted()).isFalse();
 	}
 
 	@Test
 	public void returnsSortFromPageableIfAvailable() throws Exception {
 
-		Sort sort = new Sort("foo");
-		Pageable pageable = new PageRequest(0, 10, sort);
+		Sort sort = Sort.by("foo");
+		Pageable pageable = PageRequest.of(0, 10, sort);
 		ParameterAccessor accessor = new ParametersParameterAccessor(pageableParameters, new Object[] { "test", pageable });
+
 		assertThat(accessor.getPageable()).isEqualTo(pageable);
 		assertThat(accessor.getSort()).isEqualTo(sort);
 	}

src/test/java/org/springframework/data/repository/query/StreamQueryResultHandlerUnitTests.java

@@ -1,92 +0,0 @@
-/*
- * Copyright 2016-2017 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.repository.query;
-
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-import lombok.Value;
-
-import java.util.Arrays;
-import java.util.stream.Stream;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.springframework.core.convert.converter.Converter;
-import org.springframework.data.projection.ProjectionFactory;
-import org.springframework.data.repository.query.ResultProcessor.StreamQueryResultHandler;
-
-/**
- * Unit tests for {@link StreamQueryResultHandler}.
- *
- * @author John Blum
- * @author Oliver Gierke
- */
-public class StreamQueryResultHandlerUnitTests {
-
-	StreamQueryResultHandler handler;
-
-	@Before
-	public void setUp() {
-
-		ReturnedType returnedType = ReturnedType.of(String.class, Person.class, mock(ProjectionFactory.class));
-
-		this.handler = new StreamQueryResultHandler(returnedType, new Converter<Object, Object>() {
-
-			@Override
-			public Object convert(Object source) {
-				return source.toString();
-			}
-		});
-	}
-
-	@Test // DATACMNS-868
-	@SuppressWarnings("unchecked")
-	public void mapsStreamUsingConverter() {
-
-		Stream<Person> people = Arrays.asList(Person.of("Dave", "Matthews")).stream();
-
-		Object result = this.handler.handle(people);
-
-		assertThat(result).isInstanceOf(Stream.class);
-
-		Stream<Object> stream = (Stream<Object>) result;
-
-		assertThat(stream).allMatch(it -> {
-
-			assertThat(it).isInstanceOf(String.class);
-
-			String string = (String) it;
-
-			assertThat(string).contains("Dave");
-			assertThat(string).contains("Matthews");
-
-			return true;
-		});
-
-		stream.close();
-	}
-
-	@Test(expected = IllegalArgumentException.class) // DATACMNS-868
-	public void rejectsNullSource() {
-		handler.handle(null);
-	}
-
-	@Value(staticConstructor = "of")
-	static class Person {
-		String firstName, lastName;
-	}
-}

src/test/java/org/springframework/data/repository/query/parser/OrderBySourceUnitTests.java

@@ -16,11 +16,11 @@
 package org.springframework.data.repository.query.parser;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.springframework.data.domain.Sort.Direction.*;
+
+import java.util.Optional;
 
 import org.junit.Test;
 import org.springframework.data.domain.Sort;
-import org.springframework.data.domain.Sort.Order;
 
 /**
  * Unit test for {@link OrderBySource}.
@@ -31,19 +31,20 @@ public class OrderBySourceUnitTests {
 
 	@Test
 	public void handlesSingleDirectionAndPropertyCorrectly() throws Exception {
-		assertThat(new OrderBySource("UsernameDesc").toSort()).hasValue(new Sort(DESC, "username"));
+		assertThat(new OrderBySource("UsernameDesc").toSort()).isEqualTo(Sort.by("username").descending());
 	}
 
 	@Test
 	public void handlesCamelCasePropertyCorrecty() throws Exception {
-		assertThat(new OrderBySource("LastnameUsernameDesc").toSort()).hasValue(new Sort(DESC, "lastnameUsername"));
+		assertThat(new OrderBySource("LastnameUsernameDesc").toSort()).isEqualTo(Sort.by("lastnameUsername").descending());
 	}
 
 	@Test
 	public void handlesMultipleDirectionsCorrectly() throws Exception {
 
 		OrderBySource orderBySource = new OrderBySource("LastnameAscUsernameDesc");
-		assertThat(orderBySource.toSort()).hasValue(new Sort(new Order(ASC, "lastname"), new Order(DESC, "username")));
+		assertThat(orderBySource.toSort()).isEqualTo(Sort.by("lastname").ascending().and(Sort.by("username").descending()));
+		// assertThat(orderBySource.toSort()).hasValue(new Sort(new Order(ASC, "lastname"), new Order(DESC, "username")));
 	}
 
 	@Test(expected = IllegalArgumentException.class)
@@ -55,15 +56,20 @@ public class OrderBySourceUnitTests {
 	@Test
 	public void usesNestedPropertyCorrectly() throws Exception {
 
-		OrderBySource source = new OrderBySource("BarNameDesc", Foo.class);
-		assertThat(source.toSort()).hasValue(new Sort(new Order(DESC, "bar.name")));
+		OrderBySource source = new OrderBySource("BarNameDesc", Optional.of(Foo.class));
+		assertThat(source.toSort()).isEqualTo(Sort.by("bar.name").descending());
 	}
 
 	@Test // DATACMNS-641
 	public void defaultsSortOrderToAscendingSort() {
 
 		OrderBySource source = new OrderBySource("lastname");
-		assertThat(source.toSort()).hasValue(new Sort("lastname"));
+		assertThat(source.toSort()).isEqualTo(Sort.by("lastname"));
+	}
+
+	@Test
+	public void orderBySourceFromEmptyStringResultsInUnsorted() {
+		assertThat(new OrderBySource("").toSort()).isEqualTo(Sort.unsorted());
 	}
 
 	@SuppressWarnings("unused")

src/test/java/org/springframework/data/repository/query/parser/PartTreeUnitTests.java

@@ -28,7 +28,6 @@ import java.util.List;
 
 import org.junit.Test;
 import org.springframework.data.domain.Sort;
-import org.springframework.data.domain.Sort.Direction;
 import org.springframework.data.mapping.PropertyPath;
 import org.springframework.data.repository.query.parser.Part.IgnoreCaseType;
 import org.springframework.data.repository.query.parser.Part.Type;
@@ -74,14 +73,14 @@ public class PartTreeUnitTests {
 	public void parsesAndPropertiesCorrectly() throws Exception {
 		PartTree partTree = partTree("firstnameAndLastname");
 		assertPart(partTree, parts("firstname", "lastname"));
-		assertThat(partTree.getSort()).isNull();
+		assertThat(partTree.getSort().isSorted()).isFalse();
 	}
 
 	@Test
 	public void parsesOrPropertiesCorrectly() throws Exception {
 		PartTree partTree = partTree("firstnameOrLastname");
 		assertPart(partTree, parts("firstname"), parts("lastname"));
-		assertThat(partTree.getSort()).isNull();
+		assertThat(partTree.getSort().isSorted()).isFalse();
 	}
 
 	@Test
@@ -92,8 +91,7 @@ public class PartTreeUnitTests {
 
 	@Test
 	public void hasSortIfOrderByIsGiven() throws Exception {
-		PartTree partTree = partTree("firstnameOrderByLastnameDesc");
-		assertThat(partTree.getSort()).isEqualTo(new Sort(Direction.DESC, "lastname"));
+		assertThat(partTree("firstnameOrderByLastnameDesc").getSort()).isEqualTo(Sort.by("lastname").descending());
 	}
 
 	@Test
@@ -105,7 +103,7 @@ public class PartTreeUnitTests {
 
 	private void hasSortIfOrderByIsGivenWithAllIgnoreCase(String source) throws Exception {
 		PartTree partTree = partTree(source);
-		assertThat(partTree.getSort()).isEqualTo(new Sort(Direction.DESC, "lastname"));
+		assertThat(partTree.getSort()).isEqualTo(Sort.by("lastname").descending());
 	}
 
 	@Test
@@ -119,7 +117,7 @@ public class PartTreeUnitTests {
 			// Check it's non-greedy (would strip everything until Order*By*
 			// otherwise)
 			PartTree tree = detectsDistinctCorrectly(prefix + "ByLastnameOrderByFirstnameDesc", false);
-			assertThat(tree.getSort()).isEqualTo(new Sort(Direction.DESC, "firstname"));
+			assertThat(tree.getSort()).isEqualTo(Sort.by("firstname").descending());
 		}
 	}
 
@@ -289,7 +287,9 @@ public class PartTreeUnitTests {
 
 	@Test // DATACMNS-221
 	public void parsesSpecialCharactersCorrectly() {
+
 		PartTree tree = new PartTree("findByØreAndÅrOrderByÅrAsc", DomainObjectWithSpecialChars.class);
+
 		assertPart(tree, new Part[] { new Part("øre", DomainObjectWithSpecialChars.class),
 				new Part("år", DomainObjectWithSpecialChars.class) });
 		assertThat(tree.getSort().getOrderFor("år").isAscending()).isTrue();
@@ -332,7 +332,7 @@ public class PartTreeUnitTests {
 						new Part("이름", DomainObjectWithSpecialChars.class), //
 						new Part("order.id", DomainObjectWithSpecialChars.class), //
 						new Part("nested.이름", DomainObjectWithSpecialChars.class) //
-		});
+				});
 		assertPartsIn(parts.next(), new Part[] { //
 				new Part("nested.order.id", DomainObjectWithSpecialChars.class) //
 		});
@@ -365,13 +365,13 @@ public class PartTreeUnitTests {
 						new Part("property1", DomainObjectWithSpecialChars.class), //
 						new Part("øre", DomainObjectWithSpecialChars.class), //
 						new Part("år", DomainObjectWithSpecialChars.class) //
-		});
+				});
 		assertPartsIn(parts.next(),
 				new Part[] { //
 						new Part("nested.order.id", DomainObjectWithSpecialChars.class), //
 						new Part("nested.property1", DomainObjectWithSpecialChars.class), //
 						new Part("property1", DomainObjectWithSpecialChars.class) //
-		});
+				});
 
 		assertThat(tree.getSort().getOrderFor("생일").isAscending()).isTrue();
 	}
@@ -440,7 +440,7 @@ public class PartTreeUnitTests {
 		PartTree tree = new PartTree("findAllByOrderByLastnameAsc", User.class);
 
 		assertThat(tree.getParts()).isEmpty();
-		assertThat(tree.getSort()).isEqualTo(new Sort(Direction.ASC, "lastname"));
+		assertThat(tree.getSort()).isEqualTo(Sort.by("lastname").ascending());
 	}
 
 	@Test // DATACMNS-448
@@ -665,7 +665,7 @@ public class PartTreeUnitTests {
 
 	private static <T> Collection<T> toCollection(Iterable<T> iterable) {
 
-		List<T> result = new ArrayList<T>();
+		List<T> result = new ArrayList<>();
 		for (T element : iterable) {
 			result.add(element);
 		}

src/test/java/org/springframework/data/repository/support/CrudRepositoryInvokerUnitTests.java

@@ -96,8 +96,8 @@ public class CrudRepositoryInvokerUnitTests {
 
 		Method method = CrudRepository.class.getMethod("findAll");
 
-		getInvokerFor(orderRepository, expectInvocationOf(method)).invokeFindAll((Pageable) null);
-		getInvokerFor(orderRepository, expectInvocationOf(method)).invokeFindAll((Sort) null);
+		getInvokerFor(orderRepository, expectInvocationOf(method)).invokeFindAll(Pageable.NONE);
+		getInvokerFor(orderRepository, expectInvocationOf(method)).invokeFindAll(Sort.unsorted());
 	}
 
 	@Test // DATACMNS-589
@@ -107,9 +107,9 @@ public class CrudRepositoryInvokerUnitTests {
 
 		Method findAllWithSort = CrudWithFindAllWithSort.class.getMethod("findAll", Sort.class);
 
-		getInvokerFor(repository, expectInvocationOf(findAllWithSort)).invokeFindAll((Pageable) null);
-		getInvokerFor(repository, expectInvocationOf(findAllWithSort)).invokeFindAll(new PageRequest(0, 10));
-		getInvokerFor(repository, expectInvocationOf(findAllWithSort)).invokeFindAll((Sort) null);
+		getInvokerFor(repository, expectInvocationOf(findAllWithSort)).invokeFindAll(Sort.unsorted());
+		getInvokerFor(repository, expectInvocationOf(findAllWithSort)).invokeFindAll(PageRequest.of(0, 10));
+		getInvokerFor(repository, expectInvocationOf(findAllWithSort)).invokeFindAll(Pageable.NONE);
 	}
 
 	@Test // DATACMNS-589
@@ -119,8 +119,8 @@ public class CrudRepositoryInvokerUnitTests {
 
 		Method findAllWithPageable = CrudWithFindAllWithPageable.class.getMethod("findAll", Pageable.class);
 
-		getInvokerFor(repository, expectInvocationOf(findAllWithPageable)).invokeFindAll((Pageable) null);
-		getInvokerFor(repository, expectInvocationOf(findAllWithPageable)).invokeFindAll(new PageRequest(0, 10));
+		getInvokerFor(repository, expectInvocationOf(findAllWithPageable)).invokeFindAll(Pageable.NONE);
+		getInvokerFor(repository, expectInvocationOf(findAllWithPageable)).invokeFindAll(PageRequest.of(0, 10));
 	}
 
 	@SuppressWarnings({ "rawtypes", "unchecked" })
@@ -150,7 +150,7 @@ public class CrudRepositoryInvokerUnitTests {
 
 	static class Person {}
 
-	interface PersonRepository extends PagingAndSortingRepository<Person, Long> {
+	public interface PersonRepository extends PagingAndSortingRepository<Person, Long> {
 
 		Page<Person> findByFirstName(@Param("firstName") String firstName, Pageable pageable);
 

src/test/java/org/springframework/data/repository/support/DefaultRepositoryInvokerFactoryIntegrationTests.java

@@ -23,7 +23,6 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
-import org.mockito.Mockito;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.repository.sample.Product;
 import org.springframework.data.repository.sample.ProductRepository;
@@ -56,7 +55,7 @@ public class DefaultRepositoryInvokerFactoryIntegrationTests {
 	@Test // DATACMNS-410, DATACMNS-589
 	public void findOneShouldDelegateToAppropriateRepository() {
 
-		Mockito.reset(productRepository);
+		// Mockito.reset(productRepository);
 		Product product = new Product();
 		when(productRepository.findOne(4711L)).thenReturn(product);
 

src/test/java/org/springframework/data/repository/support/DomainClassConverterIntegrationTests.java

@@ -33,9 +33,7 @@ import org.springframework.context.support.GenericApplicationContext;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.data.repository.CrudRepository;
-import org.springframework.data.repository.core.EntityInformation;
 import org.springframework.data.repository.core.RepositoryInformation;
-import org.springframework.data.repository.core.support.DummyEntityInformation;
 import org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport;
 import org.springframework.data.repository.core.support.RepositoryFactoryInformation;
 
@@ -65,16 +63,10 @@ public class DomainClassConverterIntegrationTests {
 		beanFactory.registerBeanDefinition("postProcessor", new RootBeanDefinition(PredictingProcessor.class));
 		beanFactory.registerBeanDefinition("repoFactory", new RootBeanDefinition(RepositoryFactoryBeanSupport.class));
 
-		doReturn(PersonRepository.class).when(information).getRepositoryInterface();
 		doReturn(Person.class).when(information).getDomainType();
 		doReturn(Serializable.class).when(information).getIdType();
-
-		EntityInformation<Person, Serializable> entityInformation = new DummyEntityInformation<Person>(Person.class);
-
-		when(factory.getObject()).thenReturn(repository);
-		when(factory.getObjectType()).thenReturn(PersonRepository.class);
-		when(factory.getEntityInformation()).thenReturn(entityInformation);
-		when(factory.getRepositoryInformation()).thenReturn(information);
+		doReturn(PersonRepository.class).when(factory).getObjectType();
+		doReturn(information).when(factory).getRepositoryInformation();
 
 		GenericApplicationContext context = new GenericApplicationContext(beanFactory);
 		context.refresh();

src/test/java/org/springframework/data/repository/support/DomainClassConverterUnitTests.java

@@ -16,7 +16,7 @@
 package org.springframework.data.repository.support;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.lang.reflect.Method;
@@ -46,7 +46,7 @@ import org.springframework.web.bind.annotation.ModelAttribute;
  * @author Oliver Gierke
  * @author Thomas Darimont
  */
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(MockitoJUnitRunner.Silent.class)
 public class DomainClassConverterUnitTests {
 
 	static final User USER = new User();
@@ -115,8 +115,7 @@ public class DomainClassConverterUnitTests {
 		ApplicationContext context = initContextWithRepo();
 		converter.setApplicationContext(context);
 
-		when(service.canConvert(String.class, Long.class)).thenReturn(true);
-		when(service.convert(anyString(), eq(Long.class))).thenReturn(1L);
+		doReturn(1L).when(service).convert(any(), eq(Long.class));
 
 		converter.convert("1", STRING_TYPE, USER_TYPE);
 

src/test/java/org/springframework/data/repository/support/MethodParametersUnitTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2014 the original author or authors.
+ * Copyright 2013-2016 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@ import static org.assertj.core.api.Assertions.*;
 
 import java.lang.reflect.Method;
 import java.util.List;
+import java.util.Optional;
 
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Qualifier;
@@ -35,11 +36,11 @@ public class MethodParametersUnitTests {
 	public void prefersAnnotatedParameterOverDiscovered() throws Exception {
 
 		Method method = Sample.class.getMethod("method", String.class, String.class, Object.class);
-		MethodParameters parameters = new MethodParameters(method, new AnnotationAttribute(Qualifier.class));
+		MethodParameters parameters = new MethodParameters(method, Optional.of(new AnnotationAttribute(Qualifier.class)));
 
-		assertThat(parameters.getParameter("param")).isNotNull();
-		assertThat(parameters.getParameter("foo")).isNotNull();
-		assertThat(parameters.getParameter("another")).isNull();
+		assertThat(parameters.getParameter("param")).isPresent();
+		assertThat(parameters.getParameter("foo")).isPresent();
+		assertThat(parameters.getParameter("another")).isNotPresent();
 	}
 
 	/**
@@ -52,6 +53,7 @@ public class MethodParametersUnitTests {
 		MethodParameters methodParameters = new MethodParameters(method);
 
 		List<MethodParameter> objectParameters = methodParameters.getParametersOfType(Object.class);
+
 		assertThat(objectParameters).hasSize(1);
 		assertThat(objectParameters.get(0).getParameterIndex()).isEqualTo(2);
 	}

src/test/java/org/springframework/data/repository/support/PageableExecutionUtilsUnitTests.java

@@ -20,6 +20,7 @@ import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.function.LongSupplier;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -27,7 +28,7 @@ import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
-import org.springframework.data.repository.support.PageableExecutionUtils.TotalSupplier;
+import org.springframework.data.domain.Pageable;
 
 /**
  * Unit tests for {@link PageableExecutionUtils}.
@@ -38,7 +39,7 @@ import org.springframework.data.repository.support.PageableExecutionUtils.TotalS
 @RunWith(MockitoJUnitRunner.class)
 public class PageableExecutionUtilsUnitTests {
 
-	@Mock TotalSupplier totalSupplierMock;
+	@Mock LongSupplier totalSupplierMock;
 
 	@Test // DATAMCNS-884
 	public void firstPageRequestIsLessThanOneFullPageDoesNotRequireTotal() {
@@ -52,9 +53,9 @@ public class PageableExecutionUtilsUnitTests {
 	}
 
 	@Test // DATAMCNS-884
-	public void noPageableRequesDoesNotRequireTotal() {
+	public void noPageableRequestDoesNotRequireTotal() {
 
-		Page<Integer> page = PageableExecutionUtils.getPage(Arrays.asList(1, 2, 3), null, totalSupplierMock);
+		Page<Integer> page = PageableExecutionUtils.getPage(Arrays.asList(1, 2, 3), Pageable.NONE, totalSupplierMock);
 
 		assertThat(page).contains(1, 2, 3);
 		assertThat(page.getTotalElements()).isEqualTo(3L);
@@ -65,7 +66,7 @@ public class PageableExecutionUtilsUnitTests {
 	@Test // DATAMCNS-884
 	public void subsequentPageRequestIsLessThanOneFullPageDoesNotRequireTotal() {
 
-		Page<Integer> page = PageableExecutionUtils.getPage(Arrays.asList(1, 2, 3), new PageRequest(5, 10),
+		Page<Integer> page = PageableExecutionUtils.getPage(Arrays.asList(1, 2, 3), PageRequest.of(5, 10),
 				totalSupplierMock);
 
 		assertThat(page).contains(1, 2, 3);
@@ -77,7 +78,7 @@ public class PageableExecutionUtilsUnitTests {
 	@Test // DATAMCNS-884
 	public void firstPageRequestHitsUpperBoundRequiresTotal() {
 
-		doReturn(4L).when(totalSupplierMock).get();
+		doReturn(4L).when(totalSupplierMock).getAsLong();
 
 		Page<Integer> page = PageableExecutionUtils.getPage(Arrays.asList(1, 2, 3), PageRequest.of(0, 3),
 				totalSupplierMock);
@@ -85,13 +86,13 @@ public class PageableExecutionUtilsUnitTests {
 		assertThat(page).contains(1, 2, 3);
 		assertThat(page.getTotalElements()).isEqualTo(4L);
 
-		verify(totalSupplierMock).get();
+		verify(totalSupplierMock).getAsLong();
 	}
 
 	@Test // DATAMCNS-884
 	public void subsequentPageRequestHitsUpperBoundRequiresTotal() {
 
-		doReturn(7L).when(totalSupplierMock).get();
+		doReturn(7L).when(totalSupplierMock).getAsLong();
 
 		Page<Integer> page = PageableExecutionUtils.getPage(Arrays.asList(1, 2, 3), PageRequest.of(1, 3),
 				totalSupplierMock);
@@ -99,18 +100,18 @@ public class PageableExecutionUtilsUnitTests {
 		assertThat(page).contains(1, 2, 3);
 		assertThat(page.getTotalElements()).isEqualTo(7L);
 
-		verify(totalSupplierMock).get();
+		verify(totalSupplierMock).getAsLong();
 	}
 
 	@Test // DATAMCNS-884
 	public void subsequentPageRequestWithoutResultRequiresRequireTotal() {
 
-		doReturn(7L).when(totalSupplierMock).get();
-		Page<Integer> page = PageableExecutionUtils.getPage(Collections.<Integer>emptyList(), new PageRequest(5, 10),
+		doReturn(7L).when(totalSupplierMock).getAsLong();
+		Page<Integer> page = PageableExecutionUtils.getPage(Collections.<Integer>emptyList(), PageRequest.of(5, 10),
 				totalSupplierMock);
 
 		assertThat(page.getTotalElements()).isEqualTo(7L);
 
-		verify(totalSupplierMock).get();
+		verify(totalSupplierMock).getAsLong();
 	}
 }

src/test/java/org/springframework/data/repository/support/PaginginAndSortingRepositoryInvokerUnitTests.java

@@ -45,8 +45,8 @@ public class PaginginAndSortingRepositoryInvokerUnitTests {
 		Repository repository = mock(Repository.class);
 		Method method = PagingAndSortingRepository.class.getMethod("findAll", Pageable.class);
 
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(new PageRequest(0, 10));
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll((Pageable) null);
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(PageRequest.of(0, 10));
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Pageable.NONE);
 	}
 
 	@Test // DATACMNS-589
@@ -55,8 +55,8 @@ public class PaginginAndSortingRepositoryInvokerUnitTests {
 		Repository repository = mock(Repository.class);
 		Method method = PagingAndSortingRepository.class.getMethod("findAll", Sort.class);
 
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(new Sort("foo"));
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll((Sort) null);
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Sort.by("foo"));
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Sort.unsorted());
 	}
 
 	@Test // DATACMNS-589
@@ -65,8 +65,8 @@ public class PaginginAndSortingRepositoryInvokerUnitTests {
 		RepositoryWithRedeclaredFindAllWithPageable repository = mock(RepositoryWithRedeclaredFindAllWithPageable.class);
 		Method method = RepositoryWithRedeclaredFindAllWithPageable.class.getMethod("findAll", Pageable.class);
 
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(new PageRequest(0, 10));
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll((Pageable) null);
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(PageRequest.of(0, 10));
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Pageable.NONE);
 	}
 
 	@Test // DATACMNS-589
@@ -75,8 +75,8 @@ public class PaginginAndSortingRepositoryInvokerUnitTests {
 		RepositoryWithRedeclaredFindAllWithSort repository = mock(RepositoryWithRedeclaredFindAllWithSort.class);
 		Method method = RepositoryWithRedeclaredFindAllWithSort.class.getMethod("findAll", Sort.class);
 
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(new Sort("foo"));
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll((Sort) null);
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Sort.by("foo"));
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Sort.unsorted());
 	}
 
 	@SuppressWarnings({ "unchecked", "rawtypes" })

src/test/java/org/springframework/data/repository/support/ReflectionRepositoryInvokerUnitTests.java

@@ -58,7 +58,7 @@ import org.springframework.util.MultiValueMap;
 @RunWith(MockitoJUnitRunner.class)
 public class ReflectionRepositoryInvokerUnitTests {
 
-	static final Page<Person> EMPTY_PAGE = new PageImpl<Person>(Collections.<Person> emptyList());
+	static final Page<Person> EMPTY_PAGE = new PageImpl<>(Collections.emptyList());
 
 	ConversionService conversionService;
 
@@ -104,10 +104,10 @@ public class ReflectionRepositoryInvokerUnitTests {
 		Method method = ManualCrudRepository.class.getMethod("findAll");
 		ManualCrudRepository repository = mock(ManualCrudRepository.class);
 
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll((Pageable) null);
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(new PageRequest(0, 10));
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll((Sort) null);
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(new Sort("foo"));
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Pageable.NONE);
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(PageRequest.of(0, 10));
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Sort.unsorted());
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Sort.by("foo"));
 	}
 
 	@Test // DATACMNS-589
@@ -116,10 +116,10 @@ public class ReflectionRepositoryInvokerUnitTests {
 		Method method = RepoWithFindAllWithSort.class.getMethod("findAll", Sort.class);
 		RepoWithFindAllWithSort repository = mock(RepoWithFindAllWithSort.class);
 
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll((Pageable) null);
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(new PageRequest(0, 10));
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll((Sort) null);
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(new Sort("foo"));
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Pageable.NONE);
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(PageRequest.of(0, 10));
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Sort.unsorted());
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Sort.by("foo"));
 	}
 
 	@Test // DATACMNS-589
@@ -128,8 +128,8 @@ public class ReflectionRepositoryInvokerUnitTests {
 		Method method = RepoWithFindAllWithPageable.class.getMethod("findAll", Pageable.class);
 		RepoWithFindAllWithPageable repository = mock(RepoWithFindAllWithPageable.class);
 
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll((Pageable) null);
-		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(new PageRequest(0, 10));
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(Pageable.NONE);
+		getInvokerFor(repository, expectInvocationOf(method)).invokeFindAll(PageRequest.of(0, 10));
 	}
 
 	@Test // DATACMNS-589
@@ -141,7 +141,8 @@ public class ReflectionRepositoryInvokerUnitTests {
 		Method method = PersonRepository.class.getMethod("findByFirstName", String.class, Pageable.class);
 		PersonRepository repository = mock(PersonRepository.class);
 
-		getInvokerFor(repository, expectInvocationOf(method)).invokeQueryMethod(method, parameters, null, null);
+		getInvokerFor(repository, expectInvocationOf(method)).invokeQueryMethod(method, parameters, Pageable.NONE,
+				Sort.unsorted());
 	}
 
 	@Test // DATACMNS-589
@@ -153,7 +154,8 @@ public class ReflectionRepositoryInvokerUnitTests {
 		Method method = PersonRepository.class.getMethod("findByCreatedUsingISO8601Date", Date.class, Pageable.class);
 		PersonRepository repository = mock(PersonRepository.class);
 
-		getInvokerFor(repository, expectInvocationOf(method)).invokeQueryMethod(method, parameters, null, null);
+		getInvokerFor(repository, expectInvocationOf(method)).invokeQueryMethod(method, parameters, Pageable.NONE,
+				Sort.unsorted());
 	}
 
 	@Test // DATAREST-335, DATAREST-346, DATACMNS-589
@@ -189,7 +191,7 @@ public class ReflectionRepositoryInvokerUnitTests {
 		RepositoryInvoker invoker = getInvokerFor(mock(EmptyRepository.class));
 
 		assertThat(invoker.hasFindAllMethod()).isFalse();
-		invoker.invokeFindAll((Pageable) null);
+		invoker.invokeFindAll(Sort.unsorted());
 	}
 
 	@Test(expected = IllegalStateException.class) // DATACMNS-589
@@ -212,7 +214,8 @@ public class ReflectionRepositoryInvokerUnitTests {
 			Method method = PersonRepository.class.getMethod("findByIdIn", Collection.class);
 			PersonRepository repository = mock(PersonRepository.class);
 
-			getInvokerFor(repository, expectInvocationOf(method)).invokeQueryMethod(method, parameters, null, null);
+			getInvokerFor(repository, expectInvocationOf(method)).invokeQueryMethod(method, parameters, Pageable.NONE,
+					Sort.unsorted());
 		}
 	}
 
@@ -227,7 +230,7 @@ public class ReflectionRepositoryInvokerUnitTests {
 		Method method = SimpleRepository.class.getMethod("findByClass", int.class);
 
 		try {
-			invoker.invokeQueryMethod(method, parameters, null, null);
+			invoker.invokeQueryMethod(method, parameters, Pageable.NONE, Sort.unsorted());
 		} catch (QueryMethodParameterConversionException o_O) {
 
 			assertThat(o_O.getParameter()).isEqualTo(new MethodParameters(method).getParameters().get(0));

src/test/java/org/springframework/data/repository/support/RepositoriesUnitTests.java

@@ -54,7 +54,7 @@ import org.springframework.util.ClassUtils;
  * @author Oliver Gierke
  * @author Thomas Darimont
  */
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(MockitoJUnitRunner.Silent.class)
 public class RepositoriesUnitTests {
 
 	GenericApplicationContext context;
@@ -174,7 +174,7 @@ public class RepositoriesUnitTests {
 		}
 
 		public PersistentEntity<?, ?> getPersistentEntity() {
-			return mappingContext.getPersistentEntity(repositoryMetadata.getDomainType());
+			return mappingContext.getRequiredPersistentEntity(repositoryMetadata.getDomainType());
 		}
 
 		public List<QueryMethod> getQueryMethods() {
@@ -217,7 +217,7 @@ public class RepositoriesUnitTests {
 		 */
 		@Override
 		public Set<Class<?>> getAlternativeDomainTypes() {
-			return Collections.<Class<?>> singleton(super.getDomainType());
+			return Collections.<Class<?>>singleton(super.getDomainType());
 		}
 	}
 

src/test/java/org/springframework/data/util/AnnotationDetectionMethodCallbackUnitTests.java

@@ -35,7 +35,7 @@ public class AnnotationDetectionMethodCallbackUnitTests {
 	@Test // DATACMNS-452
 	public void findsMethodWithAnnotation() throws Exception {
 
-		AnnotationDetectionMethodCallback<Value> callback = new AnnotationDetectionMethodCallback<Value>(Value.class);
+		AnnotationDetectionMethodCallback<Value> callback = new AnnotationDetectionMethodCallback<>(Value.class);
 		ReflectionUtils.doWithMethods(Sample.class, callback);
 
 		assertThat(callback.hasFoundAnnotation()).isTrue();
@@ -52,7 +52,7 @@ public class AnnotationDetectionMethodCallbackUnitTests {
 		exception.expectMessage("getValue");
 		exception.expectMessage("getOtherValue");
 
-		AnnotationDetectionMethodCallback<Value> callback = new AnnotationDetectionMethodCallback<Value>(Value.class, true);
+		AnnotationDetectionMethodCallback<Value> callback = new AnnotationDetectionMethodCallback<>(Value.class, true);
 		ReflectionUtils.doWithMethods(Multiple.class, callback);
 	}
 

src/test/java/org/springframework/data/util/ClassTypeInformationUnitTests.java

@@ -17,6 +17,7 @@ package org.springframework.data.util;
 
 import static org.assertj.core.api.Assertions.*;
 import static org.springframework.data.util.ClassTypeInformation.*;
+import static org.springframework.data.util.OptionalAssert.*;
 
 import javaslang.collection.Traversable;
 
@@ -45,26 +46,25 @@ public class ClassTypeInformationUnitTests {
 
 		assertThat(discoverer.getType()).isEqualTo(ConcreteType.class);
 
-		TypeInformation<?> content = discoverer.getProperty("content");
+		OptionalAssert<TypeInformation<?>> assertThat = assertOptional(discoverer.getProperty("content"));
 
-		assertThat(content.getType()).isEqualTo(String.class);
-		assertThat(content.getComponentType()).isNull();
-		assertThat(content.getMapValueType()).isNull();
+		assertThat.value(it -> it.getType()).isEqualTo(String.class);
+		assertThat.flatMap(it -> it.getComponentType()).isNotPresent();
+		assertThat.flatMap(it -> it.getMapValueType()).isNotPresent();
 	}
 
 	@Test
 	public void discoversTypeForNestedGenericField() {
 
 		TypeInformation<ConcreteWrapper> discoverer = ClassTypeInformation.from(ConcreteWrapper.class);
-
 		assertThat(discoverer.getType()).isEqualTo(ConcreteWrapper.class);
-		TypeInformation<?> wrapper = discoverer.getProperty("wrapped");
-		assertThat(wrapper.getType()).isEqualTo(GenericType.class);
-		TypeInformation<?> content = wrapper.getProperty("content");
 
-		assertThat(content.getType()).isEqualTo(String.class);
-		assertThat(discoverer.getProperty("wrapped").getProperty("content").getType()).isEqualTo(String.class);
-		assertThat(discoverer.getProperty("wrapped.content").getType()).isEqualTo(String.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);
+		});
+
+		assertOptional(discoverer.getProperty("wrapped.content")).value(it -> it.getType()).isEqualTo(String.class);
 	}
 
 	@Test
@@ -72,7 +72,7 @@ public class ClassTypeInformationUnitTests {
 	public void discoversBoundType() {
 
 		TypeInformation<GenericTypeWithBound> information = ClassTypeInformation.from(GenericTypeWithBound.class);
-		assertThat(information.getProperty("person").getType()).isEqualTo(Person.class);
+		assertOptional(information.getProperty("person")).value(it -> it.getType()).isEqualTo(Person.class);
 	}
 
 	@Test
@@ -80,7 +80,7 @@ public class ClassTypeInformationUnitTests {
 
 		TypeInformation<SpecialGenericTypeWithBound> information = ClassTypeInformation
 				.from(SpecialGenericTypeWithBound.class);
-		assertThat(information.getProperty("person").getType()).isEqualTo(SpecialPerson.class);
+		assertOptional(information.getProperty("person")).value(it -> it.getType()).isEqualTo(SpecialPerson.class);
 	}
 
 	@Test
@@ -88,43 +88,52 @@ public class ClassTypeInformationUnitTests {
 	public void discoversBoundTypeForNested() {
 
 		TypeInformation<AnotherGenericType> information = ClassTypeInformation.from(AnotherGenericType.class);
-		assertThat(information.getProperty("nested").getType()).isEqualTo(GenericTypeWithBound.class);
-		assertThat(information.getProperty("nested.person").getType()).isEqualTo(Person.class);
+
+		assertOptional(information.getProperty("nested")).value(it -> it.getType()).isEqualTo(GenericTypeWithBound.class);
+		assertOptional(information.getProperty("nested.person")).value(it -> it.getType()).isEqualTo(Person.class);
 	}
 
 	@Test
 	public void discoversArraysAndCollections() {
+
 		TypeInformation<StringCollectionContainer> information = ClassTypeInformation.from(StringCollectionContainer.class);
 
-		TypeInformation<?> property = information.getProperty("array");
-		assertThat(property.getComponentType().getType()).isEqualTo(String.class);
+		OptionalAssert<TypeInformation<?>> optional = assertOptional(information.getProperty("array"));
 
-		Class<?> type = property.getType();
-		assertThat(type).isEqualTo(String[].class);
-		assertThat(type.isArray()).isTrue();
+		optional.flatMap(it -> it.getComponentType()).value(it -> it.getType()).isEqualTo(String.class);
+		optional.value(it -> it.getType()).satisfies(it -> {
+			assertThat(it).isEqualTo(String[].class);
+			assertThat(it.isArray()).isTrue();
+		});
 
-		property = information.getProperty("foo");
-		assertThat(property.getType()).isEqualTo(Collection[].class);
-		assertThat(property.getComponentType().getType()).isEqualTo(Collection.class);
-		assertThat(property.getComponentType().getComponentType().getType()).isEqualTo(String.class);
+		optional = assertOptional(information.getProperty("foo"));
 
-		property = information.getProperty("rawSet");
-		assertThat(property.getType()).isEqualTo(Set.class);
-		assertThat(property.getComponentType().getType()).isEqualTo(Object.class);
-		assertThat(property.getMapValueType()).isNull();
+		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 = 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();
 	}
 
 	@Test
 	public void discoversMapValueType() {
 
 		TypeInformation<StringMapContainer> information = ClassTypeInformation.from(StringMapContainer.class);
-		TypeInformation<?> genericMap = information.getProperty("genericMap");
-		assertThat(genericMap.getType()).isEqualTo(Map.class);
-		assertThat(genericMap.getMapValueType().getType()).isEqualTo(String.class);
+		OptionalAssert<TypeInformation<?>> assertion = assertOptional(information.getProperty("genericMap"));
 
-		TypeInformation<?> map = information.getProperty("map");
-		assertThat(map.getType()).isEqualTo(Map.class);
-		assertThat(map.getMapValueType().getType()).isEqualTo(Calendar.class);
+		assertion.value(it -> it.getType()).isEqualTo(Map.class);
+		assertion.flatMap(it -> it.getMapValueType()).value(it -> it.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);
 	}
 
 	@Test
@@ -141,13 +150,8 @@ public class ClassTypeInformationUnitTests {
 
 		TypeInformation<PropertyGetter> from = ClassTypeInformation.from(PropertyGetter.class);
 
-		TypeInformation<?> property = from.getProperty("_name");
-		assertThat(property).isNotNull();
-		assertThat(property.getType()).isEqualTo(String.class);
-
-		property = from.getProperty("name");
-		assertThat(property).isNotNull();
-		assertThat(property.getType()).isEqualTo(byte[].class);
+		assertOptional(from.getProperty("_name")).value(it -> it.getType()).isEqualTo(String.class);
+		assertOptional(from.getProperty("name")).value(it -> it.getType()).isEqualTo(byte[].class);
 	}
 
 	@Test // DATACMNS-77
@@ -162,16 +166,18 @@ public class ClassTypeInformationUnitTests {
 
 		TypeInformation<ClassWithWildCardBound> information = ClassTypeInformation.from(ClassWithWildCardBound.class);
 
-		TypeInformation<?> property = information.getProperty("wildcard");
-		assertThat(property.isCollectionLike()).isTrue();
-		assertThat(property.getComponentType().getType()).isEqualTo(String.class);
+		OptionalAssert<TypeInformation<?>> assertion = assertOptional(information.getProperty("wildcard"));
 
-		property = information.getProperty("complexWildcard");
-		assertThat(property.isCollectionLike()).isTrue();
+		assertion.value(it -> it.isCollectionLike()).isEqualTo(true);
+		assertion.flatMap(it -> it.getComponentType()).value(it -> it.getType()).isEqualTo(String.class);
 
-		TypeInformation<?> component = property.getComponentType();
-		assertThat(component.isCollectionLike()).isTrue();
-		assertThat(component.getComponentType().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);
+		});
 	}
 
 	@Test
@@ -258,8 +264,9 @@ public class ClassTypeInformationUnitTests {
 	public void returnsComponentTypeForMultiDimensionalArrayCorrectly() {
 
 		TypeInformation<?> information = from(String[][].class);
+
 		assertThat(information.getType()).isEqualTo(String[][].class);
-		assertThat(information.getComponentType().getType()).isEqualTo(String[].class);
+		assertOptional(information.getComponentType()).value(it -> it.getType()).isEqualTo(String[].class);
 		assertThat(information.getActualType().getActualType().getType()).isEqualTo(String.class);
 	}
 
@@ -268,10 +275,8 @@ public class ClassTypeInformationUnitTests {
 	public void findsGetterOnInterface() {
 
 		TypeInformation<Product> information = from(Product.class);
-		TypeInformation<?> categoryIdInfo = information.getProperty("category.id");
 
-		assertThat(categoryIdInfo).isNotNull();
-		assertThat(categoryIdInfo).isEqualTo((TypeInformation) from(Long.class));
+		assertOptional(information.getProperty("category.id")).hasValue(from(Long.class));
 	}
 
 	@Test(expected = IllegalArgumentException.class) // DATACMNS-387
@@ -280,27 +285,32 @@ public class ClassTypeInformationUnitTests {
 	}
 
 	@Test // DATACMNS-422
-	public void returnsNullForRawTypesOnly() {
+	public void returnsEmptyOptionalForRawTypesOnly() {
 
-		assertThat(from(MyRawIterable.class).getComponentType()).isNull();
-		assertThat(from(MyIterable.class).getComponentType()).isNotNull();
+		assertThat(from(MyRawIterable.class).getComponentType()).isNotPresent();
+		assertThat(from(MyIterable.class).getComponentType()).isPresent();
 	}
 
 	@Test // DATACMNS-440
 	public void detectsSpecialMapAsMapValueType() {
 
-		TypeInformation<SuperGenerics> information = ClassTypeInformation.from(SuperGenerics.class);
+		OptionalAssert<TypeInformation<?>> assertion = assertOptional(
+				ClassTypeInformation.from(SuperGenerics.class).getProperty("seriously"));
 
-		TypeInformation<?> propertyInformation = information.getProperty("seriously");
-		assertThat(propertyInformation.getType()).isEqualTo(SortedMap.class);
+		assertion//
+				// Type
+				.andAssert(inner -> inner.value(it -> it.getType()).isEqualTo(SortedMap.class))//
 
-		TypeInformation<?> mapValueType = propertyInformation.getMapValueType();
-		assertThat(mapValueType.getType()).isEqualTo(SortedMap.class);
-		assertThat(mapValueType.getComponentType().getType()).isEqualTo(String.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);
 
-		TypeInformation<?> nestedValueType = mapValueType.getMapValueType();
-		assertThat(nestedValueType.getType()).isEqualTo(List.class);
-		assertThat(nestedValueType.getComponentType().getType()).isEqualTo(Person.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);
+				}));
 	}
 
 	@Test // DATACMNS-446
@@ -313,33 +323,33 @@ public class ClassTypeInformationUnitTests {
 	public void resolvesNestedGenericsToConcreteType() {
 
 		ClassTypeInformation<ConcreteRoot> rootType = from(ConcreteRoot.class);
-		TypeInformation<?> subsPropertyType = rootType.getProperty("subs");
-		TypeInformation<?> subsElementType = subsPropertyType.getActualType();
-		TypeInformation<?> subSubType = subsElementType.getProperty("subSub");
 
-		assertThat(subSubType.getType()).isEqualTo(ConcreteSubSub.class);
+		assertOptional(rootType.getProperty("subs"))//
+				.map(it -> it.getActualType())//
+				.flatMap(it -> it.getProperty("subSub"))//
+				.value(it -> it.getType()).isEqualTo(ConcreteSubSub.class);
 	}
 
 	@Test // DATACMNS-594
 	public void considersGenericsOfTypeBounds() {
 
-		ClassTypeInformation<ConcreteRootIntermediate> customer = ClassTypeInformation.from(ConcreteRootIntermediate.class);
-		TypeInformation<?> leafType = customer.getProperty("intermediate.content.intermediate.content");
-
-		assertThat(leafType.getType()).isEqualTo(Leaf.class);
+		assertOptional(ClassTypeInformation.from(ConcreteRootIntermediate.class)
+				.getProperty("intermediate.content.intermediate.content"))//
+						.value(it -> it.getType()).isEqualTo(Leaf.class);
 	}
 
 	@Test // DATACMNS-783, DATACMNS-853
 	public void specializesTypeUsingTypeVariableContext() {
 
 		ClassTypeInformation<Foo> root = ClassTypeInformation.from(Foo.class);
-		TypeInformation<?> property = root.getProperty("abstractBar");
 
-		TypeInformation<?> specialized = property.specialize(ClassTypeInformation.from(Bar.class));
-
-		assertThat(specialized.getType()).isEqualTo(Bar.class);
-		assertThat(specialized.getProperty("field").getType()).isEqualTo(Character.class);
-		assertThat(specialized.getProperty("anotherField").getType()).isEqualTo(Integer.class);
+		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);
+				});
 	}
 
 	@Test // DATACMNS-783
@@ -347,10 +357,9 @@ public class ClassTypeInformationUnitTests {
 	public void usesTargetTypeDirectlyIfNoGenericsAreInvolved() {
 
 		ClassTypeInformation<Foo> root = ClassTypeInformation.from(Foo.class);
-		TypeInformation<?> property = root.getProperty("object");
-
 		ClassTypeInformation<?> from = ClassTypeInformation.from(Bar.class);
-		assertThat(property.specialize(from)).isEqualTo((TypeInformation) from);
+
+		assertOptional(root.getProperty("object")).value(it -> it.specialize(from)).isEqualTo(from);
 	}
 
 	@Test // DATACMNS-855
@@ -358,14 +367,17 @@ public class ClassTypeInformationUnitTests {
 	public void specializedTypeEqualsAndHashCode() {
 
 		ClassTypeInformation<Foo> root = ClassTypeInformation.from(Foo.class);
-		TypeInformation<?> property = root.getProperty("abstractBar");
 
-		TypeInformation left = property.specialize(ClassTypeInformation.from(Bar.class));
-		TypeInformation right = property.specialize(ClassTypeInformation.from(Bar.class));
+		OptionalAssert<TypeInformation<?>> assertion = assertOptional(root.getProperty("abstractBar"));
 
-		assertThat(left).isEqualTo(right);
-		assertThat(right).isEqualTo(left);
-		assertThat(left.hashCode()).isEqualTo(right.hashCode());
+		assertion
+				.map(it -> Pair.of(it.specialize(ClassTypeInformation.from(Bar.class)),
+						it.specialize(ClassTypeInformation.from(Bar.class))))//
+				.hasValueSatisfying(pair -> {
+					assertThat(pair.getFirst()).isEqualTo(pair.getSecond());
+					assertThat(pair.getSecond()).isEqualTo(pair.getFirst());
+					assertThat(pair.getFirst().hashCode()).isEqualTo(pair.getSecond().hashCode());
+				});
 	}
 
 	@Test // DATACMNS-896
@@ -373,7 +385,7 @@ public class ClassTypeInformationUnitTests {
 
 		ClassTypeInformation<Concrete> information = ClassTypeInformation.from(Concrete.class);
 
-		assertThat(information.getProperty("field").getType()).isEqualTo(Nested.class);
+		assertOptional(information.getProperty("field")).value(it -> it.getType()).isEqualTo(Nested.class);
 	}
 
 	@Test // DATACMNS-940

src/test/java/org/springframework/data/util/DataCmns511Tests.java

@@ -15,7 +15,7 @@
  */
 package org.springframework.data.util;
 
-import static org.assertj.core.api.Assertions.*;
+import static org.springframework.data.util.OptionalAssert.*;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -33,26 +33,32 @@ public class DataCmns511Tests {
 	@SuppressWarnings("rawtypes")
 	public void detectsEqualTypeVariableTypeInformationInstances() {
 
-		TypeInformation<AbstractRole> firstRoleType = ClassTypeInformation.from(AbstractRole.class);
-		TypeInformation<?> firstCreatedBy = firstRoleType.getProperty("createdBy");
-		TypeInformation<?> secondRoleType = firstCreatedBy.getProperty("roles").getActualType();
-		TypeInformation secondCreatedBy = secondRoleType.getProperty("createdBy");
-		TypeInformation<?> thirdRoleType = secondCreatedBy.getProperty("roles").getActualType();
-		TypeInformation thirdCreatedBy = thirdRoleType.getProperty("createdBy");
+		OptionalAssert<TypeInformation<?>> assertion = assertOptional(
+				ClassTypeInformation.from(AbstractRole.class).getProperty("createdBy"));
 
-		assertThat(secondCreatedBy).isEqualTo(thirdCreatedBy);
-		assertThat(secondCreatedBy.hashCode()).isEqualTo(thirdCreatedBy.hashCode());
+		assertion.flatMap(it -> it.getProperty("roles"))//
+				.map(it -> it.getActualType())//
+				.flatMap(it -> it.getProperty("createdBy"))//
+				.andAssert(second -> {
+
+					OptionalAssert<TypeInformation<?>> third = second.flatMap(it -> it.getProperty("roles"))//
+							.map(it -> it.getActualType())//
+							.flatMap(it -> it.getProperty("createdBy"));
+
+					second.isEqualTo(third);
+					second.value(it -> it.hashCode()).isEqualTo(third.getActual().hashCode());
+				});
 	}
 
-	static class AbstractRole<USER extends AbstractUser<USER, ROLE>, ROLE extends AbstractRole<USER, ROLE>> extends
-			AuditingEntity<USER> {
+	static class AbstractRole<USER extends AbstractUser<USER, ROLE>, ROLE extends AbstractRole<USER, ROLE>>
+			extends AuditingEntity<USER> {
 
 		String name;
 	}
 
 	static abstract class AbstractUser<USER extends AbstractUser<USER, ROLE>, ROLE extends AbstractRole<USER, ROLE>> {
 
-		Set<ROLE> roles = new HashSet<ROLE>();
+		Set<ROLE> roles = new HashSet<>();
 	}
 
 	static abstract class AuditingEntity<USER extends AbstractUser<USER, ?>> {

src/test/java/org/springframework/data/util/OptionalAssert.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.util;
+
+import lombok.EqualsAndHashCode;
+
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import org.assertj.core.api.AbstractObjectAssert;
+import org.assertj.core.api.Assertions;
+
+/**
+ * @author Oliver Gierke
+ */
+@EqualsAndHashCode(callSuper = true)
+public class OptionalAssert<T> extends org.assertj.core.api.OptionalAssert<T> {
+
+	public OptionalAssert(Optional<T> actual) {
+		super(actual);
+	}
+
+	public static <T> OptionalAssert<T> assertOptional(Optional<T> optional) {
+		return new OptionalAssert<T>(optional);
+	}
+
+	public Optional<T> getActual() {
+		return actual;
+	}
+
+	public <S> OptionalAssert<S> flatMap(Function<T, Optional<S>> function) {
+
+		Assertions.assertThat(actual).isPresent();
+
+		return assertOptional(actual.flatMap(function));
+	}
+
+	public <S> OptionalAssert<S> map(Function<T, S> function) {
+
+		Assertions.assertThat(actual).isPresent();
+
+		return assertOptional(actual.map(function));
+	}
+
+	public <S> AbstractObjectAssert<?, S> value(Function<T, S> function) {
+
+		Assertions.assertThat(actual).isPresent();
+
+		return Assertions.assertThat(actual.map(function).orElseThrow(() -> new IllegalStateException()));
+	}
+
+	public OptionalAssert<T> isEqualTo(OptionalAssert<?> other) {
+
+		Assertions.assertThat(actual).isEqualTo(other.actual);
+
+		return this;
+	}
+
+	public OptionalAssert<T> andAssert(Consumer<OptionalAssert<T>> consumer) {
+
+		consumer.accept(this);
+
+		return this;
+	}
+}

src/test/java/org/springframework/data/util/ParameterizedTypeUnitTests.java

@@ -18,6 +18,7 @@ package org.springframework.data.util;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 import static org.springframework.data.util.ClassTypeInformation.*;
+import static org.springframework.data.util.OptionalAssert.*;
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
@@ -27,6 +28,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Optional;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -55,8 +57,8 @@ public class ParameterizedTypeUnitTests {
 	@Test
 	public void considersTypeInformationsWithDifferingParentsNotEqual() {
 
-		TypeDiscoverer<String> stringParent = new TypeDiscoverer<String>(String.class, EMPTY_MAP);
-		TypeDiscoverer<Object> objectParent = new TypeDiscoverer<Object>(Object.class, EMPTY_MAP);
+		TypeDiscoverer<String> stringParent = new TypeDiscoverer<>(String.class, EMPTY_MAP);
+		TypeDiscoverer<Object> objectParent = new TypeDiscoverer<>(Object.class, EMPTY_MAP);
 
 		ParameterizedTypeInformation<Object> first = new ParameterizedTypeInformation<>(one, stringParent, EMPTY_MAP);
 		ParameterizedTypeInformation<Object> second = new ParameterizedTypeInformation<>(one, objectParent, EMPTY_MAP);
@@ -67,7 +69,7 @@ public class ParameterizedTypeUnitTests {
 	@Test
 	public void considersTypeInformationsWithSameParentsNotEqual() {
 
-		TypeDiscoverer<String> stringParent = new TypeDiscoverer<String>(String.class, EMPTY_MAP);
+		TypeDiscoverer<String> stringParent = new TypeDiscoverer<>(String.class, EMPTY_MAP);
 
 		ParameterizedTypeInformation<Object> first = new ParameterizedTypeInformation<>(one, stringParent, EMPTY_MAP);
 		ParameterizedTypeInformation<Object> second = new ParameterizedTypeInformation<>(one, stringParent, EMPTY_MAP);
@@ -79,19 +81,23 @@ public class ParameterizedTypeUnitTests {
 	public void resolvesMapValueTypeCorrectly() {
 
 		TypeInformation<Foo> type = ClassTypeInformation.from(Foo.class);
-		TypeInformation<?> propertyType = type.getProperty("param");
-		assertThat(propertyType.getProperty("value").getType()).isEqualTo(String.class);
-		assertThat(propertyType.getMapValueType().getType()).isEqualTo(String.class);
+		Optional<TypeInformation<?>> propertyType = type.getProperty("param");
+
+		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);
 
 		propertyType = type.getProperty("param2");
-		assertThat(propertyType.getProperty("value").getType()).isEqualTo(String.class);
-		assertThat(propertyType.getMapValueType().getType()).isEqualTo(Locale.class);
+
+		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);
 	}
 
 	@Test // DATACMNS-446
 	public void createsToStringRepresentation() {
 
-		assertThat(from(Foo.class).getProperty("param").toString())
+		assertOptional(from(Foo.class).getProperty("param")).value(it -> it.toString())
 				.isEqualTo("org.springframework.data.util.ParameterizedTypeUnitTests$Localized<java.lang.String>");
 	}
 
@@ -99,37 +105,47 @@ public class ParameterizedTypeUnitTests {
 	@SuppressWarnings("rawtypes")
 	public void hashCodeShouldBeConsistentWithEqualsForResolvedTypes() {
 
-		TypeInformation first = from(First.class).getProperty("property");
-		TypeInformation second = from(Second.class).getProperty("property");
+		Optional<TypeInformation<?>> first = from(First.class).getProperty("property");
+		Optional<TypeInformation<?>> second = from(Second.class).getProperty("property");
 
 		assertThat(first).isEqualTo(second);
-		assertThat(first.hashCode()).isEqualTo(second.hashCode());
+
+		assertThat(first).hasValueSatisfying(left -> {
+			assertThat(second).hasValueSatisfying(right -> {
+				assertThat(left.hashCode()).isEqualTo(right.hashCode());
+			});
+		});
 	}
 
 	@Test // DATACMNS-485
 	@SuppressWarnings("rawtypes")
 	public void getActualTypeShouldNotUnwrapParameterizedTypes() {
 
-		TypeInformation type = from(First.class).getProperty("property");
-		assertThat(type.getActualType()).isEqualTo(type);
+		Optional<TypeInformation<?>> type = from(First.class).getProperty("property");
+
+		assertOptional(type).map(it -> it.getActualType()).isEqualTo(type);
 	}
 
 	@Test // DATACMNS-697
 	public void usesLocalGenericInformationOfFields() {
 
 		TypeInformation<NormalizedProfile> information = ClassTypeInformation.from(NormalizedProfile.class);
-		TypeInformation<?> valueType = information.getProperty("education2.data").getComponentType();
-		assertThat(valueType.getProperty("value").getType()).isEqualTo(Education.class);
+
+		assertOptional(information.getProperty("education2.data"))//
+				.flatMap(it -> it.getComponentType())//
+				.flatMap(it -> it.getProperty("value"))//
+				.value(it -> it.getType())//
+				.isEqualTo(Education.class);
 	}
 
 	@Test // DATACMNS-899
-	public void returnsNullMapValueTypeForNonMapProperties() {
+	public void returnsEmptyOptionalMapValueTypeForNonMapProperties() {
 
-		TypeInformation<?> valueType = ClassTypeInformation.from(Bar.class).getProperty("param");
-		TypeInformation<?> mapValueType = valueType.getMapValueType();
+		OptionalAssert<TypeInformation<?>> assertion = assertOptional(
+				ClassTypeInformation.from(Bar.class).getProperty("param"));
 
-		assertThat(valueType).isInstanceOf(ParameterizedTypeInformation.class);
-		assertThat(mapValueType).isNull();
+		assertion.hasValueSatisfying(it -> assertThat(it).isInstanceOf(ParameterizedTypeInformation.class));
+		assertion.flatMap(it -> it.getMapValueType()).isEmpty();
 	}
 
 	@SuppressWarnings("serial")

src/test/java/org/springframework/data/util/TypeDiscovererUnitTests.java

@@ -26,6 +26,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Optional;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -47,14 +48,14 @@ public class TypeDiscovererUnitTests {
 
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsNullType() {
-		new TypeDiscoverer<Object>(null, null);
+		new TypeDiscoverer<>(null, null);
 	}
 
 	@Test
 	public void isNotEqualIfTypesDiffer() {
 
-		TypeDiscoverer<Object> objectTypeInfo = new TypeDiscoverer<Object>(Object.class, EMPTY_MAP);
-		TypeDiscoverer<String> stringTypeInfo = new TypeDiscoverer<String>(String.class, EMPTY_MAP);
+		TypeDiscoverer<Object> objectTypeInfo = new TypeDiscoverer<>(Object.class, EMPTY_MAP);
+		TypeDiscoverer<String> stringTypeInfo = new TypeDiscoverer<>(String.class, EMPTY_MAP);
 
 		assertThat(objectTypeInfo.equals(stringTypeInfo)).isFalse();
 	}
@@ -64,8 +65,8 @@ public class TypeDiscovererUnitTests {
 
 		assertThat(firstMap.equals(secondMap)).isFalse();
 
-		TypeDiscoverer<Object> first = new TypeDiscoverer<Object>(Object.class, firstMap);
-		TypeDiscoverer<Object> second = new TypeDiscoverer<Object>(Object.class, secondMap);
+		TypeDiscoverer<Object> first = new TypeDiscoverer<>(Object.class, firstMap);
+		TypeDiscoverer<Object> second = new TypeDiscoverer<>(Object.class, secondMap);
 
 		assertThat(first.equals(second)).isFalse();
 	}
@@ -74,8 +75,9 @@ public class TypeDiscovererUnitTests {
 	public void dealsWithTypesReferencingThemselves() {
 
 		TypeInformation<SelfReferencing> information = from(SelfReferencing.class);
-		TypeInformation<?> first = information.getProperty("parent").getMapValueType();
-		TypeInformation<?> second = first.getProperty("map").getMapValueType();
+		Optional<TypeInformation<?>> first = information.getProperty("parent").flatMap(it -> it.getMapValueType());
+		Optional<TypeInformation<?>> second = first.flatMap(it -> it.getProperty("map"))
+				.flatMap(it -> it.getMapValueType());
 
 		assertThat(second).isEqualTo(first);
 	}
@@ -84,27 +86,35 @@ public class TypeDiscovererUnitTests {
 	public void dealsWithTypesReferencingThemselvesInAMap() {
 
 		TypeInformation<SelfReferencingMap> information = from(SelfReferencingMap.class);
-		TypeInformation<?> mapValueType = information.getProperty("map").getMapValueType();
+		Optional<TypeInformation<?>> property = information.getProperty("map");
 
-		assertThat(information).isEqualTo(mapValueType);
+		assertThat(property).hasValueSatisfying(it -> {
+			assertThat(it.getMapValueType()).hasValue(information);
+		});
 	}
 
 	@Test
 	public void returnsComponentAndValueTypesForMapExtensions() {
 
-		TypeInformation<?> discoverer = new TypeDiscoverer<Object>(CustomMap.class, EMPTY_MAP);
+		TypeInformation<?> discoverer = new TypeDiscoverer<>(CustomMap.class, EMPTY_MAP);
 
-		assertThat(discoverer.getMapValueType().getType()).isEqualTo(Locale.class);
-		assertThat(discoverer.getComponentType().getType()).isEqualTo(String.class);
+		assertThat(discoverer.getMapValueType()).hasValueSatisfying(it -> {
+			assertThat(it.getType()).isEqualTo(Locale.class);
+		});
+
+		assertThat(discoverer.getComponentType()).hasValueSatisfying(it -> {
+			assertThat(it.getType()).isEqualTo(String.class);
+		});
 	}
 
 	@Test
 	public void returnsComponentTypeForCollectionExtension() {
 
-		TypeDiscoverer<CustomCollection> discoverer = new TypeDiscoverer<CustomCollection>(CustomCollection.class,
-				firstMap);
+		TypeDiscoverer<CustomCollection> discoverer = new TypeDiscoverer<>(CustomCollection.class, firstMap);
 
-		assertThat(discoverer.getComponentType().getType()).isEqualTo(String.class);
+		assertThat(discoverer.getComponentType()).hasValueSatisfying(it -> {
+			assertThat(it.getType()).isEqualTo(String.class);
+		});
 	}
 
 	@Test
@@ -112,49 +122,56 @@ public class TypeDiscovererUnitTests {
 
 		TypeDiscoverer<String[]> discoverer = new TypeDiscoverer<String[]>(String[].class, EMPTY_MAP);
 
-		assertThat(discoverer.getComponentType().getType()).isEqualTo(String.class);
+		assertThat(discoverer.getComponentType()).hasValueSatisfying(it -> {
+			assertThat(it.getType()).isEqualTo(String.class);
+		});
 	}
 
 	@Test // DATACMNS-57
 	@SuppressWarnings("rawtypes")
 	public void discoveresConstructorParameterTypesCorrectly() throws NoSuchMethodException, SecurityException {
 
-		TypeDiscoverer<GenericConstructors> discoverer = new TypeDiscoverer<GenericConstructors>(GenericConstructors.class,
-				firstMap);
+		TypeDiscoverer<GenericConstructors> discoverer = new TypeDiscoverer<>(GenericConstructors.class, firstMap);
 		Constructor<GenericConstructors> constructor = GenericConstructors.class.getConstructor(List.class, Locale.class);
 		List<TypeInformation<?>> types = discoverer.getParameterTypes(constructor);
 
 		assertThat(types).hasSize(2);
 		assertThat(types.get(0).getType()).isEqualTo(List.class);
-		assertThat(types.get(0).getComponentType().getType()).isEqualTo(String.class);
+		assertThat(types.get(0).getComponentType()).hasValueSatisfying(it -> {
+			assertThat(it.getType()).isEqualTo(String.class);
+		});
 	}
 
 	@Test
 	@SuppressWarnings("rawtypes")
 	public void returnsNullForComponentAndValueTypesForRawMaps() {
 
-		TypeDiscoverer<Map> discoverer = new TypeDiscoverer<Map>(Map.class, EMPTY_MAP);
+		TypeDiscoverer<Map> discoverer = new TypeDiscoverer<>(Map.class, EMPTY_MAP);
 
-		assertThat(discoverer.getComponentType()).isNull();
-		assertThat(discoverer.getMapValueType()).isNull();
+		assertThat(discoverer.getComponentType()).isEmpty();
+		assertThat(discoverer.getMapValueType()).isEmpty();
 	}
 
 	@Test // DATACMNS-167
 	@SuppressWarnings("rawtypes")
 	public void doesNotConsiderTypeImplementingIterableACollection() {
 
-		TypeDiscoverer<Person> discoverer = new TypeDiscoverer<Person>(Person.class, EMPTY_MAP);
+		TypeDiscoverer<Person> discoverer = new TypeDiscoverer<>(Person.class, EMPTY_MAP);
 		TypeInformation reference = from(Address.class);
 
-		TypeInformation<?> addresses = discoverer.getProperty("addresses");
+		Optional<TypeInformation<?>> addresses = discoverer.getProperty("addresses");
 
-		assertThat(addresses.isCollectionLike()).isFalse();
-		assertThat(addresses.getComponentType()).isEqualTo(reference);
+		assertThat(addresses).hasValueSatisfying(it -> {
+			assertThat(it.isCollectionLike()).isFalse();
+			assertThat(it.getComponentType()).hasValue(reference);
+		});
 
-		TypeInformation<?> adressIterable = discoverer.getProperty("addressIterable");
+		Optional<TypeInformation<?>> adressIterable = discoverer.getProperty("addressIterable");
 
-		assertThat(adressIterable.isCollectionLike()).isTrue();
-		assertThat(adressIterable.getComponentType()).isEqualTo(reference);
+		assertThat(adressIterable).hasValueSatisfying(it -> {
+			assertThat(it.isCollectionLike()).isTrue();
+			assertThat(it.getComponentType()).hasValue(reference);
+		});
 	}
 
 	class Person {

src/test/java/org/springframework/data/util/TypeInformationAssert.java

@@ -0,0 +1,41 @@
+package org.springframework.data.util;
+
+import java.util.Optional;
+
+import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.AbstractObjectAssert;
+import org.assertj.core.api.Assertions;
+
+public class TypeInformationAssert extends AbstractAssert<TypeInformationAssert, TypeInformation<?>> {
+
+	/**
+	 * @param actual
+	 * @param selfType
+	 */
+	public TypeInformationAssert(TypeInformation<?> actual) {
+		super(actual, TypeInformationAssert.class);
+	}
+
+	public static TypeInformationAssert assertThat(TypeInformation<?> information) {
+		return new TypeInformationAssert(information);
+	}
+
+	public TypeInformationAssert hasComponentType(Class<?> type) {
+
+		Assertions.assertThat(actual.getComponentType()).hasValueSatisfying(it -> {
+			Assertions.assertThat(it.getType()).isEqualTo(type);
+		});
+
+		return this;
+	}
+
+	public AbstractObjectAssert<?, TypeInformation<?>> hasProperty(String property) {
+
+		Optional<TypeInformation<?>> property2 = actual.getProperty(property);
+
+		return Assertions.assertThat(property2.orElseGet(() -> {
+			failWithMessage("Property %s not found!", property);
+			return null;
+		}));
+	}
+}

src/test/java/org/springframework/data/web/HateoasPageableHandlerMethodArgumentResolverUnitTests.java

@@ -52,7 +52,7 @@ public class HateoasPageableHandlerMethodArgumentResolverUnitTests
 		MethodParameter parameter = new MethodParameter(Sample.class.getMethod("supportedMethod", Pageable.class), 0);
 		UriComponentsContributor resolver = new HateoasPageableHandlerMethodArgumentResolver();
 		UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl("http://localhost:8080?page=0&size=10");
-		resolver.enhance(builder, parameter, new PageRequest(1, 20));
+		resolver.enhance(builder, parameter, PageRequest.of(1, 20));
 
 		MultiValueMap<String, String> params = builder.build().getQueryParams();
 
@@ -67,7 +67,7 @@ public class HateoasPageableHandlerMethodArgumentResolverUnitTests
 
 	@Test // DATACMNS-335
 	public void preventsPageSizeFromExceedingMayValueIfConfiguredOnWrite() throws Exception {
-		assertUriStringFor(new PageRequest(0, 200), "page=0&size=100");
+		assertUriStringFor(PageRequest.of(0, 200), "page=0&size=100");
 	}
 
 	@Test // DATACMNS-418
@@ -101,7 +101,7 @@ public class HateoasPageableHandlerMethodArgumentResolverUnitTests
 
 		UriComponentsBuilder builder = UriComponentsBuilder.fromPath("/");
 
-		resolver.enhance(builder, null, new PageRequest(0, 10));
+		resolver.enhance(builder, null, PageRequest.of(0, 10));
 
 		MultiValueMap<String, String> params = builder.build().getQueryParams();
 

src/test/java/org/springframework/data/web/JsonProjectingMethodInterceptorFactoryUnitTests.java

@@ -15,7 +15,6 @@
  */
 package org.springframework.data.web;
 
-import static org.hamcrest.Matchers.*;
 import static org.assertj.core.api.Assertions.*;
 
 import lombok.AllArgsConstructor;

src/test/java/org/springframework/data/web/MapDataBinderUnitTests.java

@@ -64,7 +64,7 @@ public class MapDataBinderUnitTests {
 
 		Map<String, Object> result = bind(values);
 
-		List<String> list = new ArrayList<String>();
+		List<String> list = new ArrayList<>();
 		list.add("String");
 
 		assertThat(result).isEqualTo((Map) singletonMap("foo", singletonMap("bar", singletonMap("fooBar", list))));

src/test/java/org/springframework/data/web/PageableDefaultUnitTests.java

@@ -48,10 +48,10 @@ public abstract class PageableDefaultUnitTests {
 	static final int PAGE_SIZE = 47;
 	static final int PAGE_NUMBER = 23;
 
-	static final AbstractPageRequest REFERENCE_WITHOUT_SORT = new PageRequest(PAGE_NUMBER, PAGE_SIZE);
-	static final AbstractPageRequest REFERENCE_WITH_SORT = new PageRequest(PAGE_NUMBER, PAGE_SIZE, SORT);
-	static final AbstractPageRequest REFERENCE_WITH_SORT_FIELDS = new PageRequest(PAGE_NUMBER, PAGE_SIZE, new Sort(
-			SORT_FIELDS));
+	static final AbstractPageRequest REFERENCE_WITHOUT_SORT = PageRequest.of(PAGE_NUMBER, PAGE_SIZE);
+	static final AbstractPageRequest REFERENCE_WITH_SORT = PageRequest.of(PAGE_NUMBER, PAGE_SIZE, SORT);
+	static final AbstractPageRequest REFERENCE_WITH_SORT_FIELDS = PageRequest.of(PAGE_NUMBER, PAGE_SIZE,
+			Sort.by(SORT_FIELDS));
 
 	@Rule public ExpectedException exception = ExpectedException.none();
 
@@ -69,8 +69,8 @@ public abstract class PageableDefaultUnitTests {
 
 	@Test
 	public void returnsDefaultIfNoRequestParametersAndNoDefault() throws Exception {
-		assertSupportedAndResult(getParameterOfMethod("supportedMethod"),
-				(Pageable) ReflectionTestUtils.getField(getResolver(), "fallbackPageable"));
+		assertSupportedAndResult(getParameterOfMethod("supportedMethod"), (Pageable) ReflectionTestUtils
+				.invokeMethod(ReflectionTestUtils.getField(getResolver(), "fallbackPageable"), "get"));
 	}
 
 	@Test

src/test/java/org/springframework/data/web/PageableHandlerMethodArgumentResolverUnitTests.java

@@ -18,6 +18,8 @@ package org.springframework.data.web;
 import static org.assertj.core.api.Assertions.*;
 import static org.springframework.data.web.PageableHandlerMethodArgumentResolver.*;
 
+import java.util.Optional;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Qualifier;
@@ -53,7 +55,7 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa
 		request.addParameter("page", "0");
 		request.addParameter("size", "200");
 
-		assertSupportedAndResult(supportedMethodParameter, new PageRequest(0, 100), request);
+		assertSupportedAndResult(supportedMethodParameter, PageRequest.of(0, 100), request);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
@@ -85,7 +87,7 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa
 		request.addParameter("foo_page", "2");
 		request.addParameter("foo_size", "10");
 
-		assertSupportedAndResult(parameter, new PageRequest(2, 10), request);
+		assertSupportedAndResult(parameter, PageRequest.of(2, 10), request);
 	}
 
 	@Test // DATACMNS-377
@@ -141,7 +143,7 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa
 	public void returnsNullIfFallbackIsNullAndNoParametersGiven() throws Exception {
 
 		PageableHandlerMethodArgumentResolver resolver = getResolver();
-		resolver.setFallbackPageable(null);
+		resolver.setFallbackPageable(Optional.empty());
 
 		assertSupportedAndResult(supportedMethodParameter, null, new ServletWebRequest(new MockHttpServletRequest()),
 				resolver);
@@ -151,7 +153,7 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa
 	public void returnsNullIfFallbackIsNullAndOnlyPageIsGiven() throws Exception {
 
 		PageableHandlerMethodArgumentResolver resolver = getResolver();
-		resolver.setFallbackPageable(null);
+		resolver.setFallbackPageable(Optional.empty());
 
 		MockHttpServletRequest request = new MockHttpServletRequest();
 		request.addParameter("page", "20");
@@ -163,7 +165,7 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa
 	public void returnsNullIfFallbackIsNullAndOnlySizeIsGiven() throws Exception {
 
 		PageableHandlerMethodArgumentResolver resolver = getResolver();
-		resolver.setFallbackPageable(null);
+		resolver.setFallbackPageable(Optional.empty());
 
 		MockHttpServletRequest request = new MockHttpServletRequest();
 		request.addParameter("size", "10");
@@ -189,7 +191,7 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa
 	public void usesNullSortIfNoDefaultIsConfiguredAndPageAndSizeAreGiven() {
 
 		PageableHandlerMethodArgumentResolver resolver = getResolver();
-		resolver.setFallbackPageable(null);
+		resolver.setFallbackPageable(Optional.empty());
 
 		MockHttpServletRequest request = new MockHttpServletRequest();
 		request.addParameter("page", "0");
@@ -199,7 +201,7 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa
 
 		assertThat(result.getPageNumber()).isEqualTo(0);
 		assertThat(result.getPageSize()).isEqualTo(10);
-		assertThat(result.getSort()).isNull();
+		assertThat(result.getSort().isSorted()).isFalse();
 	}
 
 	@Test // DATACMNS-692
@@ -236,8 +238,8 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa
 		PageableHandlerMethodArgumentResolver resolver = getResolver();
 		resolver.setFallbackPageable(null);
 
-		assertThat(resolver.isFallbackPageable(null), is(false));
-		assertThat(resolver.isFallbackPageable(new PageRequest(0, 10)), is(false));
+		assertThat(resolver.isFallbackPageable(null)).isFalse();
+		assertThat(resolver.isFallbackPageable(PageRequest.of(0, 10))).isTrue();
 	}
 
 	@Override

src/test/java/org/springframework/data/web/PagedResourcesAssemblerUnitTests.java

@@ -49,11 +49,11 @@ import org.springframework.web.util.UriComponentsBuilder;
  */
 public class PagedResourcesAssemblerUnitTests {
 
-	static final Pageable PAGEABLE = new PageRequest(0, 20);
-	static final Page<Person> EMPTY_PAGE = new PageImpl<Person>(Collections.<Person> emptyList(), PAGEABLE, 0);
+	static final Pageable PAGEABLE = PageRequest.of(0, 20);
+	static final Page<Person> EMPTY_PAGE = new PageImpl<>(Collections.emptyList(), PAGEABLE, 0);
 
 	HateoasPageableHandlerMethodArgumentResolver resolver = new HateoasPageableHandlerMethodArgumentResolver();
-	PagedResourcesAssembler<Person> assembler = new PagedResourcesAssembler<Person>(resolver, null);
+	PagedResourcesAssembler<Person> assembler = new PagedResourcesAssembler<>(resolver, null);
 
 	@Before
 	public void setUp() {
@@ -95,7 +95,7 @@ public class PagedResourcesAssemblerUnitTests {
 
 		UriComponents baseUri = UriComponentsBuilder.fromUriString("http://foo:9090").build();
 
-		PagedResourcesAssembler<Person> assembler = new PagedResourcesAssembler<Person>(resolver, baseUri);
+		PagedResourcesAssembler<Person> assembler = new PagedResourcesAssembler<>(resolver, baseUri);
 		PagedResources<Resource<Person>> resources = assembler.toResource(createPage(1));
 
 		assertThat(resources.getLink(Link.REL_PREVIOUS).getHref()).startsWith(baseUri.toUriString());
@@ -120,8 +120,8 @@ public class PagedResourcesAssemblerUnitTests {
 
 		resolver.setOneIndexedParameters(true);
 
-		AbstractPageRequest request = new PageRequest(0, 1);
-		Page<Person> page = new PageImpl<Person>(Collections.<Person> emptyList(), request, 0);
+		AbstractPageRequest request = PageRequest.of(0, 1);
+		Page<Person> page = new PageImpl<>(Collections.emptyList(), request, 0);
 
 		assembler.toResource(page);
 	}
@@ -155,7 +155,7 @@ public class PagedResourcesAssemblerUnitTests {
 		HateoasPageableHandlerMethodArgumentResolver argumentResolver = new HateoasPageableHandlerMethodArgumentResolver();
 		argumentResolver.setOneIndexedParameters(true);
 
-		PagedResourcesAssembler<Person> assembler = new PagedResourcesAssembler<Person>(argumentResolver, null);
+		PagedResourcesAssembler<Person> assembler = new PagedResourcesAssembler<>(argumentResolver, null);
 		PagedResources<Resource<Person>> resource = assembler.toResource(createPage(1));
 
 		assertThat(resource.hasLink("prev")).isTrue();
@@ -228,7 +228,7 @@ public class PagedResourcesAssemblerUnitTests {
 	@Test // DATACMNS-701
 	public void alwaysAddsFirstAndLastLinkIfConfiguredTo() {
 
-		PagedResourcesAssembler<Person> assembler = new PagedResourcesAssembler<Person>(resolver, null);
+		PagedResourcesAssembler<Person> assembler = new PagedResourcesAssembler<>(resolver, null);
 		assembler.setForceFirstAndLastRels(true);
 
 		PagedResources<Resource<Person>> resources = assembler.toResource(EMPTY_PAGE);
@@ -240,7 +240,7 @@ public class PagedResourcesAssemblerUnitTests {
 	@Test // DATACMNS-802
 	public void usesCustomPagedResources() {
 
-		ResourceAssembler<Page<Person>, PagedResources<Resource<Person>>> assembler = new CustomPagedResourcesAssembler<Person>(
+		ResourceAssembler<Page<Person>, PagedResources<Resource<Person>>> assembler = new CustomPagedResourcesAssembler<>(
 				resolver, null);
 
 		assertThat(assembler.toResource(EMPTY_PAGE)).isInstanceOf(CustomPagedResources.class);
@@ -248,12 +248,12 @@ public class PagedResourcesAssemblerUnitTests {
 
 	private static Page<Person> createPage(int index) {
 
-		AbstractPageRequest request = new PageRequest(index, 1);
+		Pageable request = PageRequest.of(index, 1);
 
 		Person person = new Person();
 		person.name = "Dave";
 
-		return new PageImpl<Person>(Arrays.asList(person), request, 3);
+		return new PageImpl<>(Arrays.asList(person), request, 3);
 	}
 
 	private static Map<String, String> getQueryParameters(Link link) {
@@ -293,7 +293,7 @@ public class PagedResourcesAssemblerUnitTests {
 		@Override
 		protected <R extends ResourceSupport, S> PagedResources<R> createPagedResource(List<R> resources,
 				PageMetadata metadata, Page<S> page) {
-			return new CustomPagedResources<R>(resources, metadata);
+			return new CustomPagedResources<>(resources, metadata);
 		}
 	}
 

src/test/java/org/springframework/data/web/ProjectingJackson2HttpMessageConverterUnitTests.java

@@ -15,7 +15,6 @@
  */
 package org.springframework.data.web;
 
-import static org.hamcrest.CoreMatchers.*;
 import static org.assertj.core.api.Assertions.*;
 
 import java.lang.reflect.Method;

src/test/java/org/springframework/data/web/SortDefaultUnitTests.java

@@ -46,17 +46,16 @@ public abstract class SortDefaultUnitTests {
 
 	static final Sort SORT = new Sort(SORT_DIRECTION, SORT_FIELDS);
 
-	@Rule
-	public ExpectedException exception = ExpectedException.none();
+	@Rule public ExpectedException exception = ExpectedException.none();
 
 	@Test
 	public void parsesSimpleSortStringCorrectly() {
 
-		assertSortStringParsedInto(new Sort(new Order("username")), SORT_1);
-		assertSortStringParsedInto(new Sort(new Order(ASC, "username")), SORT_1);
-		assertSortStringParsedInto(new Sort(new Order(ASC, "username"), //
+		assertSortStringParsedInto(Sort.by(new Order("username")), SORT_1);
+		assertSortStringParsedInto(Sort.by(new Order(ASC, "username")), SORT_1);
+		assertSortStringParsedInto(Sort.by(new Order(ASC, "username"), //
 				new Order(DESC, "lastname"), new Order(DESC, "firstname")), SORT_2);
-		assertSortStringParsedInto(new Sort("firstname", "lastname"), SORT_3);
+		assertSortStringParsedInto(Sort.by("firstname", "lastname"), SORT_3);
 	}
 
 	private static void assertSortStringParsedInto(Sort expected, String... source) {
@@ -74,12 +73,12 @@ public abstract class SortDefaultUnitTests {
 
 	@Test
 	public void returnsNullForNoDefault() throws Exception {
-		assertSupportedAndResolvedTo(getParameterOfMethod("supportedMethod"), null);
+		assertSupportedAndResolvedTo(getParameterOfMethod("supportedMethod"), Sort.unsorted());
 	}
 
 	@Test
 	public void discoversSimpleDefault() throws Exception {
-		assertSupportedAndResolvedTo(getParameterOfMethod("simpleDefault"), new Sort(Direction.ASC, SORT_FIELDS));
+		assertSupportedAndResolvedTo(getParameterOfMethod("simpleDefault"), Sort.by(SORT_FIELDS).ascending());
 	}
 
 	@Test
@@ -114,7 +113,7 @@ public abstract class SortDefaultUnitTests {
 	public void discoversContaineredDefault() throws Exception {
 
 		MethodParameter parameter = getParameterOfMethod("containeredDefault");
-		Sort reference = new Sort("foo", "bar");
+		Sort reference = Sort.by("foo", "bar");
 
 		assertSupportedAndResolvedTo(parameter, reference);
 	}

src/test/java/org/springframework/data/web/SortHandlerMethodArgumentResolverUnitTests.java

@@ -69,14 +69,14 @@ public class SortHandlerMethodArgumentResolverUnitTests extends SortDefaultUnitT
 		SortHandlerMethodArgumentResolver resolver = new SortHandlerMethodArgumentResolver();
 
 		Sort sort = resolver.resolveArgument(parameter, null, new ServletWebRequest(new MockHttpServletRequest()), null);
-		assertThat(sort).isNull();
+		assertThat(sort.isSorted()).isFalse();
 	}
 
 	@Test
 	public void discoversSimpleSortFromRequest() {
 
 		MethodParameter parameter = getParameterOfMethod("simpleDefault");
-		Sort reference = new Sort("bar", "foo");
+		Sort reference = Sort.by("bar", "foo");
 		NativeWebRequest request = getRequestWithSort(reference);
 
 		assertSupportedAndResolvedTo(request, parameter, reference);
@@ -86,7 +86,7 @@ public class SortHandlerMethodArgumentResolverUnitTests extends SortDefaultUnitT
 	public void discoversComplexSortFromRequest() {
 
 		MethodParameter parameter = getParameterOfMethod("simpleDefault");
-		Sort reference = new Sort("bar", "foo").and(new Sort("fizz", "buzz"));
+		Sort reference = Sort.by("bar", "foo").and(Sort.by("fizz", "buzz"));
 
 		assertSupportedAndResolvedTo(getRequestWithSort(reference), parameter, reference);
 	}
@@ -95,7 +95,7 @@ public class SortHandlerMethodArgumentResolverUnitTests extends SortDefaultUnitT
 	public void discoversQualifiedSortFromRequest() {
 
 		MethodParameter parameter = getParameterOfMethod("qualifiedSort");
-		Sort reference = new Sort("bar", "foo");
+		Sort reference = Sort.by("bar", "foo");
 
 		assertSupportedAndResolvedTo(getRequestWithSort(reference, "qual"), parameter, reference);
 	}
@@ -110,7 +110,7 @@ public class SortHandlerMethodArgumentResolverUnitTests extends SortDefaultUnitT
 
 		SortHandlerMethodArgumentResolver resolver = new SortHandlerMethodArgumentResolver();
 		Sort result = resolver.resolveArgument(parameter, null, new ServletWebRequest(request), null);
-		assertThat(result).isNull();
+		assertThat(result.isSorted()).isFalse();
 	}
 
 	@Test // DATACMNS-366
@@ -132,7 +132,7 @@ public class SortHandlerMethodArgumentResolverUnitTests extends SortDefaultUnitT
 		MockHttpServletRequest request = new MockHttpServletRequest();
 		request.addParameter("sort", "");
 
-		assertThat(resolveSort(request, PARAMETER)).isNull();
+		assertThat(resolveSort(request, PARAMETER).isSorted()).isFalse();
 	}
 
 	@Test // DATACMNS-408
@@ -141,7 +141,7 @@ public class SortHandlerMethodArgumentResolverUnitTests extends SortDefaultUnitT
 		MockHttpServletRequest request = new MockHttpServletRequest();
 		request.addParameter("sort", ",DESC");
 
-		assertThat(resolveSort(request, PARAMETER)).isNull();
+		assertThat(resolveSort(request, PARAMETER).isSorted()).isFalse();
 	}
 
 	@Test // DATACMNS-408
@@ -169,7 +169,7 @@ public class SortHandlerMethodArgumentResolverUnitTests extends SortDefaultUnitT
 		MockHttpServletRequest request = new MockHttpServletRequest();
 		request.addParameter("sort", ",");
 
-		assertThat(resolveSort(request, PARAMETER)).isNull();
+		assertThat(resolveSort(request, PARAMETER).isSorted()).isFalse();
 	}
 
 	@Test // DATACMNS-753, DATACMNS-408
@@ -178,8 +178,8 @@ public class SortHandlerMethodArgumentResolverUnitTests extends SortDefaultUnitT
 		MockHttpServletRequest request = new MockHttpServletRequest();
 		request.addParameter("sort", "");
 
-		assertThat(resolveSort(request, getParameterOfMethod("simpleDefault"))).isEqualTo(new Sort("firstname", "lastname"));
-		assertThat(resolveSort(request, getParameterOfMethod("containeredDefault"))).isEqualTo(new Sort("foo", "bar"));
+		assertThat(resolveSort(request, getParameterOfMethod("simpleDefault"))).isEqualTo(Sort.by("firstname", "lastname"));
+		assertThat(resolveSort(request, getParameterOfMethod("containeredDefault"))).isEqualTo(Sort.by("foo", "bar"));
 	}
 
 	private static Sort resolveSort(HttpServletRequest request, MethodParameter parameter) throws Exception {

src/test/java/org/springframework/data/web/XmlBeamHttpMessageConverterUnitTests.java

@@ -15,7 +15,6 @@
  */
 package org.springframework.data.web;
 
-import static org.hamcrest.CoreMatchers.*;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 

src/test/java/org/springframework/data/web/config/PageableResourcesAssemblerIntegrationTests.java

@@ -68,7 +68,7 @@ public class PageableResourcesAssemblerIntegrationTests {
 
 		assertThat(controller.assembler).isNotNull();
 
-		PagedResources<Resource<Person>> resources = controller.sample(new PageRequest(1, 1));
+		PagedResources<Resource<Person>> resources = controller.sample(PageRequest.of(1, 1));
 
 		assertThat(resources.getLink(Link.REL_PREVIOUS)).isNotNull();
 		assertThat(resources.getLink(Link.REL_NEXT)).isNotNull();
@@ -99,7 +99,7 @@ public class PageableResourcesAssemblerIntegrationTests {
 		@RequestMapping("/persons")
 		PagedResources<Resource<Person>> sample(Pageable pageable) {
 
-			Page<Person> page = new PageImpl<Person>(Arrays.asList(new Person()), pageable,
+			Page<Person> page = new PageImpl<>(Arrays.asList(new Person()), pageable,
 					pageable.getOffset() + pageable.getPageSize() + 1);
 
 			return assembler.toResource(page);