diff --git a/src/test/java/org/springframework/data/repository/config/RepositoryConfigurationExtensionSupportUnitTests.java b/src/test/java/org/springframework/data/repository/config/RepositoryConfigurationExtensionSupportUnitTests.java index 392e46cdf..bbb41d966 100755 --- a/src/test/java/org/springframework/data/repository/config/RepositoryConfigurationExtensionSupportUnitTests.java +++ b/src/test/java/org/springframework/data/repository/config/RepositoryConfigurationExtensionSupportUnitTests.java @@ -41,21 +41,21 @@ public class RepositoryConfigurationExtensionSupportUnitTests { public void doesNotConsiderRepositoryForPlainTypeStrictMatch() { RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(PlainTypeRepository.class); - assertThat(extension.isStrictRepositoryCandidate(metadata), is(false)); + assertThat(extension.isStrictRepositoryCandidate(metadata)).isFalse(); } @Test // DATACMNS-526 public void considersRepositoryWithAnnotatedTypeStrictMatch() { RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(AnnotatedTypeRepository.class); - assertThat(extension.isStrictRepositoryCandidate(metadata), is(true)); + assertThat(extension.isStrictRepositoryCandidate(metadata)).isTrue(); } @Test // DATACMNS-526 public void considersRepositoryInterfaceExtendingStoreInterfaceStrictMatch() { RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(ExtendingInterface.class); - assertThat(extension.isStrictRepositoryCandidate(metadata), is(true)); + assertThat(extension.isStrictRepositoryCandidate(metadata)).isTrue(); } static class SampleRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport { diff --git a/src/test/java/org/springframework/data/repository/core/support/QueryExecutionResultHandlerUnitTests.java b/src/test/java/org/springframework/data/repository/core/support/QueryExecutionResultHandlerUnitTests.java index 555af9551..cfca5ccee 100755 --- a/src/test/java/org/springframework/data/repository/core/support/QueryExecutionResultHandlerUnitTests.java +++ b/src/test/java/org/springframework/data/repository/core/support/QueryExecutionResultHandlerUnitTests.java @@ -108,10 +108,10 @@ public class QueryExecutionResultHandlerUnitTests { Single entity = Single.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("publisher")); - assertThat(result, is(instanceOf(Publisher.class))); + assertThat(result).isInstanceOf(Publisher.class); Mono mono = Mono.from((Publisher) result); - assertThat(mono.block(), is(entity.toBlocking().value())); + assertThat(mono.block()).isEqualTo(entity.toBlocking().value()); } @Test // DATACMNS-836 @@ -121,10 +121,10 @@ public class QueryExecutionResultHandlerUnitTests { Single entity = Single.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("mono")); - assertThat(result, is(instanceOf(Mono.class))); + assertThat(result).isInstanceOf(Mono.class); Mono mono = (Mono) result; - assertThat(mono.block(), is(entity.toBlocking().value())); + assertThat(mono.block()).isEqualTo(entity.toBlocking().value()); } @Test // DATACMNS-836 @@ -134,10 +134,10 @@ public class QueryExecutionResultHandlerUnitTests { Single entity = Single.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("flux")); - assertThat(result, is(instanceOf(Flux.class))); + assertThat(result).isInstanceOf(Flux.class); Flux flux = (Flux) result; - assertThat(flux.next().block(), is(entity.toBlocking().value())); + assertThat(flux.next().block()).isEqualTo(entity.toBlocking().value()); } @Test // DATACMNS-836 @@ -147,10 +147,10 @@ public class QueryExecutionResultHandlerUnitTests { Observable entity = Observable.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("publisher")); - assertThat(result, is(instanceOf(Publisher.class))); + assertThat(result).isInstanceOf(Publisher.class); Mono mono = Mono.from((Publisher) result); - assertThat(mono.block(), is(entity.toBlocking().first())); + assertThat(mono.block()).isEqualTo(entity.toBlocking().first()); } @Test // DATACMNS-836 @@ -160,10 +160,10 @@ public class QueryExecutionResultHandlerUnitTests { Observable entity = Observable.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("mono")); - assertThat(result, is(instanceOf(Mono.class))); + assertThat(result).isInstanceOf(Mono.class); Mono mono = (Mono) result; - assertThat(mono.block(), is(entity.toBlocking().first())); + assertThat(mono.block()).isEqualTo(entity.toBlocking().first()); } @Test // DATACMNS-836 @@ -173,10 +173,10 @@ public class QueryExecutionResultHandlerUnitTests { Observable entity = Observable.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("flux")); - assertThat(result, is(instanceOf(Flux.class))); + assertThat(result).isInstanceOf(Flux.class); Flux flux = (Flux) result; - assertThat(flux.next().block(), is(entity.toBlocking().first())); + assertThat(flux.next().block()).isEqualTo(entity.toBlocking().first()); } @Test // DATACMNS-836 @@ -186,10 +186,10 @@ public class QueryExecutionResultHandlerUnitTests { Observable entity = Observable.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("single")); - assertThat(result, is(instanceOf(Single.class))); + assertThat(result).isInstanceOf(Single.class); Single single = (Single) result; - assertThat(single.toBlocking().value(), is(entity.toBlocking().first())); + assertThat(single.toBlocking().value()).isEqualTo(entity.toBlocking().first()); } @Test // DATACMNS-836 @@ -199,10 +199,10 @@ public class QueryExecutionResultHandlerUnitTests { Single entity = Single.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("observable")); - assertThat(result, is(instanceOf(Observable.class))); + assertThat(result).isInstanceOf(Observable.class); Observable observable = (Observable) result; - assertThat(observable.toBlocking().first(), is(entity.toBlocking().value())); + assertThat(observable.toBlocking().first()).isEqualTo(entity.toBlocking().value()); } @Test // DATACMNS-836 @@ -212,10 +212,10 @@ public class QueryExecutionResultHandlerUnitTests { Mono entity = Mono.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("single")); - assertThat(result, is(instanceOf(Single.class))); + assertThat(result).isInstanceOf(Single.class); Single single = (Single) result; - assertThat(single.toBlocking().value(), is(entity.block())); + assertThat(single.toBlocking().value()).isEqualTo(entity.block()); } @Test // DATACMNS-836 @@ -225,10 +225,10 @@ public class QueryExecutionResultHandlerUnitTests { Mono entity = Mono.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("completable")); - assertThat(result, is(instanceOf(Completable.class))); + assertThat(result).isInstanceOf(Completable.class); Completable completable = (Completable) result; - assertThat(completable.get(), is(nullValue())); + assertThat(completable.get()).isNull(); } @Test // DATACMNS-836 @@ -238,10 +238,10 @@ public class QueryExecutionResultHandlerUnitTests { Mono entity = Mono.error(new InvalidDataAccessApiUsageException("err")); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("completable")); - assertThat(result, is(instanceOf(Completable.class))); + assertThat(result).isInstanceOf(Completable.class); Completable completable = (Completable) result; - assertThat(completable.get(), is(instanceOf(InvalidDataAccessApiUsageException.class))); + assertThat(completable.get()).isInstanceOf(InvalidDataAccessApiUsageException.class); } @Test // DATACMNS-836 @@ -251,10 +251,10 @@ public class QueryExecutionResultHandlerUnitTests { Completable entity = Completable.complete(); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("mono")); - assertThat(result, is(instanceOf(Mono.class))); + assertThat(result).isInstanceOf(Mono.class); Mono mono = (Mono) result; - assertThat(mono.block(), is(nullValue())); + assertThat(mono.block()).isNull(); } @Test(expected = InvalidDataAccessApiUsageException.class) // DATACMNS-836 @@ -264,7 +264,7 @@ public class QueryExecutionResultHandlerUnitTests { Completable entity = Completable.error(new InvalidDataAccessApiUsageException("err")); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("mono")); - assertThat(result, is(instanceOf(Mono.class))); + assertThat(result).isInstanceOf(Mono.class); Mono mono = (Mono) result; mono.block(); @@ -278,10 +278,10 @@ public class QueryExecutionResultHandlerUnitTests { Mono entity = Mono.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("observable")); - assertThat(result, is(instanceOf(Observable.class))); + assertThat(result).isInstanceOf(Observable.class); Observable observable = (Observable) result; - assertThat(observable.toBlocking().first(), is(entity.block())); + assertThat(observable.toBlocking().first()).isEqualTo(entity.block()); } @Test // DATACMNS-836 @@ -291,10 +291,10 @@ public class QueryExecutionResultHandlerUnitTests { Flux entity = Flux.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("single")); - assertThat(result, is(instanceOf(Single.class))); + assertThat(result).isInstanceOf(Single.class); Single single = (Single) result; - assertThat(single.toBlocking().value(), is(entity.next().block())); + assertThat(single.toBlocking().value()).isEqualTo(entity.next().block()); } @Test // DATACMNS-836 @@ -304,10 +304,10 @@ public class QueryExecutionResultHandlerUnitTests { Flux entity = Flux.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("observable")); - assertThat(result, is(instanceOf(Observable.class))); + assertThat(result).isInstanceOf(Observable.class); Observable observable = (Observable) result; - assertThat(observable.toBlocking().first(), is(entity.next().block())); + assertThat(observable.toBlocking().first()).isEqualTo(entity.next().block()); } @Test // DATACMNS-836 @@ -317,10 +317,10 @@ public class QueryExecutionResultHandlerUnitTests { Flux entity = Flux.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("mono")); - assertThat(result, is(instanceOf(Mono.class))); + assertThat(result).isInstanceOf(Mono.class); Mono mono = (Mono) result; - assertThat(mono.block(), is(entity.next().block())); + assertThat(mono.block()).isEqualTo(entity.next().block()); } @Test // DATACMNS-836 @@ -330,10 +330,10 @@ public class QueryExecutionResultHandlerUnitTests { Mono entity = Mono.just(new Entity()); Object result = handler.postProcessInvocationResult(entity, getTypeDescriptorFor("flux")); - assertThat(result, is(instanceOf(Flux.class))); + assertThat(result).isInstanceOf(Flux.class); Flux flux = (Flux) result; - assertThat(flux.next().block(), is(entity.block())); + assertThat(flux.next().block()).isEqualTo(entity.block()); } private static TypeDescriptor getTypeDescriptorFor(String methodName) throws Exception { diff --git a/src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java b/src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java index 2d1de712a..9a25c66f5 100755 --- a/src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java +++ b/src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java @@ -17,6 +17,8 @@ package org.springframework.data.repository.query; import static org.assertj.core.api.Assertions.*; +import rx.Single; + import java.lang.reflect.Method; import java.util.Optional; @@ -167,7 +169,7 @@ public class ParametersUnitTests { Parameters parameters = getParametersFor("methodWithPublisher", Publisher.class); - assertThat(parameters.getParameter(0).getType(), is(typeCompatibleWith(Publisher.class))); + assertThat(parameters.getParameter(0).getType()).isAssignableFrom(Publisher.class); } @Test // DATACMNS-836 @@ -175,7 +177,7 @@ public class ParametersUnitTests { Parameters parameters = getParametersFor("methodWithSingle", Single.class); - assertThat(parameters.getParameter(0).getType(), is(typeCompatibleWith(Single.class))); + assertThat(parameters.getParameter(0).getType()).isAssignableFrom(Single.class); } private Parameters getParametersFor(String methodName, Class... parameterTypes) diff --git a/src/test/java/org/springframework/data/repository/query/ResultProcessorUnitTests.java b/src/test/java/org/springframework/data/repository/query/ResultProcessorUnitTests.java index ad80e0ca5..8259b513c 100755 --- a/src/test/java/org/springframework/data/repository/query/ResultProcessorUnitTests.java +++ b/src/test/java/org/springframework/data/repository/query/ResultProcessorUnitTests.java @@ -223,11 +223,11 @@ public class ResultProcessorUnitTests { Object result = getProcessor("findMonoSample").processResult(samples); - assertThat(result, is(instanceOf(Mono.class))); + assertThat(result).isInstanceOf(Mono.class); Object content = ((Mono) result).block(); - assertThat(content, is(instanceOf(Sample.class))); + assertThat(content).isInstanceOf(Sample.class); } @Test // DATACMNS-836 @@ -238,11 +238,11 @@ public class ResultProcessorUnitTests { Object result = getProcessor("findSingleSample").processResult(samples); - assertThat(result, is(instanceOf(Single.class))); + assertThat(result).isInstanceOf(Single.class); Object content = ((Single) result).toBlocking().value(); - assertThat(content, is(instanceOf(Sample.class))); + assertThat(content).isInstanceOf(Sample.class); } @Test // DATACMNS-836 @@ -254,11 +254,11 @@ public class ResultProcessorUnitTests { Object result = processor.processResult(Mono.just(new Sample("Dave", "Matthews")), source -> new SampleDto()); - assertThat(result, is(instanceOf(Mono.class))); + assertThat(result).isInstanceOf(Mono.class); Object content = ((Mono) result).block(); - assertThat(content, is(instanceOf(SampleDto.class))); + assertThat(content).isInstanceOf(SampleDto.class); } @Test // DATACMNS-836 @@ -269,12 +269,12 @@ public class ResultProcessorUnitTests { Object result = getProcessor("findFluxProjection").processResult(samples); - assertThat(result, is(instanceOf(Flux.class))); + assertThat(result).isInstanceOf(Flux.class); List content = ((Flux) result).collectList().block(); - assertThat(content, is(not(empty()))); - assertThat(content.get(0), is(instanceOf(SampleProjection.class))); + assertThat(content).isNotEmpty(); + assertThat(content.get(0)).isInstanceOf(SampleProjection.class); } @Test // DATACMNS-836 @@ -285,12 +285,12 @@ public class ResultProcessorUnitTests { Object result = getProcessor("findObservableProjection").processResult(samples); - assertThat(result, is(instanceOf(Observable.class))); + assertThat(result).isInstanceOf(Observable.class); List content = ((Observable) result).toList().toBlocking().single(); - assertThat(content, is(not(empty()))); - assertThat(content.get(0), is(instanceOf(SampleProjection.class))); + assertThat(content).isNotEmpty(); + assertThat(content.get(0)).isInstanceOf(SampleProjection.class); } private static ResultProcessor getProcessor(String methodName, Class... parameters) throws Exception { diff --git a/src/test/java/org/springframework/data/repository/util/QueryExecutionConvertersUnitTests.java b/src/test/java/org/springframework/data/repository/util/QueryExecutionConvertersUnitTests.java index ae164505c..6c5bf6153 100755 --- a/src/test/java/org/springframework/data/repository/util/QueryExecutionConvertersUnitTests.java +++ b/src/test/java/org/springframework/data/repository/util/QueryExecutionConvertersUnitTests.java @@ -15,9 +15,7 @@ */ package org.springframework.data.repository.util; -import static org.assertj.core.api.Assertions.assertThat; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.assertThat; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.repository.util.QueryExecutionConverters.*; import javaslang.collection.HashMap; @@ -40,7 +38,6 @@ import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Future; -import org.hamcrest.Matchers; import org.junit.Before; import org.junit.Test; import org.reactivestreams.Publisher; @@ -78,49 +75,49 @@ public class QueryExecutionConvertersUnitTests { assertThat(QueryExecutionConverters.supports(Future.class)).isTrue(); assertThat(QueryExecutionConverters.supports(ListenableFuture.class)).isTrue(); assertThat(QueryExecutionConverters.supports(Option.class)).isTrue(); - assertThat(QueryExecutionConverters.supports(javaslang.control.Option.class), is(true)); + assertThat(QueryExecutionConverters.supports(javaslang.control.Option.class)).isTrue(); } @Test // DATACMNS-836 public void registersReactiveWrapperTypes() { - assertThat(QueryExecutionConverters.supports(Publisher.class), is(true)); - assertThat(QueryExecutionConverters.supports(Mono.class), is(true)); - assertThat(QueryExecutionConverters.supports(Flux.class), is(true)); - assertThat(QueryExecutionConverters.supports(Single.class), is(true)); - assertThat(QueryExecutionConverters.supports(Completable.class), is(true)); - assertThat(QueryExecutionConverters.supports(Observable.class), is(true)); - assertThat(QueryExecutionConverters.supports(io.reactivex.Single.class), is(true)); - assertThat(QueryExecutionConverters.supports(io.reactivex.Maybe.class), is(true)); - assertThat(QueryExecutionConverters.supports(io.reactivex.Completable.class), is(true)); - assertThat(QueryExecutionConverters.supports(io.reactivex.Flowable.class), is(true)); - assertThat(QueryExecutionConverters.supports(io.reactivex.Observable.class), is(true)); + assertThat(QueryExecutionConverters.supports(Publisher.class)).isTrue(); + assertThat(QueryExecutionConverters.supports(Mono.class)).isTrue(); + assertThat(QueryExecutionConverters.supports(Flux.class)).isTrue(); + assertThat(QueryExecutionConverters.supports(Single.class)).isTrue(); + assertThat(QueryExecutionConverters.supports(Completable.class)).isTrue(); + assertThat(QueryExecutionConverters.supports(Observable.class)).isTrue(); + assertThat(QueryExecutionConverters.supports(io.reactivex.Single.class)).isTrue(); + assertThat(QueryExecutionConverters.supports(io.reactivex.Maybe.class)).isTrue(); + assertThat(QueryExecutionConverters.supports(io.reactivex.Completable.class)).isTrue(); + assertThat(QueryExecutionConverters.supports(io.reactivex.Flowable.class)).isTrue(); + assertThat(QueryExecutionConverters.supports(io.reactivex.Observable.class)).isTrue(); } @Test // DATACMNS-836 public void registersUnwrapperTypes() { - assertThat(QueryExecutionConverters.supportsUnwrapping(Optional.class), is(true)); - assertThat(QueryExecutionConverters.supportsUnwrapping(java.util.Optional.class), is(true)); - assertThat(QueryExecutionConverters.supportsUnwrapping(Future.class), is(true)); - assertThat(QueryExecutionConverters.supportsUnwrapping(ListenableFuture.class), is(true)); - assertThat(QueryExecutionConverters.supportsUnwrapping(Option.class), is(true)); + assertThat(QueryExecutionConverters.supportsUnwrapping(Optional.class)).isTrue(); + assertThat(QueryExecutionConverters.supportsUnwrapping(java.util.Optional.class)).isTrue(); + assertThat(QueryExecutionConverters.supportsUnwrapping(Future.class)).isTrue(); + assertThat(QueryExecutionConverters.supportsUnwrapping(ListenableFuture.class)).isTrue(); + assertThat(QueryExecutionConverters.supportsUnwrapping(Option.class)).isTrue(); } @Test // DATACMNS-836 public void doesNotRegisterReactiveUnwrapperTypes() { - assertThat(QueryExecutionConverters.supportsUnwrapping(Publisher.class), is(false)); - assertThat(QueryExecutionConverters.supportsUnwrapping(Mono.class), is(false)); - assertThat(QueryExecutionConverters.supportsUnwrapping(Flux.class), is(false)); - assertThat(QueryExecutionConverters.supportsUnwrapping(Single.class), is(false)); - assertThat(QueryExecutionConverters.supportsUnwrapping(Completable.class), is(false)); - assertThat(QueryExecutionConverters.supportsUnwrapping(Observable.class), is(false)); - assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Single.class), is(false)); - assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Maybe.class), is(false)); - assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Completable.class), is(false)); - assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Flowable.class), is(false)); - assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Observable.class), is(false)); + assertThat(QueryExecutionConverters.supportsUnwrapping(Publisher.class)).isFalse(); + assertThat(QueryExecutionConverters.supportsUnwrapping(Mono.class)).isFalse(); + assertThat(QueryExecutionConverters.supportsUnwrapping(Flux.class)).isFalse(); + assertThat(QueryExecutionConverters.supportsUnwrapping(Single.class)).isFalse(); + assertThat(QueryExecutionConverters.supportsUnwrapping(Completable.class)).isFalse(); + assertThat(QueryExecutionConverters.supportsUnwrapping(Observable.class)).isFalse(); + assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Single.class)).isFalse(); + assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Maybe.class)).isFalse(); + assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Completable.class)).isFalse(); + assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Flowable.class)).isFalse(); + assertThat(QueryExecutionConverters.supportsUnwrapping(io.reactivex.Observable.class)).isFalse(); } @Test // DATACMNS-714 @@ -186,9 +183,10 @@ public class QueryExecutionConvertersUnitTests { } @Test // DATACMNS-937 + @SuppressWarnings("unchecked") public void turnsNullIntoJavaslangOption() { - assertThat(conversionService.convert(new NullableWrapper(null), javaslang.control.Option.class), - is((Object) optionNone())); + assertThat(conversionService.convert(new NullableWrapper(null), javaslang.control.Option.class)) + .isEqualTo(optionNone()); } @Test // DATACMNS-937 @@ -197,78 +195,78 @@ public class QueryExecutionConvertersUnitTests { javaslang.control.Option result = conversionService.convert(new NullableWrapper("string"), javaslang.control.Option.class); - assertThat(result.isEmpty(), is(false)); - assertThat(result.get(), is((Object) "string")); + assertThat(result.isEmpty()).isFalse(); + assertThat(result.get()).isEqualTo("string"); } @Test // DATACMNS-937 public void unwrapsEmptyJavaslangOption() { - assertThat(QueryExecutionConverters.unwrap(optionNone()), is(nullValue())); + assertThat(QueryExecutionConverters.unwrap(optionNone())).isNull(); } @Test // DATACMNS-937 public void unwrapsJavaslangOption() { - assertThat(QueryExecutionConverters.unwrap(option("string")), is((Object) "string")); + assertThat(QueryExecutionConverters.unwrap(option("string"))).isEqualTo("string"); } @Test // DATACMNS-940 public void conversListToJavaslang() { - assertThat(conversionService.canConvert(List.class, javaslang.collection.Traversable.class), is(true)); - assertThat(conversionService.canConvert(List.class, javaslang.collection.List.class), is(true)); - assertThat(conversionService.canConvert(List.class, javaslang.collection.Set.class), is(true)); - assertThat(conversionService.canConvert(List.class, javaslang.collection.Map.class), is(false)); + assertThat(conversionService.canConvert(List.class, javaslang.collection.Traversable.class)).isTrue(); + assertThat(conversionService.canConvert(List.class, javaslang.collection.List.class)).isTrue(); + assertThat(conversionService.canConvert(List.class, javaslang.collection.Set.class)).isTrue(); + assertThat(conversionService.canConvert(List.class, javaslang.collection.Map.class)).isFalse(); List integers = Arrays.asList(1, 2, 3); Traversable result = conversionService.convert(integers, Traversable.class); - assertThat(result, is(instanceOf(javaslang.collection.List.class))); + assertThat(result).isInstanceOf(javaslang.collection.List.class); } @Test // DATACMNS-940 public void convertsSetToJavaslang() { - assertThat(conversionService.canConvert(Set.class, javaslang.collection.Traversable.class), is(true)); - assertThat(conversionService.canConvert(Set.class, javaslang.collection.Set.class), is(true)); - assertThat(conversionService.canConvert(Set.class, javaslang.collection.List.class), is(true)); - assertThat(conversionService.canConvert(Set.class, javaslang.collection.Map.class), is(false)); + assertThat(conversionService.canConvert(Set.class, javaslang.collection.Traversable.class)).isTrue(); + assertThat(conversionService.canConvert(Set.class, javaslang.collection.Set.class)).isTrue(); + assertThat(conversionService.canConvert(Set.class, javaslang.collection.List.class)).isTrue(); + assertThat(conversionService.canConvert(Set.class, javaslang.collection.Map.class)).isFalse(); Set integers = Collections.singleton(1); Traversable result = conversionService.convert(integers, Traversable.class); - assertThat(result, is(instanceOf(javaslang.collection.Set.class))); + assertThat(result).isInstanceOf(javaslang.collection.Set.class); } @Test // DATACMNS-940 public void convertsMapToJavaslang() { - assertThat(conversionService.canConvert(Map.class, javaslang.collection.Traversable.class), is(true)); - assertThat(conversionService.canConvert(Map.class, javaslang.collection.Map.class), is(true)); - assertThat(conversionService.canConvert(Map.class, javaslang.collection.Set.class), is(false)); - assertThat(conversionService.canConvert(Map.class, javaslang.collection.List.class), is(false)); + assertThat(conversionService.canConvert(Map.class, javaslang.collection.Traversable.class)).isTrue(); + assertThat(conversionService.canConvert(Map.class, javaslang.collection.Map.class)).isTrue(); + assertThat(conversionService.canConvert(Map.class, javaslang.collection.Set.class)).isFalse(); + assertThat(conversionService.canConvert(Map.class, javaslang.collection.List.class)).isFalse(); Map map = Collections.singletonMap("key", "value"); Traversable result = conversionService.convert(map, Traversable.class); - assertThat(result, is(instanceOf(javaslang.collection.Map.class))); + assertThat(result).isInstanceOf(javaslang.collection.Map.class); } @Test // DATACMNS-940 public void unwrapsJavaslangCollectionsToJavaOnes() { - assertThat(unwrap(javaslangList(1, 2, 3)), is(instanceOf(List.class))); - assertThat(unwrap(javaslangSet(1, 2, 3)), is(instanceOf(Set.class))); - assertThat(unwrap(javaslangMap("key", "value")), is(instanceOf(Map.class))); + assertThat(unwrap(javaslangList(1, 2, 3))).isInstanceOf(List.class); + assertThat(unwrap(javaslangSet(1, 2, 3))).isInstanceOf(Set.class); + assertThat(unwrap(javaslangMap("key", "value"))).isInstanceOf(Map.class); } @Test // DATACMNS-1005 public void registersAllowedPageabletypes() { Set> allowedPageableTypes = QueryExecutionConverters.getAllowedPageableTypes(); - assertThat(allowedPageableTypes, Matchers.> hasItems(Page.class, Slice.class, List.class, Seq.class)); + assertThat(allowedPageableTypes).contains(Page.class, Slice.class, List.class, Seq.class); } @SuppressWarnings("unchecked")