From bfd306dba71b6bdb4f33e8220d7d2696f6aadc74 Mon Sep 17 00:00:00 2001 From: Oliver Gierke Date: Fri, 3 Feb 2012 11:50:12 +0100 Subject: [PATCH] DATACMNS-131 - Formatting. --- .../data/annotation/TypeAlias.java | 3 +- .../data/convert/DefaultTypeMapper.java | 25 +++---- .../data/convert/EntityInstantiator.java | 3 +- .../data/convert/EntityReader.java | 2 +- .../data/convert/EntityWriter.java | 1 - .../data/convert/TypeAliasAccessor.java | 8 +-- .../data/convert/TypeInformationMapper.java | 6 +- .../org/springframework/data/domain/Sort.java | 19 +++--- .../data/mapping/PersistentEntity.java | 4 +- .../data/mapping/PersistentProperty.java | 9 ++- .../data/mapping/PreferredConstructor.java | 8 +-- .../data/mapping/PropertyPath.java | 22 +++---- .../DefaultPersistentPropertyPath.java | 2 +- .../context/PersistentPropertyPath.java | 5 +- .../model/AbstractPersistentProperty.java | 2 +- .../mapping/model/BasicPersistentEntity.java | 14 ++-- .../data/mapping/model/BeanWrapper.java | 2 +- .../mapping/model/ParameterValueProvider.java | 2 +- .../mapping/model/PropertyValueProvider.java | 2 +- .../model/SpELExpressionEvaluator.java | 2 +- .../data/persistence/StateBackedCreator.java | 1 + .../data/querydsl/QueryDslUtils.java | 4 +- .../repository/cdi/CdiRepositoryBean.java | 2 +- ...tractRepositoryConfigDefinitionParser.java | 8 +-- .../repository/core/RepositoryMetadata.java | 2 +- .../support/AbstractRepositoryMetadata.java | 6 +- .../support/DefaultRepositoryInformation.java | 4 +- ...sitoryInterfaceAwareBeanPostProcessor.java | 2 +- .../data/repository/query/QueryMethod.java | 2 +- .../data/repository/query/parser/Part.java | 44 +++++-------- .../repository/query/parser/PartTree.java | 10 +-- .../util/ParameterizedTypeInformation.java | 12 ++-- .../util/ParentTypeAwareTypeInformation.java | 12 ++-- .../data/util/TypeDiscoverer.java | 20 +++--- .../data/util/TypeInformation.java | 2 +- .../util/TypeVariableTypeInformation.java | 3 +- .../UserCredentialsUnitTests.java | 4 +- ...gurableTypeInformationMapperUnitTests.java | 38 +++++------ .../ReflectionEntityInstantiatorUnitTest.java | 12 ++-- .../SimpleTypeInformationMapperUnitTests.java | 20 +++--- .../data/domain/DirectionUnitTests.java | 4 +- .../data/domain/PageImplUnitTests.java | 21 ++---- .../data/domain/PageRequestUnitTests.java | 10 +-- .../data/domain/SortUnitTests.java | 37 ++++------- .../data/domain/UnitTestUtils.java | 13 ++-- .../data/mapping/Document.java | 5 +- .../data/mapping/MappingMetadataTests.java | 27 ++++---- .../mapping/SimpleTypeHolderUnitTests.java | 66 +++++++++---------- ...bstractMappingContextIntegrationTests.java | 8 +-- .../AbstractMappingContextUnitTests.java | 38 ++++++----- .../AbstractPersistentPropertyUnitTests.java | 13 ++-- .../SimpleEntityPathResolverUnitTests.java | 9 +-- .../cdi/CdiRepositoryBeanUnitTests.java | 26 ++++---- ...itoryExtensionSupportIntegrationTests.java | 2 +- ...itoryExtensionSupportIntegrationTests.java | 3 +- .../RepositoryComponentProviderUnitTests.java | 6 +- .../config/TypeFilterParserUnitTests.java | 32 +++------ .../AbstractEntityInformationUnitTests.java | 11 +--- .../AbstractRepositoryMetadataUnitTests.java | 2 +- ...AnnotationRepositoryMetadataUnitTests.java | 20 +++--- ...onTransactionAttributeSourceUnitTests.java | 4 +- ...DefaultRepositoryInformationUnitTests.java | 8 +-- .../DefaultRepositoryMetadataUnitTests.java | 52 +++++---------- ...PersistableEntityInformationUnitTests.java | 17 ++--- ...erfaceAwareBeanPostProcessorUnitTests.java | 36 +++------- ...RepositoryProxyPostProcessorUnitTests.java | 22 ++----- .../repository/query/ParametersUnitTests.java | 53 ++++----------- .../query/QueryMethodUnitTests.java | 7 +- .../SimpleParameterAccessorUnitTests.java | 45 +++---------- .../query/parser/OrderBySourceUnitTests.java | 19 ++---- .../sample/SampleAnnotatedRepository.java | 2 +- .../DomainClassConverterUnitTests.java | 36 +++------- ...ClassPropertyEditorRegistrarUnitTests.java | 34 +++------- .../DomainClassPropertyEditorUnitTests.java | 28 ++------ .../repository/util/ClassUtilsUnitTests.java | 7 +- .../util/ClassTypeInformationUnitTests.java | 52 +++++++-------- .../data/util/ParameterizedTypeUnitTests.java | 37 ++++++----- .../data/util/TypeDiscovererUnitTests.java | 2 +- .../PageableArgumentResolverUnitTests.java | 45 +++---------- 79 files changed, 469 insertions(+), 739 deletions(-) diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/annotation/TypeAlias.java b/spring-data-commons-core/src/main/java/org/springframework/data/annotation/TypeAlias.java index d9f2ca138..ff09317c0 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/annotation/TypeAlias.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/annotation/TypeAlias.java @@ -32,12 +32,13 @@ import org.springframework.data.mapping.PersistentEntity; */ @Documented @Inherited -@Target({ElementType.TYPE}) +@Target({ ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) public @interface TypeAlias { /** * The type alias to be used when persisting + * * @return */ String value(); diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/convert/DefaultTypeMapper.java b/spring-data-commons-core/src/main/java/org/springframework/data/convert/DefaultTypeMapper.java index bc2f803fb..d2d65c742 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/convert/DefaultTypeMapper.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/convert/DefaultTypeMapper.java @@ -44,20 +44,22 @@ public class DefaultTypeMapper implements TypeMapper { } public DefaultTypeMapper(TypeAliasAccessor accessor, List mappers) { - + this(accessor, null, mappers); } - - public DefaultTypeMapper(TypeAliasAccessor accessor, MappingContext, ?> mappingContext, List additionalMappers) { - + + public DefaultTypeMapper(TypeAliasAccessor accessor, + MappingContext, ?> mappingContext, + List additionalMappers) { + Assert.notNull(accessor); - + List mappers = new ArrayList(additionalMappers.size() + 1); if (mappingContext != null) { - mappers.add(new ConfigurableTypeInformationMapper(mappingContext)); + mappers.add(new ConfigurableTypeInformationMapper(mappingContext)); } mappers.addAll(additionalMappers); - + this.mappers = Collections.unmodifiableList(mappers); this.accessor = accessor; } @@ -91,11 +93,11 @@ public class DefaultTypeMapper implements TypeMapper { Assert.notNull(source); Class documentsTargetType = getDefaultedTypeToBeUsed(source); - + if (documentsTargetType == null) { return basicType; } - + Class rawType = basicType == null ? null : basicType.getType(); boolean isMoreConcreteCustomType = rawType == null ? true : rawType.isAssignableFrom(documentsTargetType) @@ -114,10 +116,11 @@ public class DefaultTypeMapper implements TypeMapper { private Class getDefaultedTypeToBeUsed(S source) { TypeInformation documentsTargetTypeInformation = readType(source); - documentsTargetTypeInformation = documentsTargetTypeInformation == null ? getFallbackTypeFor(source) : documentsTargetTypeInformation; + documentsTargetTypeInformation = documentsTargetTypeInformation == null ? getFallbackTypeFor(source) + : documentsTargetTypeInformation; return documentsTargetTypeInformation == null ? null : documentsTargetTypeInformation.getType(); } - + /** * Returns the type fallback {@link TypeInformation} in case none could be extracted from the given source. * diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityInstantiator.java b/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityInstantiator.java index 711376876..075f3b0d9 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityInstantiator.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityInstantiator.java @@ -33,5 +33,6 @@ public interface EntityInstantiator { * @param provider will not be {@literal null}. * @return */ - , P extends PersistentProperty

> T createInstance(E entity, ParameterValueProvider

provider); + , P extends PersistentProperty

> T createInstance(E entity, + ParameterValueProvider

provider); } diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityReader.java b/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityReader.java index 427afe863..b348f667d 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityReader.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityReader.java @@ -17,7 +17,7 @@ package org.springframework.data.convert; /** * Interface to read object from store specific sources. - * + * * @author Oliver Gierke */ public interface EntityReader { diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityWriter.java b/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityWriter.java index af1a3080c..99ed6cf55 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityWriter.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/convert/EntityWriter.java @@ -15,7 +15,6 @@ */ package org.springframework.data.convert; - /** * Interface to write objects into store specific sinks. * diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/convert/TypeAliasAccessor.java b/spring-data-commons-core/src/main/java/org/springframework/data/convert/TypeAliasAccessor.java index 23a30a818..6372408dc 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/convert/TypeAliasAccessor.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/convert/TypeAliasAccessor.java @@ -17,22 +17,22 @@ package org.springframework.data.convert; /** * Interface to abstract implementations of how to access a type alias from a given source or sink. - * + * * @author Oliver Gierke */ public interface TypeAliasAccessor { /** * Reads the type alias to be used from the given source. - * + * * @param source * @return */ Object readAliasFrom(S source); - + /** * Writes the given type alias to the given sink. - * + * * @param sink * @param alias */ diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/convert/TypeInformationMapper.java b/spring-data-commons-core/src/main/java/org/springframework/data/convert/TypeInformationMapper.java index 6eede2cb4..29207f5f2 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/convert/TypeInformationMapper.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/convert/TypeInformationMapper.java @@ -19,7 +19,7 @@ import org.springframework.data.util.TypeInformation; /** * Interface to abstract the mapping from a type alias to the actual type. - * + * * @author Oliver Gierke */ public interface TypeInformationMapper { @@ -31,10 +31,10 @@ public interface TypeInformationMapper { * @return */ TypeInformation resolveTypeFrom(Object alias); - + /** * Returns the alias to be used for the given {@link TypeInformation}. - * + * * @param type * @return */ diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/domain/Sort.java b/spring-data-commons-core/src/main/java/org/springframework/data/domain/Sort.java index 2526f671d..5a963d2bb 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/domain/Sort.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/domain/Sort.java @@ -167,10 +167,9 @@ public class Sort implements Iterable> { * {@link PersistentEntity}. * * @param property - * @return true if the given {@link PersistentProperty} is referred to by a constructor argument or {@literal false} if - * not or {@literal null}. + * @return true if the given {@link PersistentProperty} is referred to by a constructor argument or {@literal false} + * if not or {@literal null}. */ boolean isConstructorArgument(P property); diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PersistentProperty.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PersistentProperty.java index 1f0f4c293..66cf12f0c 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PersistentProperty.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PersistentProperty.java @@ -43,7 +43,7 @@ public interface PersistentProperty

> { /** * Returns the {@link PropertyDescriptor} backing the {@link PersistentProperty}. - * + * * @return */ PropertyDescriptor getPropertyDescriptor(); @@ -60,7 +60,7 @@ public interface PersistentProperty

> { * @return */ boolean isIdProperty(); - + /** * Returns whether the property is a {@link Collection}, {@link Iterable} or an array. * @@ -88,8 +88,7 @@ public interface PersistentProperty

> { * @return */ boolean isTransient(); - - + boolean shallBePersisted(); /** @@ -98,7 +97,7 @@ public interface PersistentProperty

> { * @return */ boolean isAssociation(); - + /** * Returns the component type of the type if it is a {@link java.util.Collection}. Will return the type of the key if * the property is a {@link java.util.Map}. diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PreferredConstructor.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PreferredConstructor.java index f97802555..55dee69da 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PreferredConstructor.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PreferredConstructor.java @@ -100,7 +100,7 @@ public class PreferredConstructor> { public boolean isExplicitlyAnnotated() { return constructor.isAnnotationPresent(PersistenceConstructor.class); } - + /** * Returns whether the given {@link PersistentProperty} is referenced in a constructor argument of the * {@link PersistentEntity} backing this {@link MappedConstructor}. @@ -199,7 +199,7 @@ public class PreferredConstructor> { public String getSpelExpression() { return key; } - + /** * Returns whether the constructor parameter is equipped with a SpEL expression. * @@ -208,7 +208,7 @@ public class PreferredConstructor> { public boolean hasSpelExpression() { return StringUtils.hasText(getSpelExpression()); } - + /** * Returns whether the {@link Parameter} maps the given {@link PersistentProperty}. * @@ -216,7 +216,7 @@ public class PreferredConstructor> { * @return */ boolean maps(P property) { - + P referencedProperty = entity == null ? null : entity.getPersistentProperty(name); return property == null ? false : property.equals(referencedProperty); } diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PropertyPath.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PropertyPath.java index 974ecc439..31e9f9260 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PropertyPath.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PropertyPath.java @@ -138,8 +138,8 @@ public class PropertyPath implements Iterable { } /** - * Returns whether there is a nested {@link PropertyPath}. If this returns {@literal true} you can expect {@link #next()} - * to return a non- {@literal null} value. + * Returns whether there is a nested {@link PropertyPath}. If this returns {@literal true} you can expect + * {@link #next()} to return a non- {@literal null} value. * * @return */ @@ -208,7 +208,7 @@ public class PropertyPath implements Iterable { */ public Iterator iterator() { return new Iterator() { - + private PropertyPath current = PropertyPath.this; public boolean hasNext() { @@ -226,7 +226,7 @@ public class PropertyPath implements Iterable { } }; } - + /** * Extracts the {@link PropertyPath} chain from the given source {@link String} and type. * @@ -243,7 +243,7 @@ public class PropertyPath implements Iterable { * Extracts the {@link PropertyPath} chain from the given source {@link String} and {@link TypeInformation}. * * @param source must not be {@literal null}. - * @param type + * @param type * @return */ public static PropertyPath from(String source, TypeInformation type) { @@ -287,10 +287,10 @@ public class PropertyPath implements Iterable { } /** - * Factory method to create a new {@link PropertyPath} for the given {@link String} and owning type. It will inspect the - * given source for camel-case parts and traverse the {@link String} along its parts starting with the entire one and - * chewing off parts from the right side then. Whenever a valid property for the given class is found, the tail will - * be traversed for subordinary properties of the just found one and so on. + * Factory method to create a new {@link PropertyPath} for the given {@link String} and owning type. It will inspect + * the given source for camel-case parts and traverse the {@link String} along its parts starting with the entire one + * and chewing off parts from the right side then. Whenever a valid property for the given class is found, the tail + * will be traversed for subordinary properties of the just found one and so on. * * @param source * @param type @@ -303,8 +303,8 @@ public class PropertyPath implements Iterable { /** * Tries to look up a chain of {@link PropertyPath}s by trying the givne source first. If that fails it will split the - * source apart at camel case borders (starting from the right side) and try to look up a {@link PropertyPath} from the - * calculated head and recombined new tail and additional tail. + * source apart at camel case borders (starting from the right side) and try to look up a {@link PropertyPath} from + * the calculated head and recombined new tail and additional tail. * * @param source * @param type diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/DefaultPersistentPropertyPath.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/DefaultPersistentPropertyPath.java index aaec65a7b..db645a6d5 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/DefaultPersistentPropertyPath.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/DefaultPersistentPropertyPath.java @@ -176,7 +176,7 @@ class DefaultPersistentPropertyPath> implements } return new DefaultPersistentPropertyPath(properties.subList(0, size - 1)); } - + /* * (non-Javadoc) * @see org.springframework.data.mapping.context.PersistentPropertyPath#getLength() diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/PersistentPropertyPath.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/PersistentPropertyPath.java index f9f8acde3..b97504c6d 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/PersistentPropertyPath.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/PersistentPropertyPath.java @@ -97,8 +97,9 @@ public interface PersistentPropertyPath> extends PersistentPropertyPath getExtensionForBaseOf(PersistentPropertyPath base); /** - * Returns the parent path of the current {@link PersistentPropertyPath}, i.e. the path without the leaf property. This happens up to the base - * property. So for a direct property reference calling this method will result in returning the property. + * Returns the parent path of the current {@link PersistentPropertyPath}, i.e. the path without the leaf property. + * This happens up to the base property. So for a direct property reference calling this method will result in + * returning the property. * * @return */ diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/AbstractPersistentProperty.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/AbstractPersistentProperty.java index 4457fca15..efe954d00 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/AbstractPersistentProperty.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/AbstractPersistentProperty.java @@ -176,7 +176,7 @@ public abstract class AbstractPersistentProperty

} protected boolean isEntity() { - + boolean isComplexType = !simpleTypeHolder.isSimpleType(information.getActualType().getType()); return isComplexType && !isTransient() && !isCollectionLike() && !isMap(); } diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/BasicPersistentEntity.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/BasicPersistentEntity.java index d68a1ab7d..f7c7d57de 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/BasicPersistentEntity.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/BasicPersistentEntity.java @@ -40,7 +40,7 @@ import org.springframework.util.StringUtils; */ public class BasicPersistentEntity> implements MutablePersistentEntity { - private final PreferredConstructor constructor; + private final PreferredConstructor constructor; private final TypeInformation information; private final Set

properties; private final Set> associations; @@ -65,16 +65,16 @@ public class BasicPersistentEntity> implement * @param comparator */ public BasicPersistentEntity(TypeInformation information, Comparator

comparator) { - + Assert.notNull(information); - + this.information = information; this.properties = comparator == null ? new HashSet

() : new TreeSet

(comparator); this.constructor = new PreferredConstructorDiscoverer(information, this).getConstructor(); this.associations = comparator == null ? new HashSet>() : new TreeSet>( new AssociationComparator

(comparator)); } - + /* * (non-Javadoc) * @see org.springframework.data.mapping.PersistentEntity#getPersistenceConstructor() @@ -82,7 +82,7 @@ public class BasicPersistentEntity> implement public PreferredConstructor getPersistenceConstructor() { return constructor; } - + /* * (non-Javadoc) * @see org.springframework.data.mapping.PersistentEntity#isConstructorArgument(org.springframework.data.mapping.PersistentProperty) @@ -153,13 +153,13 @@ public class BasicPersistentEntity> implement public Class getType() { return information.getType(); } - + /* * (non-Javadoc) * @see org.springframework.data.mapping.PersistentEntity#getTypeAlias() */ public Object getTypeAlias() { - + TypeAlias alias = getType().getAnnotation(TypeAlias.class); return alias == null ? null : StringUtils.hasText(alias.value()) ? alias.value() : null; } diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/BeanWrapper.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/BeanWrapper.java index f593d3128..cee678d49 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/BeanWrapper.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/BeanWrapper.java @@ -131,7 +131,7 @@ public class BeanWrapper, T> { Field field = property.getField(); Method getter = (null != property.getPropertyDescriptor() ? property.getPropertyDescriptor().getReadMethod() : null); - + if (fieldAccessOnly || null == getter) { ReflectionUtils.makeAccessible(field); obj = ReflectionUtils.getField(field, bean); diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/ParameterValueProvider.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/ParameterValueProvider.java index 295e5fa91..1049f73bc 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/ParameterValueProvider.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/ParameterValueProvider.java @@ -24,7 +24,7 @@ import org.springframework.data.mapping.PreferredConstructor.Parameter; * @author Oliver Gierke */ public interface ParameterValueProvider

> { - + /** * Returns the value to be used for the given {@link Parameter} (usually when entity instances are created). * diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/PropertyValueProvider.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/PropertyValueProvider.java index 8f04d98c9..b3ef0eea3 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/PropertyValueProvider.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/PropertyValueProvider.java @@ -19,7 +19,7 @@ import org.springframework.data.mapping.PersistentProperty; /** * SPI for components to provide values for as {@link PersistentProperty}. - * + * * @author Oliver Gierke */ public interface PropertyValueProvider

> { diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/SpELExpressionEvaluator.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/SpELExpressionEvaluator.java index 8b5085967..bbad60cd1 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/SpELExpressionEvaluator.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/model/SpELExpressionEvaluator.java @@ -17,7 +17,7 @@ package org.springframework.data.mapping.model; /** * SPI for components that can evaluate Spring EL expressions. - * + * * @author Oliver Gierke */ public interface SpELExpressionEvaluator { diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/persistence/StateBackedCreator.java b/spring-data-commons-core/src/main/java/org/springframework/data/persistence/StateBackedCreator.java index bbe0e0aa4..ed55d3629 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/persistence/StateBackedCreator.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/persistence/StateBackedCreator.java @@ -7,6 +7,7 @@ import org.springframework.data.convert.EntityInstantiator; *

* Can be implemented and registered with the concrete AbstractConstructorEntityInstantiator to provide non reflection * bases instantiaton for domain classes + * * @deprecated use {@link EntityInstantiator} abstraction instead. */ @Deprecated diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/querydsl/QueryDslUtils.java b/spring-data-commons-core/src/main/java/org/springframework/data/querydsl/QueryDslUtils.java index d70842c0f..1376d7c31 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/querydsl/QueryDslUtils.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/querydsl/QueryDslUtils.java @@ -24,8 +24,8 @@ public abstract class QueryDslUtils { public static final boolean QUERY_DSL_PRESENT = org.springframework.util.ClassUtils.isPresent( "com.mysema.query.types.Predicate", QueryDslUtils.class.getClassLoader()); - + private QueryDslUtils() { - + } } diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/repository/cdi/CdiRepositoryBean.java b/spring-data-commons-core/src/main/java/org/springframework/data/repository/cdi/CdiRepositoryBean.java index 9e2885a04..cc54a7b86 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/repository/cdi/CdiRepositoryBean.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/repository/cdi/CdiRepositoryBean.java @@ -83,7 +83,7 @@ public abstract class CdiRepositoryBean implements Bean { return new HashSet(interfaces); } - + /** * Returns an instance of an {@link EntityManager}. * diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/repository/config/AbstractRepositoryConfigDefinitionParser.java b/spring-data-commons-core/src/main/java/org/springframework/data/repository/config/AbstractRepositoryConfigDefinitionParser.java index 0039d57dc..b601b4536 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/repository/config/AbstractRepositoryConfigDefinitionParser.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/repository/config/AbstractRepositoryConfigDefinitionParser.java @@ -63,7 +63,7 @@ public abstract class AbstractRepositoryConfigDefinitionParser definitions = provider.findCandidateComponents(config.getBasePackage()); - + if (definitions.size() == 0) { return null; } - + if (definitions.size() == 1) { return (AbstractBeanDefinition) definitions.iterator().next(); } @@ -287,7 +287,7 @@ public abstract class AbstractRepositoryConfigDefinitionParser getRepositoryInterface(); - + /** * Returns the domain class returned by the given {@link Method}. Will extract the type from {@link Collection}s and * {@link org.springframework.data.domain.Page} as well. diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadata.java b/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadata.java index 4de8d3f26..82ff50409 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadata.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadata.java @@ -30,19 +30,19 @@ import org.springframework.util.Assert; public abstract class AbstractRepositoryMetadata implements RepositoryMetadata { private final TypeInformation typeInformation; - + /** * Creates a new {@link AbstractRepositoryMetadata}. * * @param repositoryInterface must not be {@literal null} and must be an interface. */ public AbstractRepositoryMetadata(Class repositoryInterface) { - + Assert.notNull(repositoryInterface, "Given type must not be null!"); Assert.isTrue(repositoryInterface.isInterface(), "Given type must be an interface!"); this.typeInformation = ClassTypeInformation.from(repositoryInterface); } - + /* * (non-Javadoc) * @see org.springframework.data.repository.core.RepositoryMetadata#getReturnedDomainClass(java.lang.reflect.Method) diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/DefaultRepositoryInformation.java b/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/DefaultRepositoryInformation.java index e84c2c7cc..3b0c643c6 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/DefaultRepositoryInformation.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/DefaultRepositoryInformation.java @@ -61,10 +61,10 @@ class DefaultRepositoryInformation extends AbstractRepositoryMetadata implements Class customImplementationClass) { super(metadata.getRepositoryInterface()); - + Assert.notNull(metadata); Assert.notNull(repositoryBaseClass); - + this.metadata = metadata; this.repositoryBaseClass = repositoryBaseClass; this.customImplementationClass = customImplementationClass; diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/RepositoryInterfaceAwareBeanPostProcessor.java b/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/RepositoryInterfaceAwareBeanPostProcessor.java index d53d3cc3b..be94a2da4 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/RepositoryInterfaceAwareBeanPostProcessor.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/repository/core/support/RepositoryInterfaceAwareBeanPostProcessor.java @@ -39,7 +39,7 @@ import org.springframework.util.ClassUtils; */ class RepositoryInterfaceAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements BeanFactoryAware { - + private static final Log LOG = LogFactory.getLog(RepositoryInterfaceAwareBeanPostProcessor.class); private static final Class REPOSITORY_TYPE = RepositoryFactoryBeanSupport.class; diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/QueryMethod.java b/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/QueryMethod.java index 85616cf02..1643ccbd9 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/QueryMethod.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/QueryMethod.java @@ -133,7 +133,7 @@ public class QueryMethod { return repositoryDomainClass == null || repositoryDomainClass.isAssignableFrom(methodDomainClass) ? methodDomainClass : repositoryDomainClass; } - + /** * Returns the type of the object that will be returned. * diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/parser/Part.java b/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/parser/Part.java index 3da93102b..60b26a645 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/parser/Part.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/parser/Part.java @@ -45,6 +45,7 @@ public class Part { * * @param part must not be {@literal null}. * @param clazz must not be {@l + */ public Part(String part, Class clazz) { @@ -73,12 +74,12 @@ public class Part { Matcher matcher = IGNORE_CASE.matcher(part); String result = part; - + if (matcher.find()) { ignoreCase = IgnoreCaseType.ALWAYS; result = part.substring(0, matcher.start()) + part.substring(matcher.end(), part.length()); } - + return result; } @@ -172,30 +173,16 @@ public class Part { */ public static enum Type { - BETWEEN(2, "Between"), - IS_NOT_NULL(0, "IsNotNull", "NotNull"), - IS_NULL(0, "IsNull", "Null"), - LESS_THAN("LessThan"), - LESS_THAN_EQUAL("LessThanEqual"), - GREATER_THAN("GreaterThan"), - GREATER_THAN_EQUAL("GreaterThanEqual"), - NOT_LIKE("NotLike"), - LIKE("Like"), - NOT_IN("NotIn"), - IN("In"), - NEAR("Near"), - WITHIN("Within"), - REGEX("Regex"), - EXISTS(0, "Exists"), - TRUE(0, "IsTrue", "True"), - FALSE(0, "IsFalse", "False"), - NEGATING_SIMPLE_PROPERTY("Not"), - SIMPLE_PROPERTY; + BETWEEN(2, "Between"), IS_NOT_NULL(0, "IsNotNull", "NotNull"), IS_NULL(0, "IsNull", "Null"), LESS_THAN("LessThan"), LESS_THAN_EQUAL( + "LessThanEqual"), GREATER_THAN("GreaterThan"), GREATER_THAN_EQUAL("GreaterThanEqual"), NOT_LIKE("NotLike"), LIKE( + "Like"), NOT_IN("NotIn"), IN("In"), NEAR("Near"), WITHIN("Within"), REGEX("Regex"), EXISTS(0, "Exists"), TRUE( + 0, "IsTrue", "True"), FALSE(0, "IsFalse", "False"), NEGATING_SIMPLE_PROPERTY("Not"), SIMPLE_PROPERTY; // Need to list them again explicitly as the order is important // (esp. for IS_NULL, IS_NOT_NULL) - private static final List ALL = Arrays.asList(IS_NOT_NULL, IS_NULL, BETWEEN, LESS_THAN, LESS_THAN_EQUAL, GREATER_THAN, GREATER_THAN_EQUAL, - NOT_LIKE, LIKE, NOT_IN, IN, NEAR, WITHIN, REGEX, EXISTS, TRUE, FALSE, NEGATING_SIMPLE_PROPERTY, SIMPLE_PROPERTY); + private static final List ALL = Arrays.asList(IS_NOT_NULL, IS_NULL, BETWEEN, LESS_THAN, LESS_THAN_EQUAL, + GREATER_THAN, GREATER_THAN_EQUAL, NOT_LIKE, LIKE, NOT_IN, IN, NEAR, WITHIN, REGEX, EXISTS, TRUE, FALSE, + NEGATING_SIMPLE_PROPERTY, SIMPLE_PROPERTY); private final List keywords; private final int numberOfArguments; @@ -219,9 +206,9 @@ public class Part { } /** - * Returns the {@link Type} of the {@link Part} for the given raw propertyPath. This will - * try to detect e.g. keywords contained in the raw propertyPath that trigger special query creation. Returns - * {@link #SIMPLE_PROPERTY} by default. + * Returns the {@link Type} of the {@link Part} for the given raw propertyPath. This will try to detect e.g. + * keywords contained in the raw propertyPath that trigger special query creation. Returns {@link #SIMPLE_PROPERTY} + * by default. * * @param rawProperty * @return @@ -238,8 +225,9 @@ public class Part { } /** - * Returns whether the the type supports the given raw propertyPath. Default implementation checks whether the propertyPath - * ends with the registered keyword. Does not support the keyword if the propertyPath is a valid field as is. + * Returns whether the the type supports the given raw propertyPath. Default implementation checks whether the + * propertyPath ends with the registered keyword. Does not support the keyword if the propertyPath is a valid field + * as is. * * @param propertyPath * @return diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/parser/PartTree.java b/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/parser/PartTree.java index 37efc4c65..12c9b510b 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/parser/PartTree.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/repository/query/parser/PartTree.java @@ -100,7 +100,7 @@ public class PartTree implements Iterable { return subject.isDistinct(); } - + /** * Returns an {@link Iterable} of all parts contained in the {@link PartTree}. * @@ -116,7 +116,7 @@ public class PartTree implements Iterable { } return result; } - + /** * Returns all {@link Part}s of the {@link PartTree} of the given {@link Type}. * @@ -124,15 +124,15 @@ public class PartTree implements Iterable { * @return */ public Iterable getParts(Type type) { - + List result = new ArrayList(); - + for (Part part : getParts()) { if (part.getType().equals(type)) { result.add(part); } } - + return result; } diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/util/ParameterizedTypeInformation.java b/spring-data-commons-core/src/main/java/org/springframework/data/util/ParameterizedTypeInformation.java index 3f392c2d9..706e77a9b 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/util/ParameterizedTypeInformation.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/util/ParameterizedTypeInformation.java @@ -45,26 +45,24 @@ class ParameterizedTypeInformation extends ParentTypeAwareTypeInformation this.type = type; } - - /* * (non-Javadoc) * @see org.springframework.data.util.TypeDiscoverer#getMapValueType() */ @Override public TypeInformation getMapValueType() { - + if (Map.class.equals(getType())) { Type[] arguments = type.getActualTypeArguments(); return createInfo(arguments[1]); } - + Class rawType = getType(); - + Set supertypes = new HashSet(); supertypes.add(rawType.getGenericSuperclass()); supertypes.addAll(Arrays.asList(rawType.getGenericInterfaces())); - + for (Type supertype : supertypes) { Class rawSuperType = GenericTypeResolver.resolveType(supertype, getTypeVariableMap()); if (Map.class.isAssignableFrom(rawSuperType)) { @@ -73,7 +71,7 @@ class ParameterizedTypeInformation extends ParentTypeAwareTypeInformation return createInfo(arguments[1]); } } - + return super.getMapValueType(); } } diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/util/ParentTypeAwareTypeInformation.java b/spring-data-commons-core/src/main/java/org/springframework/data/util/ParentTypeAwareTypeInformation.java index 42a133971..4a4dd2835 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/util/ParentTypeAwareTypeInformation.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/util/ParentTypeAwareTypeInformation.java @@ -8,13 +8,13 @@ import org.springframework.util.ObjectUtils; /** * Base class for {@link TypeInformation} implementations that need parent type awareness. - * + * * @author Oliver Gierke */ public abstract class ParentTypeAwareTypeInformation extends TypeDiscoverer { - private final TypeDiscoverer parent; - + private final TypeDiscoverer parent; + /** * Creates a new {@link ParentTypeAwareTypeInformation}. * @@ -26,7 +26,7 @@ public abstract class ParentTypeAwareTypeInformation extends TypeDiscoverer extends TypeDiscoverer getTypeVariableMap() { return parent == null ? super.getTypeVariableMap() : parent.getTypeVariableMap(); } - + /* * (non-Javadoc) * @see org.springframework.data.util.TypeDiscoverer#createInfo(java.lang.reflect.Type) */ @Override protected TypeInformation createInfo(Type fieldType) { - + if (parent.getType().equals(fieldType)) { return parent; } diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeDiscoverer.java b/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeDiscoverer.java index 96674e78a..bd9343d49 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeDiscoverer.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeDiscoverer.java @@ -89,7 +89,7 @@ class TypeDiscoverer implements TypeInformation { if (fieldType instanceof Class) { return new ClassTypeInformation((Class) fieldType); } - + Map variableMap = GenericTypeResolver.getTypeVariableMap(resolveType(fieldType)); if (fieldType instanceof ParameterizedType) { @@ -105,18 +105,18 @@ class TypeDiscoverer implements TypeInformation { if (fieldType instanceof GenericArrayType) { return new GenericArrayTypeInformation((GenericArrayType) fieldType, this); } - + if (fieldType instanceof WildcardType) { - + WildcardType wildcardType = (WildcardType) fieldType; Type[] bounds = wildcardType.getLowerBounds(); - + if (bounds.length > 0) { return createInfo(bounds[0]); - } - + } + bounds = wildcardType.getUpperBounds(); - + if (bounds.length > 0) { return createInfo(bounds[0]); } @@ -266,7 +266,7 @@ class TypeDiscoverer implements TypeInformation { if (!isMap()) { return null; } - + return getTypeArgument(getType(), Map.class, 1); } @@ -320,11 +320,11 @@ class TypeDiscoverer implements TypeInformation { * @see org.springframework.data.util.TypeInformation#getReturnType(java.lang.reflect.Method) */ public TypeInformation getReturnType(Method method) { - + Assert.notNull(method); return createInfo(method.getGenericReturnType()); } - + /* * (non-Javadoc) * diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeInformation.java b/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeInformation.java index 69344fc31..ee2a50b58 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeInformation.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeInformation.java @@ -83,7 +83,7 @@ public interface TypeInformation { * @return */ TypeInformation getActualType(); - + /** * Returns a {@link TypeInformation} for the return type of the given {@link Method}. Will potentially resolve * generics information against the current types type parameter bindings. diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeVariableTypeInformation.java b/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeVariableTypeInformation.java index 05f834143..4aea74b05 100644 --- a/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeVariableTypeInformation.java +++ b/spring-data-commons-core/src/main/java/org/springframework/data/util/TypeVariableTypeInformation.java @@ -44,7 +44,8 @@ class TypeVariableTypeInformation extends ParentTypeAwareTypeInformation { * @param parent */ @SuppressWarnings("rawtypes") - public TypeVariableTypeInformation(TypeVariable variable, Type owningType, TypeDiscoverer parent, Map map) { + public TypeVariableTypeInformation(TypeVariable variable, Type owningType, TypeDiscoverer parent, + Map map) { super(variable, parent, map); Assert.notNull(variable); diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/authentication/UserCredentialsUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/authentication/UserCredentialsUnitTests.java index 03cfe7313..aa2273952 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/authentication/UserCredentialsUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/authentication/UserCredentialsUnitTests.java @@ -22,14 +22,14 @@ import org.junit.Test; /** * Unit tests for {@link UserCredentials}. - * + * * @author Oliver Gierke */ public class UserCredentialsUnitTests { @Test public void treatsEmptyStringAsNull() { - + UserCredentials credentials = new UserCredentials("", ""); assertThat(credentials.getUsername(), is(nullValue())); assertThat(credentials.getPassword(), is(nullValue())); diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/convert/ConfigurableTypeInformationMapperUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/convert/ConfigurableTypeInformationMapperUnitTests.java index 4b47bbf8d..775482706 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/convert/ConfigurableTypeInformationMapperUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/convert/ConfigurableTypeInformationMapperUnitTests.java @@ -39,42 +39,42 @@ import org.springframework.data.util.TypeInformation; /** * Unit tests for {@link ConfigurableTypeMapper}. - * + * * @author Oliver Gierke */ public class ConfigurableTypeInformationMapperUnitTests> { - + ConfigurableTypeInformationMapper mapper; - + @Before public void setUp() { mapper = new ConfigurableTypeInformationMapper(Collections.singletonMap(String.class, "1")); } - + @Test(expected = IllegalArgumentException.class) public void rejectsNullTypeMap() { new ConfigurableTypeInformationMapper((Map, String>) null); } - + @Test(expected = IllegalArgumentException.class) public void rejectsNullMappingContext() { new ConfigurableTypeInformationMapper((MappingContext) null); } - + @Test(expected = IllegalArgumentException.class) public void rejectsNonBijectionalMap() { Map, String> map = new HashMap, String>(); map.put(String.class, "1"); map.put(Object.class, "1"); - + new ConfigurableTypeInformationMapper(map); } - + @Test @SuppressWarnings("unchecked") public void extractsAliasInfoFromMappingContext() { - - AbstractMappingContext,T> mappingContext = new AbstractMappingContext, T>() { + + AbstractMappingContext, T> mappingContext = new AbstractMappingContext, T>() { @Override protected BasicPersistentEntity createPersistentEntity(TypeInformation typeInformation) { @@ -92,32 +92,32 @@ public class ConfigurableTypeInformationMapperUnitTests(Foo.class).getConstructor(); - + when(entity.getType()).thenReturn((Class) Foo.class); when(entity.getPersistenceConstructor()).thenReturn(constructor); - + Object instance = INSTANCE.createInstance(entity, provider); - + assertTrue(instance instanceof Foo); verify(provider, times(1)).getParameterValue((Parameter) constructor.getParameters().iterator().next()); } - + static class Foo { - + Foo(String foo) { - + } } } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/convert/SimpleTypeInformationMapperUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/convert/SimpleTypeInformationMapperUnitTests.java index 691830f9a..b401b5794 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/convert/SimpleTypeInformationMapperUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/convert/SimpleTypeInformationMapperUnitTests.java @@ -36,37 +36,37 @@ public class SimpleTypeInformationMapperUnitTests { TypeInformation type = mapper.resolveTypeFrom("java.lang.String"); TypeInformation expected = ClassTypeInformation.from(String.class); - + assertThat(type, is(expected)); } - + @Test public void returnsNullForNonStringKey() { - + TypeInformationMapper mapper = new SimpleTypeInformationMapper(); assertThat(mapper.resolveTypeFrom(new Object()), is(nullValue())); } - + @Test public void returnsNullForEmptyTypeKey() { - + TypeInformationMapper mapper = new SimpleTypeInformationMapper(); assertThat(mapper.resolveTypeFrom(""), is(nullValue())); } - + @Test public void returnsNullForUnloadableClass() { - + TypeInformationMapper mapper = new SimpleTypeInformationMapper(); assertThat(mapper.resolveTypeFrom("Foo"), is(nullValue())); } - + @Test public void usesFullyQualifiedClassNameAsTypeKey() { - + TypeInformationMapper mapper = new SimpleTypeInformationMapper(); Object alias = mapper.createAliasFor(ClassTypeInformation.from(String.class)); - + assertTrue(alias instanceof String); assertThat(alias, is((Object) String.class.getName())); } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/domain/DirectionUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/domain/DirectionUnitTests.java index 72ea9e665..c319839b9 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/domain/DirectionUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/domain/DirectionUnitTests.java @@ -5,10 +5,9 @@ import static org.junit.Assert.*; import org.junit.Test; import org.springframework.data.domain.Sort.Direction; - /** * Unit test for {@link Direction}. - * + * * @author Oliver Gierke */ public class DirectionUnitTests { @@ -20,7 +19,6 @@ public class DirectionUnitTests { assertEquals(Direction.DESC, Direction.fromString("desc")); } - @Test(expected = IllegalArgumentException.class) public void rejectsInvalidString() throws Exception { diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/domain/PageImplUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/domain/PageImplUnitTests.java index 208794ea8..ed5143603 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/domain/PageImplUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/domain/PageImplUnitTests.java @@ -26,10 +26,9 @@ import java.util.List; import org.junit.Test; - /** * Unit test for {@link PageImpl}. - * + * * @author Oliver Gierke */ public class PageImplUnitTests { @@ -40,11 +39,9 @@ public class PageImplUnitTests { PageImpl page = new PageImpl(Arrays.asList("Foo")); assertEqualsAndHashcode(page, page); - assertEqualsAndHashcode(page, - new PageImpl(Arrays.asList("Foo"))); + assertEqualsAndHashcode(page, new PageImpl(Arrays.asList("Foo"))); } - @Test public void assertEqualsForComplexSetup() throws Exception { @@ -55,27 +52,21 @@ public class PageImplUnitTests { assertEqualsAndHashcode(page, page); - assertEqualsAndHashcode(page, new PageImpl(content, pageable, - 100)); + assertEqualsAndHashcode(page, new PageImpl(content, pageable, 100)); - assertNotEqualsAndHashcode(page, new PageImpl(content, - pageable, 90)); + assertNotEqualsAndHashcode(page, new PageImpl(content, pageable, 90)); - assertNotEqualsAndHashcode(page, new PageImpl(content, - new PageRequest(1, 10), 100)); + assertNotEqualsAndHashcode(page, new PageImpl(content, new PageRequest(1, 10), 100)); - assertNotEqualsAndHashcode(page, new PageImpl(content, - new PageRequest(0, 15), 100)); + assertNotEqualsAndHashcode(page, new PageImpl(content, new PageRequest(0, 15), 100)); } - @Test(expected = IllegalArgumentException.class) public void preventsNullContentForSimpleSetup() throws Exception { new PageImpl(null); } - @Test(expected = IllegalArgumentException.class) public void preventsNullContentForAdvancedSetup() throws Exception { diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/domain/PageRequestUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/domain/PageRequestUnitTests.java index b9ea8e942..6a6e3e85e 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/domain/PageRequestUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/domain/PageRequestUnitTests.java @@ -21,10 +21,9 @@ import static org.springframework.data.domain.UnitTestUtils.*; import org.junit.Test; import org.springframework.data.domain.Sort.Direction; - /** * Unit test for {@link PageRequest}. - * + * * @author Oliver Gierke */ public class PageRequestUnitTests { @@ -35,21 +34,18 @@ public class PageRequestUnitTests { new PageRequest(-1, 10); } - @Test(expected = IllegalArgumentException.class) public void preventsNegativeSize() { new PageRequest(0, -1); } - @Test(expected = IllegalArgumentException.class) public void preventsZeroSize() { new PageRequest(0, 0); } - @Test public void equalsRegardsSortCorrectly() { @@ -69,11 +65,9 @@ public class PageRequestUnitTests { assertNotEqualsAndHashcode(request, new PageRequest(0, 10)); // Is not equal to instance with another sort - assertNotEqualsAndHashcode(request, new PageRequest(0, 10, - Direction.ASC, "foo")); + assertNotEqualsAndHashcode(request, new PageRequest(0, 10, Direction.ASC, "foo")); } - @Test public void equalsHonoursPageAndSize() { diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/domain/SortUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/domain/SortUnitTests.java index c5c3a86ba..0e4406557 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/domain/SortUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/domain/SortUnitTests.java @@ -22,33 +22,28 @@ import static org.junit.Assert.*; import org.junit.Test; import org.springframework.data.domain.Sort.Direction; - /** * Unit test for {@link Sort}. - * + * * @author Oliver Gierke */ public class SortUnitTests { /** - * Asserts that the class applies the default sort order if no order or - * {@code null} was provided. - * + * Asserts that the class applies the default sort order if no order or {@code null} was provided. + * * @throws Exception */ @Test public void appliesDefaultForOrder() throws Exception { - assertEquals(Sort.DEFAULT_DIRECTION, new Sort("foo").iterator().next() - .getDirection()); - assertEquals(Sort.DEFAULT_DIRECTION, new Sort((Direction) null, "foo") - .iterator().next().getDirection()); + assertEquals(Sort.DEFAULT_DIRECTION, new Sort("foo").iterator().next().getDirection()); + assertEquals(Sort.DEFAULT_DIRECTION, new Sort((Direction) null, "foo").iterator().next().getDirection()); } - /** * Asserts that the class rejects {@code null} as properties array. - * + * * @throws Exception */ @Test(expected = IllegalArgumentException.class) @@ -57,11 +52,9 @@ public class SortUnitTests { new Sort(Direction.ASC, (String[]) null); } - /** - * Asserts that the class rejects {@code null} values in the properties - * array. - * + * Asserts that the class rejects {@code null} values in the properties array. + * * @throws Exception */ @Test(expected = IllegalArgumentException.class) @@ -70,10 +63,9 @@ public class SortUnitTests { new Sort(Direction.ASC, (String) null); } - /** * Asserts that the class rejects empty strings in the properties array. - * + * * @throws Exception */ @Test(expected = IllegalArgumentException.class) @@ -82,10 +74,9 @@ public class SortUnitTests { new Sort(Direction.ASC, ""); } - /** * Asserts that the class rejects no properties given at all. - * + * * @throws Exception */ @Test(expected = IllegalArgumentException.class) @@ -93,17 +84,17 @@ public class SortUnitTests { new Sort(Direction.ASC); } - + @Test public void allowsCombiningSorts() { - + Sort sort = new Sort("foo").and(new Sort("bar")); assertThat(sort, hasItems(new Sort.Order("foo"), new Sort.Order("bar"))); } - + @Test public void handlesAdditionalNullSort() { - + Sort sort = new Sort("foo").and(null); assertThat(sort, hasItem(new Sort.Order("foo"))); } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/domain/UnitTestUtils.java b/spring-data-commons-core/src/test/java/org/springframework/data/domain/UnitTestUtils.java index a7f356a31..9a6330281 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/domain/UnitTestUtils.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/domain/UnitTestUtils.java @@ -2,7 +2,6 @@ package org.springframework.data.domain; import static org.junit.Assert.*; - /** * @author Oliver Gierke */ @@ -12,11 +11,9 @@ public abstract class UnitTestUtils { } - /** - * Asserts that delivered objects both equal each other as well as return - * the same hash code. - * + * Asserts that delivered objects both equal each other as well as return the same hash code. + * * @param first * @param second */ @@ -27,11 +24,9 @@ public abstract class UnitTestUtils { assertEquals(first.hashCode(), second.hashCode()); } - /** - * Asserts that both objects are not equal to each other and differ in hash - * code, too. - * + * Asserts that both objects are not equal to each other and differ in hash code, too. + * * @param first * @param second */ diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/Document.java b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/Document.java index 6947fe621..c657d05b5 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/Document.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/Document.java @@ -27,10 +27,7 @@ import org.springframework.data.annotation.Persistent; * @author Jon Brisbin */ @Retention(RetentionPolicy.RUNTIME) -@Target({ - ElementType.TYPE, - ElementType.FIELD -}) +@Target({ ElementType.TYPE, ElementType.FIELD }) @Persistent public @interface Document { } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/MappingMetadataTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/MappingMetadataTests.java index 14c552100..100794ff5 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/MappingMetadataTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/MappingMetadataTests.java @@ -43,13 +43,12 @@ public class MappingMetadataTests { ctx = new SampleMappingContext(); } - @Test public void testPojoWithId() { - + ctx.setInitialEntitySet(Collections.singleton(PersonWithId.class)); ctx.afterPropertiesSet(); - + PersistentEntity person = ctx.getPersistentEntity(PersonWithId.class); assertNotNull(person.getIdProperty()); assertEquals(String.class, person.getIdProperty().getType()); @@ -57,10 +56,10 @@ public class MappingMetadataTests { @Test public void testAssociations() { - + ctx.setInitialEntitySet(Collections.singleton(PersonWithChildren.class)); ctx.afterPropertiesSet(); - + PersistentEntity person = ctx.getPersistentEntity(PersonWithChildren.class); person.doWithAssociations(new AssociationHandler() { public void doWithAssociation(Association association) { @@ -72,30 +71,26 @@ public class MappingMetadataTests { public interface SampleProperty extends PersistentProperty { } - public class SampleMappingContext extends AbstractMappingContext, SampleProperty> { + public class SampleMappingContext extends + AbstractMappingContext, SampleProperty> { @Override - protected MutablePersistentEntity createPersistentEntity( - TypeInformation typeInformation) { + protected MutablePersistentEntity createPersistentEntity(TypeInformation typeInformation) { return new BasicPersistentEntity(typeInformation); } @Override - protected SampleProperty createPersistentProperty(Field field, - PropertyDescriptor descriptor, - MutablePersistentEntity owner, - SimpleTypeHolder simpleTypeHolder) { + protected SampleProperty createPersistentProperty(Field field, PropertyDescriptor descriptor, + MutablePersistentEntity owner, SimpleTypeHolder simpleTypeHolder) { return new SamplePropertyImpl(field, descriptor, owner, simpleTypeHolder); } } public class SamplePropertyImpl extends AnnotationBasedPersistentProperty implements SampleProperty { - public SamplePropertyImpl(Field field, - PropertyDescriptor propertyDescriptor, - PersistentEntity owner, - SimpleTypeHolder simpleTypeHolder) { + public SamplePropertyImpl(Field field, PropertyDescriptor propertyDescriptor, + PersistentEntity owner, SimpleTypeHolder simpleTypeHolder) { super(field, propertyDescriptor, owner, simpleTypeHolder); } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/SimpleTypeHolderUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/SimpleTypeHolderUnitTests.java index 23e70a985..b23db2657 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/SimpleTypeHolderUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/SimpleTypeHolderUnitTests.java @@ -35,7 +35,7 @@ public class SimpleTypeHolderUnitTests { public void rejectsNullCustomTypes() { new SimpleTypeHolder(null, false); } - + @Test(expected = IllegalArgumentException.class) public void rejectsNullOriginal() { new SimpleTypeHolder(new HashSet>(), null); @@ -49,38 +49,38 @@ public class SimpleTypeHolderUnitTests { SimpleTypeHolder holder = new SimpleTypeHolder(); holder.isSimpleType(null); } - + @Test public void addsDefaultTypes() { - + SimpleTypeHolder holder = new SimpleTypeHolder(); - + assertThat(holder.isSimpleType(String.class), is(true)); } - + @Test public void doesNotAddDefaultConvertersIfConfigured() { - + SimpleTypeHolder holder = new SimpleTypeHolder(new HashSet>(), false); - + assertThat(holder.isSimpleType(String.class), is(false)); } - + @Test public void addsCustomTypesToSimpleOnes() { - + SimpleTypeHolder holder = new SimpleTypeHolder(Collections.singleton(SimpleTypeHolder.class), true); - + assertThat(holder.isSimpleType(SimpleTypeHolder.class), is(true)); assertThat(holder.isSimpleType(SimpleTypeHolderUnitTests.class), is(false)); } - + @Test public void createsHolderFromAnotherOneCorrectly() { - + SimpleTypeHolder holder = new SimpleTypeHolder(Collections.singleton(SimpleTypeHolder.class), true); SimpleTypeHolder second = new SimpleTypeHolder(Collections.singleton(SimpleTypeHolderUnitTests.class), holder); - + assertThat(holder.isSimpleType(SimpleTypeHolder.class), is(true)); assertThat(holder.isSimpleType(SimpleTypeHolderUnitTests.class), is(false)); assertThat(second.isSimpleType(SimpleTypeHolder.class), is(true)); @@ -94,33 +94,33 @@ public class SimpleTypeHolderUnitTests { } @Test - public void considersSimpleEnumAsSimple() { - - SimpleTypeHolder holder = new SimpleTypeHolder(); - assertThat(holder.isSimpleType(SimpleEnum.FOO.getClass()), is(true)); - } - + public void considersSimpleEnumAsSimple() { + + SimpleTypeHolder holder = new SimpleTypeHolder(); + assertThat(holder.isSimpleType(SimpleEnum.FOO.getClass()), is(true)); + } + @Test public void considersComplexEnumAsSimple() { - + SimpleTypeHolder holder = new SimpleTypeHolder(); - assertThat(holder.isSimpleType(ComplexEnum.FOO.getClass()), is(true)); + assertThat(holder.isSimpleType(ComplexEnum.FOO.getClass()), is(true)); } - - enum SimpleEnum { - - FOO; - } - - enum ComplexEnum { - - FOO { + + enum SimpleEnum { + + FOO; + } + + enum ComplexEnum { + + FOO { @Override boolean method() { return false; } }; - - abstract boolean method(); - } + + abstract boolean method(); + } } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/context/AbstractMappingContextIntegrationTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/context/AbstractMappingContextIntegrationTests.java index 0fe95d4d2..db49b59f0 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/context/AbstractMappingContextIntegrationTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/context/AbstractMappingContextIntegrationTests.java @@ -52,7 +52,7 @@ public class AbstractMappingContextIntegrationTests entity = context.getPersistentEntity(Person.class); - + entity.doWithProperties(new PropertyHandler() { public void doWithPersistentProperty(T persistentProperty) { try { @@ -68,7 +68,7 @@ public class AbstractMappingContextIntegrationTests owner, final SimpleTypeHolder simpleTypeHolder) { PersistentProperty prop = mock(PersistentProperty.class); - + when(prop.getTypeInformation()).thenReturn((TypeInformation) owner.getTypeInformation()); when(prop.getName()).thenReturn(field.getName()); when(prop.getPersistentEntityType()).thenReturn(Collections.EMPTY_SET); @@ -97,7 +97,7 @@ public class AbstractMappingContextIntegrationTests path = context.getPersistentPropertyPath(PropertyPath.from("name", Person.class)); + PersistentPropertyPath path = context.getPersistentPropertyPath(PropertyPath.from("name", + Person.class)); assertThat(path, is(notNullValue())); } @@ -49,26 +50,27 @@ public class AbstractMappingContextUnitTests { } catch (MappingException e) { // expected } - + context.getPersistentEntity(Unsupported.class); } - + class Person { String name; } - + class Unsupported { - + } - - - class DummyMappingContext extends AbstractMappingContext, DummyPersistenProperty> { + + class DummyMappingContext extends + AbstractMappingContext, DummyPersistenProperty> { @Override @SuppressWarnings("unchecked") - protected BasicPersistentEntity createPersistentEntity(TypeInformation typeInformation) { + protected BasicPersistentEntity createPersistentEntity( + TypeInformation typeInformation) { return new BasicPersistentEntity((TypeInformation) typeInformation) { - + @Override public void verify() { if (holder.isSimpleType(getType()) || Unsupported.class.equals(getType())) { @@ -81,11 +83,11 @@ public class AbstractMappingContextUnitTests { @Override protected DummyPersistenProperty createPersistentProperty(final Field field, final PropertyDescriptor descriptor, final BasicPersistentEntity owner, final SimpleTypeHolder simpleTypeHolder) { - + return new DummyPersistenProperty(field, descriptor, owner, simpleTypeHolder); } } - + class DummyPersistenProperty extends AbstractPersistentProperty { public DummyPersistenProperty(Field field, PropertyDescriptor propertyDescriptor, diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/model/AbstractPersistentPropertyUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/model/AbstractPersistentPropertyUnitTests.java index 1049b1e65..e2d3306e1 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/model/AbstractPersistentPropertyUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/model/AbstractPersistentPropertyUnitTests.java @@ -21,18 +21,17 @@ import org.springframework.util.ReflectionUtils; * @author Oliver Gierke */ public class AbstractPersistentPropertyUnitTests { - + TypeInformation typeInfo; PersistentEntity entity; SimpleTypeHolder typeHolder; - + @Before public void setUp() { typeInfo = ClassTypeInformation.from(TestClassComplex.class); entity = new BasicPersistentEntity(typeInfo); typeHolder = new SimpleTypeHolder(); } - /** * @see DATACMNS-68 @@ -41,20 +40,20 @@ public class AbstractPersistentPropertyUnitTests { public void discoversComponentTypeCorrectly() throws Exception { Field field = ReflectionUtils.findField(TestClassComplex.class, "testClassSet"); - + SamplePersistentProperty property = new SamplePersistentProperty(field, null, entity, typeHolder); property.getComponentType(); } @Test public void returnsNestedEntityTypeCorrectly() { - + Field field = ReflectionUtils.findField(TestClassComplex.class, "testClassSet"); - + SamplePersistentProperty property = new SamplePersistentProperty(field, null, entity, typeHolder); assertThat(property.getPersistentEntityType().iterator().hasNext(), is(false)); } - + @SuppressWarnings("serial") class TestClassSet extends TreeSet { } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/querydsl/SimpleEntityPathResolverUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/querydsl/SimpleEntityPathResolverUnitTests.java index a8e07c644..30ee72256 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/querydsl/SimpleEntityPathResolverUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/querydsl/SimpleEntityPathResolverUnitTests.java @@ -22,24 +22,21 @@ import org.junit.Test; import com.mysema.query.annotations.QueryEntity; - /** * Unit test for {@link SimpleEntityPathResolver}. - * + * * @author Oliver Gierke */ public class SimpleEntityPathResolverUnitTests { EntityPathResolver resolver = SimpleEntityPathResolver.INSTANCE; - @Test public void createsRepositoryFromDomainClassCorrectly() throws Exception { assertThat((QUser) resolver.createPath(User.class), isA(QUser.class)); } - @Test public void resolvesEntityPathForInnerClassCorrectly() throws Exception { @@ -47,10 +44,8 @@ public class SimpleEntityPathResolverUnitTests { isA(QSimpleEntityPathResolverUnitTests_NamedUser.class)); } - @Test(expected = IllegalArgumentException.class) - public void rejectsClassWithoutQueryClassConfrmingToTheNamingScheme() - throws Exception { + public void rejectsClassWithoutQueryClassConfrmingToTheNamingScheme() throws Exception { resolver.createPath(QSimpleEntityPathResolverUnitTests_Sample.class); } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/CdiRepositoryBeanUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/CdiRepositoryBeanUnitTests.java index 61709b55f..87343efcc 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/CdiRepositoryBeanUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/CdiRepositoryBeanUnitTests.java @@ -61,13 +61,13 @@ public class CdiRepositoryBeanUnitTests { public void voidRejectsNullBeanManager() { new DummyCdiRepositoryBean(NO_ANNOTATIONS, SampleRepository.class, null); } - + @Test public void returnsBasicMetadata() { - - DummyCdiRepositoryBean bean = new DummyCdiRepositoryBean( - NO_ANNOTATIONS, SampleRepository.class, beanManager); - + + DummyCdiRepositoryBean bean = new DummyCdiRepositoryBean(NO_ANNOTATIONS, + SampleRepository.class, beanManager); + assertThat(bean.getBeanClass(), is(typeCompatibleWith(SampleRepository.class))); assertThat(bean.getName(), is(SampleRepository.class.getName())); assertThat(bean.isNullable(), is(false)); @@ -77,20 +77,20 @@ public class CdiRepositoryBeanUnitTests { @SuppressWarnings("unchecked") public void returnsAllImplementedTypes() { - DummyCdiRepositoryBean bean = new DummyCdiRepositoryBean( - NO_ANNOTATIONS, SampleRepository.class, beanManager); - + DummyCdiRepositoryBean bean = new DummyCdiRepositoryBean(NO_ANNOTATIONS, + SampleRepository.class, beanManager); + Set types = bean.getTypes(); assertThat(types.size(), is(2)); assertThat(types.containsAll(Arrays.asList(SampleRepository.class, Repository.class)), is(true)); } - + @Test public void detectsStereotypes() { - + DummyCdiRepositoryBean bean = new DummyCdiRepositoryBean( NO_ANNOTATIONS, StereotypedSampleRepository.class, beanManager); - + Set> stereotypes = bean.getStereotypes(); assertThat(stereotypes.size(), is(1)); assertThat(stereotypes, hasItem(StereotypeAnnotation.class)); @@ -115,9 +115,9 @@ public class CdiRepositoryBeanUnitTests { static interface SampleRepository extends Repository { } - + @StereotypeAnnotation static interface StereotypedSampleRepository { - + } } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/CdiRepositoryExtensionSupportIntegrationTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/CdiRepositoryExtensionSupportIntegrationTests.java index 37ea8f616..5c37cf5ae 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/CdiRepositoryExtensionSupportIntegrationTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/CdiRepositoryExtensionSupportIntegrationTests.java @@ -29,7 +29,7 @@ public abstract class CdiRepositoryExtensionSupportIntegrationTests { @Test public void createsSpringDataRepositoryBean() { - + assertThat(getBean(SampleRepository.class), is(notNullValue())); RepositoryClient client = getBean(RepositoryClient.class); diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/WebbeansCdiRepositoryExtensionSupportIntegrationTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/WebbeansCdiRepositoryExtensionSupportIntegrationTests.java index e61c8858d..4bf8596c1 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/WebbeansCdiRepositoryExtensionSupportIntegrationTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/cdi/WebbeansCdiRepositoryExtensionSupportIntegrationTests.java @@ -25,7 +25,8 @@ import org.junit.BeforeClass; * * @author Oliver Gierke */ -public class WebbeansCdiRepositoryExtensionSupportIntegrationTests extends CdiRepositoryExtensionSupportIntegrationTests { +public class WebbeansCdiRepositoryExtensionSupportIntegrationTests extends + CdiRepositoryExtensionSupportIntegrationTests { static CdiTestContainer container; diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/config/RepositoryComponentProviderUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/config/RepositoryComponentProviderUnitTests.java index 4af944765..9c3bd4b87 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/config/RepositoryComponentProviderUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/config/RepositoryComponentProviderUnitTests.java @@ -28,17 +28,17 @@ import org.springframework.data.repository.sample.SampleAnnotatedRepository; /** * Unit tests for {@link RepositoryComponentProvider}. - * + * * @author Oliver Gierke */ public class RepositoryComponentProviderUnitTests { @Test public void findsAnnotatedRepositoryInterface() { - + RepositoryComponentProvider provider = new RepositoryComponentProvider(Repository.class); Set components = provider.findCandidateComponents("org.springframework.data.repository.sample"); - + assertThat(components.size(), is(1)); assertThat(components.iterator().next().getBeanClassName(), is(SampleAnnotatedRepository.class.getName())); } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/config/TypeFilterParserUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/config/TypeFilterParserUnitTests.java index 89dc2626a..426f4c624 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/config/TypeFilterParserUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/config/TypeFilterParserUnitTests.java @@ -36,10 +36,9 @@ import org.springframework.util.xml.DomUtils; import org.w3c.dom.Element; import org.xml.sax.SAXException; - /** * Unit test for {@link TypeFilterParser}. - * + * * @author Oliver Gierke */ @RunWith(MockitoJUnitRunner.class) @@ -57,51 +56,36 @@ public class TypeFilterParserUnitTests { @Mock private ClassPathScanningCandidateComponentProvider scanner; - @Before - public void setUp() throws SAXException, IOException, - ParserConfigurationException { + public void setUp() throws SAXException, IOException, ParserConfigurationException { parser = new TypeFilterParser(classLoader, context); - Resource sampleXmlFile = - new ClassPathResource("type-filter-test.xml", - TypeFilterParserUnitTests.class); + Resource sampleXmlFile = new ClassPathResource("type-filter-test.xml", TypeFilterParserUnitTests.class); DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware(true); - documentElement = - factory.newDocumentBuilder() - .parse(sampleXmlFile.getInputStream()) - .getDocumentElement(); + documentElement = factory.newDocumentBuilder().parse(sampleXmlFile.getInputStream()).getDocumentElement(); } - @Test public void parsesIncludesCorrectly() throws Exception { - Element element = - DomUtils.getChildElementByTagName(documentElement, - "firstSample"); + Element element = DomUtils.getChildElementByTagName(documentElement, "firstSample"); parser.parseFilters(element, scanner); - verify(scanner, atLeastOnce()).addIncludeFilter( - isA(AssignableTypeFilter.class)); + verify(scanner, atLeastOnce()).addIncludeFilter(isA(AssignableTypeFilter.class)); } - @Test public void parsesExcludesCorrectly() throws Exception { - Element element = - DomUtils.getChildElementByTagName(documentElement, - "secondSample"); + Element element = DomUtils.getChildElementByTagName(documentElement, "secondSample"); parser.parseFilters(element, scanner); - verify(scanner, atLeastOnce()).addExcludeFilter( - isA(AssignableTypeFilter.class)); + verify(scanner, atLeastOnce()).addExcludeFilter(isA(AssignableTypeFilter.class)); } } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AbstractEntityInformationUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AbstractEntityInformationUnitTests.java index 3f602a7fb..238033386 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AbstractEntityInformationUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AbstractEntityInformationUnitTests.java @@ -24,10 +24,9 @@ import org.junit.Test; import org.springframework.data.repository.core.EntityInformation; import org.springframework.data.repository.core.support.AbstractEntityInformation; - /** * Unit tests for {@link AbstractEntityInformation}. - * + * * @author Oliver Gierke */ public class AbstractEntityInformationUnitTests { @@ -38,25 +37,21 @@ public class AbstractEntityInformationUnitTests { new DummyAbstractEntityInformation(null); } - @Test public void considersEntityNewIfGetIdReturnsNull() throws Exception { - EntityInformation metadata = - new DummyAbstractEntityInformation(Object.class); + EntityInformation metadata = new DummyAbstractEntityInformation(Object.class); assertThat(metadata.isNew(null), is(true)); assertThat(metadata.isNew(new Object()), is(false)); } - private static class DummyAbstractEntityInformation extends - AbstractEntityInformation { + private static class DummyAbstractEntityInformation extends AbstractEntityInformation { public DummyAbstractEntityInformation(Class domainClass) { super(domainClass); } - /* * (non-Javadoc) * diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadataUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadataUnitTests.java index 70850daf6..10c0d2c19 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadataUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadataUnitTests.java @@ -72,7 +72,7 @@ public class AbstractRepositoryMetadataUnitTests { @Test public void handlesGenericTypeInReturnedCollectionCorrectly() throws SecurityException, NoSuchMethodException { - + RepositoryMetadata metadata = new DummyRepositoryMetadata(ExtendingRepository.class); Method method = ExtendingRepository.class.getMethod("anotherMethod"); assertThat(metadata.getReturnedDomainClass(method), is(typeCompatibleWith(Map.class))); diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AnnotationRepositoryMetadataUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AnnotationRepositoryMetadataUnitTests.java index 53bb1b1ec..9e2cbf350 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AnnotationRepositoryMetadataUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/AnnotationRepositoryMetadataUnitTests.java @@ -23,25 +23,24 @@ import org.springframework.data.repository.core.RepositoryMetadata; import org.springframework.data.repository.core.support.AnnotationRepositoryMetadata; import org.springframework.data.repository.core.support.DefaultRepositoryMetadata; - /** * Unit tests for {@link DefaultRepositoryMetadata}. - * + * * @author Oliver Gierke */ -public class AnnotationRepositoryMetadataUnitTests { - +public class AnnotationRepositoryMetadataUnitTests { + @Test public void handlesRepositoryProxyAnnotationCorrectly() { - + RepositoryMetadata metadata = new AnnotationRepositoryMetadata(AnnotatedRepository.class); assertEquals(User.class, metadata.getDomainClass()); assertEquals(Integer.class, metadata.getIdClass()); } - + @Test(expected = IllegalArgumentException.class) public void preventsUnannotatedInterface() { - + new AnnotationRepositoryMetadata(UnannotatedRepository.class); } @@ -50,7 +49,6 @@ public class AnnotationRepositoryMetadataUnitTests { private String firstname; - public String getAddress() { return null; @@ -59,10 +57,10 @@ public class AnnotationRepositoryMetadataUnitTests { @RepositoryDefinition(domainClass = User.class, idClass = Integer.class) interface AnnotatedRepository { - + } - + interface UnannotatedRepository { - + } } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/CustomAnnotationTransactionAttributeSourceUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/CustomAnnotationTransactionAttributeSourceUnitTests.java index cf564856b..0fe4fe2ec 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/CustomAnnotationTransactionAttributeSourceUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/CustomAnnotationTransactionAttributeSourceUnitTests.java @@ -37,7 +37,7 @@ public class CustomAnnotationTransactionAttributeSourceUnitTests { CustomAnnotationTransactionAttributeSource source = new TransactionalRepositoryProxyPostProcessor.CustomAnnotationTransactionAttributeSource(); TransactionAttribute attribute = source.getTransactionAttribute(Bar.class.getMethod("bar", Object.class), - FooImpl.class); + FooImpl.class); assertThat(attribute.isReadOnly(), is(false)); attribute = source.getTransactionAttribute(Bar.class.getMethod("foo"), FooImpl.class); @@ -76,7 +76,7 @@ public class CustomAnnotationTransactionAttributeSourceUnitTests { /** * Interface reconfiguring transactions. - * + * * @author Oliver Gierke */ interface Bar extends Foo { diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryInformationUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryInformationUnitTests.java index 60caa950c..f3ecbccf7 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryInformationUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryInformationUnitTests.java @@ -81,21 +81,21 @@ public class DefaultRepositoryInformationUnitTests { @Test public void discoversIntermediateMethodsAsBackingMethods() throws NoSuchMethodException, SecurityException { - + DefaultRepositoryMetadata metadata = new DefaultRepositoryMetadata(CustomRepository.class); DefaultRepositoryInformation information = new DefaultRepositoryInformation(metadata, PagingAndSortingRepository.class, null); Method method = CustomRepository.class.getMethod("findAll", Pageable.class); assertThat(information.isBaseClassMethod(method), is(true)); - + method = getMethodFrom(CustomRepository.class, "exists"); assertThat(information.isBaseClassMethod(method), is(true)); - + Matcher> empty = iterableWithSize(0); assertThat(information.getQueryMethods(), is(empty)); } - + private Method getMethodFrom(Class type, String name) { for (Method method : type.getMethods()) { if (method.getName().equals(name)) { diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryMetadataUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryMetadataUnitTests.java index 224ed0322..e5facbe18 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryMetadataUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryMetadataUnitTests.java @@ -27,66 +27,57 @@ import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.core.RepositoryMetadata; import org.springframework.data.repository.util.ClassUtils; - /** * Unit tests for {@link DefaultRepositoryMetadata}. - * + * * @author Oliver Gierke */ public class DefaultRepositoryMetadataUnitTests { @Test(expected = IllegalArgumentException.class) public void preventsNullRepositoryInterface() { - + new DefaultRepositoryMetadata(null); } - + @Test(expected = IllegalArgumentException.class) public void rejectsNonInterface() { new DefaultRepositoryMetadata(Object.class); } - + @Test(expected = IllegalArgumentException.class) public void rejectsNonRepositoryInterface() { new DefaultRepositoryMetadata(Collection.class); } - + @Test public void looksUpDomainClassCorrectly() throws Exception { - RepositoryMetadata metadata = - new DefaultRepositoryMetadata(UserRepository.class); + RepositoryMetadata metadata = new DefaultRepositoryMetadata(UserRepository.class); assertEquals(User.class, metadata.getDomainClass()); metadata = new DefaultRepositoryMetadata(SomeDao.class); assertEquals(User.class, metadata.getDomainClass()); } - @Test public void findsDomainClassOnExtensionOfDaoInterface() throws Exception { - RepositoryMetadata metadata = - new DefaultRepositoryMetadata( - ExtensionOfUserCustomExtendedDao.class); + RepositoryMetadata metadata = new DefaultRepositoryMetadata(ExtensionOfUserCustomExtendedDao.class); assertEquals(User.class, metadata.getDomainClass()); } - @Test public void detectsParameterizedEntitiesCorrectly() { - RepositoryMetadata metadata = - new DefaultRepositoryMetadata(GenericEntityRepository.class); + RepositoryMetadata metadata = new DefaultRepositoryMetadata(GenericEntityRepository.class); assertEquals(GenericEntity.class, metadata.getDomainClass()); } - @Test public void looksUpIdClassCorrectly() throws Exception { - RepositoryMetadata metadata = - new DefaultRepositoryMetadata(UserRepository.class); + RepositoryMetadata metadata = new DefaultRepositoryMetadata(UserRepository.class); assertEquals(Integer.class, metadata.getIdClass()); } @@ -96,7 +87,6 @@ public class DefaultRepositoryMetadataUnitTests { private String firstname; - public String getAddress() { return null; @@ -110,12 +100,10 @@ public class DefaultRepositoryMetadataUnitTests { /** * Sample interface to serve two purposes: *
    - *
  1. Check that {@link ClassUtils#getDomainClass(Class)} skips non - * {@link GenericDao} interfaces
    2. - *
  2. Check that {@link ClassUtils#getDomainClass(Class)} traverses - * interface hierarchy
    3. + *
  3. Check that {@link ClassUtils#getDomainClass(Class)} skips non {@link GenericDao} interfaces
    4. + *
  4. Check that {@link ClassUtils#getDomainClass(Class)} traverses interface hierarchy
    5. *
- * + * * @author Oliver Gierke */ private interface SomeDao extends Serializable, UserRepository { @@ -125,21 +113,18 @@ public class DefaultRepositoryMetadataUnitTests { /** * Sample interface to test recursive lookup of domain class. - * + * * @author Oliver Gierke */ - static interface ExtensionOfUserCustomExtendedDao extends - UserCustomExtendedRepository { + static interface ExtensionOfUserCustomExtendedDao extends UserCustomExtendedRepository { } - static interface UserCustomExtendedRepository extends - CrudRepository { + static interface UserCustomExtendedRepository extends CrudRepository { } - static abstract class DummyGenericRepositorySupport - implements CrudRepository { + static abstract class DummyGenericRepositorySupport implements CrudRepository { public T findOne(ID id) { @@ -149,14 +134,13 @@ public class DefaultRepositoryMetadataUnitTests { /** * Helper class to reproduce #256. - * + * * @author Oliver Gierke */ static class GenericEntity { } - static interface GenericEntityRepository extends - CrudRepository, Long> { + static interface GenericEntityRepository extends CrudRepository, Long> { } } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/PersistableEntityInformationUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/PersistableEntityInformationUnitTests.java index 26402fec1..3956788d8 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/PersistableEntityInformationUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/PersistableEntityInformationUnitTests.java @@ -26,23 +26,20 @@ import org.mockito.runners.MockitoJUnitRunner; import org.springframework.data.domain.Persistable; import org.springframework.data.repository.core.support.PersistableEntityInformation; - /** * Unit tests for {@link PersistableEntityMetadata}. - * + * * @author Oliver Gierke */ @RunWith(MockitoJUnitRunner.class) public class PersistableEntityInformationUnitTests { - @SuppressWarnings({"rawtypes", "unchecked"}) - static final PersistableEntityInformation metadata = - new PersistableEntityInformation(Persistable.class); + @SuppressWarnings({ "rawtypes", "unchecked" }) + static final PersistableEntityInformation metadata = new PersistableEntityInformation(Persistable.class); @Mock Persistable persistable; - @Test @SuppressWarnings("unchecked") public void usesPersistablesGetId() throws Exception { @@ -53,7 +50,6 @@ public class PersistableEntityInformationUnitTests { assertEquals(3L, metadata.getId(persistable)); } - @Test @SuppressWarnings("unchecked") public void usesPersistablesIsNew() throws Exception { @@ -63,13 +59,11 @@ public class PersistableEntityInformationUnitTests { assertThat(metadata.isNew(persistable), is(false)); } - @Test public void returnsGivenClassAsEntityType() throws Exception { - PersistableEntityInformation info = - new PersistableEntityInformation( - PersistableEntity.class); + PersistableEntityInformation info = new PersistableEntityInformation( + PersistableEntity.class); assertEquals(PersistableEntity.class, info.getJavaType()); } @@ -82,7 +76,6 @@ public class PersistableEntityInformationUnitTests { return null; } - public boolean isNew() { return false; diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/RepositoryInterfaceAwareBeanPostProcessorUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/RepositoryInterfaceAwareBeanPostProcessorUnitTests.java index 81bdaa8e6..d8cfdbeee 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/RepositoryInterfaceAwareBeanPostProcessorUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/RepositoryInterfaceAwareBeanPostProcessorUnitTests.java @@ -32,17 +32,15 @@ import org.springframework.data.repository.Repository; import org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport; import org.springframework.data.repository.core.support.RepositoryInterfaceAwareBeanPostProcessor; - /** * Unit tests for {@link RepositoryInterfaceAwareBeanPostProcessor}. - * + * * @author Oliver Gierke */ @RunWith(MockitoJUnitRunner.class) public class RepositoryInterfaceAwareBeanPostProcessorUnitTests { - private static final Class FACTORY_CLASS = - RepositoryFactoryBeanSupport.class; + private static final Class FACTORY_CLASS = RepositoryFactoryBeanSupport.class; private static final String BEAN_NAME = "foo"; private static final String DAO_INTERFACE_PROPERTY = "repositoryInterface"; @@ -52,33 +50,26 @@ public class RepositoryInterfaceAwareBeanPostProcessorUnitTests { private ConfigurableListableBeanFactory beanFactory; private BeanDefinition beanDefinition; - @Before public void setUp() { - BeanDefinitionBuilder builder = - BeanDefinitionBuilder - .rootBeanDefinition(FACTORY_CLASS) - .addPropertyValue(DAO_INTERFACE_PROPERTY, UserDao.class); + BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(FACTORY_CLASS).addPropertyValue( + DAO_INTERFACE_PROPERTY, UserDao.class); this.beanDefinition = builder.getBeanDefinition(); - when(beanFactory.getBeanDefinition(BEAN_NAME)).thenReturn( - beanDefinition); + when(beanFactory.getBeanDefinition(BEAN_NAME)).thenReturn(beanDefinition); processor = new RepositoryInterfaceAwareBeanPostProcessor(); } - @Test public void returnsDaoInterfaceClassForFactoryBean() throws Exception { processor.setBeanFactory(beanFactory); - assertEquals(UserDao.class, - processor.predictBeanType(FACTORY_CLASS, BEAN_NAME)); + assertEquals(UserDao.class, processor.predictBeanType(FACTORY_CLASS, BEAN_NAME)); } - @Test public void doesNotResolveInterfaceForNonFactoryClasses() throws Exception { @@ -86,22 +77,17 @@ public class RepositoryInterfaceAwareBeanPostProcessorUnitTests { assertNotTypeDetected(BeanFactory.class); } - @Test public void doesNotResolveInterfaceForUnloadableClass() throws Exception { - BeanDefinitionBuilder builder = - BeanDefinitionBuilder.rootBeanDefinition(FACTORY_CLASS) - .addPropertyValue(DAO_INTERFACE_PROPERTY, - "com.acme.Foo"); + BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(FACTORY_CLASS).addPropertyValue( + DAO_INTERFACE_PROPERTY, "com.acme.Foo"); - when(beanFactory.getBeanDefinition(BEAN_NAME)).thenReturn( - builder.getBeanDefinition()); + when(beanFactory.getBeanDefinition(BEAN_NAME)).thenReturn(builder.getBeanDefinition()); assertNotTypeDetected(FACTORY_CLASS); } - @Test public void doesNotResolveTypeForPlainBeanFactory() throws Exception { @@ -111,11 +97,9 @@ public class RepositoryInterfaceAwareBeanPostProcessorUnitTests { assertNotTypeDetected(FACTORY_CLASS); } - private void assertNotTypeDetected(Class beanClass) { - assertThat(processor.predictBeanType(beanClass, BEAN_NAME), - is(nullValue())); + assertThat(processor.predictBeanType(beanClass, BEAN_NAME), is(nullValue())); } private class User { diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/TransactionRepositoryProxyPostProcessorUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/TransactionRepositoryProxyPostProcessorUnitTests.java index 483f84c73..d167d7c06 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/TransactionRepositoryProxyPostProcessorUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/core/support/TransactionRepositoryProxyPostProcessorUnitTests.java @@ -36,10 +36,9 @@ import org.springframework.data.repository.core.support.RepositoryProxyPostProce import org.springframework.data.repository.core.support.TransactionalRepositoryProxyPostProcessor; import org.springframework.transaction.interceptor.TransactionInterceptor; - /** * Unit test for {@link TransactionalRepositoryProxyPostProcessor}. - * + * * @author Oliver Gierke */ @RunWith(MockitoJUnitRunner.class) @@ -52,44 +51,35 @@ public class TransactionRepositoryProxyPostProcessorUnitTests { @Mock ProxyFactory proxyFactory; - @Before public void setUp() { - Map beans = - new HashMap(); + Map beans = new HashMap(); beans.put("foo", mock(PersistenceExceptionTranslator.class)); - when( - beanFactory.getBeansOfType( - eq(PersistenceExceptionTranslator.class), anyBoolean(), - anyBoolean())).thenReturn(beans); + when(beanFactory.getBeansOfType(eq(PersistenceExceptionTranslator.class), anyBoolean(), anyBoolean())).thenReturn( + beans); } - @Test(expected = IllegalArgumentException.class) public void rejectsNullBeanFactory() throws Exception { new TransactionalRepositoryProxyPostProcessor(null, "transactionManager"); } - @Test(expected = IllegalArgumentException.class) public void rejectsNullTxManagerName() throws Exception { new TransactionalRepositoryProxyPostProcessor(beanFactory, null); } - @Test public void setsUpBasicInstance() throws Exception { - RepositoryProxyPostProcessor postProcessor = - new TransactionalRepositoryProxyPostProcessor(beanFactory, "txManager"); + RepositoryProxyPostProcessor postProcessor = new TransactionalRepositoryProxyPostProcessor(beanFactory, "txManager"); postProcessor.postProcess(proxyFactory); - verify(proxyFactory).addAdvice( - isA(PersistenceExceptionTranslationInterceptor.class)); + verify(proxyFactory).addAdvice(isA(PersistenceExceptionTranslationInterceptor.class)); verify(proxyFactory).addAdvice(isA(TransactionInterceptor.class)); } } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java index d6221883d..e205466bf 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java @@ -25,62 +25,49 @@ import org.junit.Test; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; - /** * Unit test for {@link Parameters}. - * + * * @author Oliver Gierke */ public class ParametersUnitTests { private Method valid; - @Before public void setUp() throws SecurityException, NoSuchMethodException { valid = SampleDao.class.getMethod("valid", String.class); } - @Test public void checksValidMethodCorrectly() throws Exception { - Method validWithPageable = - SampleDao.class.getMethod("validWithPageable", String.class, - Pageable.class); - Method validWithSort = - SampleDao.class.getMethod("validWithSort", String.class, - Sort.class); + Method validWithPageable = SampleDao.class.getMethod("validWithPageable", String.class, Pageable.class); + Method validWithSort = SampleDao.class.getMethod("validWithSort", String.class, Sort.class); new Parameters(valid); new Parameters(validWithPageable); new Parameters(validWithSort); } - @Test(expected = IllegalArgumentException.class) public void rejectsInvalidMethodWithParamMissing() throws Exception { - Method method = - SampleDao.class.getMethod("invalidParamMissing", String.class, - String.class); + Method method = SampleDao.class.getMethod("invalidParamMissing", String.class, String.class); new Parameters(method); } - @Test(expected = IllegalArgumentException.class) public void rejectsNullMethod() throws Exception { new Parameters(null); } - @Test public void detectsNamedParameterCorrectly() throws Exception { - Parameters parameters = - getParametersFor("validWithSort", String.class, Sort.class); + Parameters parameters = getParametersFor("validWithSort", String.class, Sort.class); Parameter parameter = parameters.getParameter(0); @@ -93,20 +80,15 @@ public class ParametersUnitTests { assertThat(parameter.isSpecialParameter(), is(true)); } - @Test public void calculatesPlaceholderPositionCorrectly() throws Exception { - Method method = - SampleDao.class.getMethod("validWithSortFirst", Sort.class, - String.class); + Method method = SampleDao.class.getMethod("validWithSortFirst", Sort.class, String.class); Parameters parameters = new Parameters(method); assertThat(parameters.getBindableParameter(0).getIndex(), is(1)); - method = - SampleDao.class.getMethod("validWithSortInBetween", - String.class, Sort.class, String.class); + method = SampleDao.class.getMethod("validWithSortInBetween", String.class, Sort.class, String.class); parameters = new Parameters(method); @@ -114,29 +96,26 @@ public class ParametersUnitTests { assertThat(parameters.getBindableParameter(1).getIndex(), is(2)); } - @Test public void detectsEmptyParameterListCorrectly() throws Exception { Parameters parameters = getParametersFor("emptyParameters"); assertThat(parameters.hasParameterAt(0), is(false)); } - + @Test public void detectsPageableParameter() throws Exception { Parameters parameters = getParametersFor("validWithPageable", String.class, Pageable.class); assertThat(parameters.getPageableIndex(), is(1)); } - + @Test public void detectsSortParameter() throws Exception { Parameters parameters = getParametersFor("validWithSort", String.class, Sort.class); assertThat(parameters.getSortIndex(), is(1)); } - - private Parameters getParametersFor(String methodName, - Class... parameterTypes) throws SecurityException, + private Parameters getParametersFor(String methodName, Class... parameterTypes) throws SecurityException, NoSuchMethodException { Method method = SampleDao.class.getMethod(methodName, parameterTypes); @@ -152,24 +131,16 @@ public class ParametersUnitTests { User valid(@Param("username") String username); + User invalidParamMissing(@Param("username") String username, String lastname); - User invalidParamMissing(@Param("username") String username, - String lastname); - - - User validWithPageable(@Param("username") String username, - Pageable pageable); - + User validWithPageable(@Param("username") String username, Pageable pageable); User validWithSort(@Param("username") String username, Sort sort); - User validWithSortFirst(Sort sort, String username); - User validWithSortInBetween(String firstname, Sort sort, String lastname); - User emptyParameters(); } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/QueryMethodUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/QueryMethodUnitTests.java index ac11c4d21..f77f462ff 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/QueryMethodUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/QueryMethodUnitTests.java @@ -57,14 +57,14 @@ public class QueryMethodUnitTests { Method method = SampleRepository.class.getMethod("findByUsername", String.class); new QueryMethod(method, metadata); } - + @Test public void considersIterableMethodForCollectionQuery() throws Exception { Method method = SampleRepository.class.getMethod("sampleMethod"); QueryMethod queryMethod = new QueryMethod(method, metadata); assertThat(queryMethod.isCollectionQuery(), is(true)); } - + @Test public void doesNotConsiderPageMethodCollectionQuery() throws Exception { Method method = SampleRepository.class.getMethod("anotherSampleMethod", Pageable.class); @@ -79,8 +79,9 @@ public class QueryMethodUnitTests { Page pagingMethodWithoutPageable(); String findByUsername(String username); - + Iterable sampleMethod(); + Page anotherSampleMethod(Pageable pageable); } } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/SimpleParameterAccessorUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/SimpleParameterAccessorUnitTests.java index e3e6182b9..52c577e99 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/SimpleParameterAccessorUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/SimpleParameterAccessorUnitTests.java @@ -24,108 +24,85 @@ import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; - /** * Unit tests for {@link ParametersParameterAccessor}. - * + * * @author Oliver Gierke */ public class SimpleParameterAccessorUnitTests { Parameters parameters, sortParameters, pageableParameters; - @Before public void setUp() throws SecurityException, NoSuchMethodException { - parameters = - new Parameters(Sample.class.getMethod("sample", String.class)); - sortParameters = - new Parameters(Sample.class.getMethod("sample1", String.class, - Sort.class)); - pageableParameters = - new Parameters(Sample.class.getMethod("sample2", String.class, - Pageable.class)); + parameters = new Parameters(Sample.class.getMethod("sample", String.class)); + sortParameters = new Parameters(Sample.class.getMethod("sample1", String.class, Sort.class)); + pageableParameters = new Parameters(Sample.class.getMethod("sample2", String.class, Pageable.class)); } - @Test public void testname() throws Exception { - new ParametersParameterAccessor(parameters, new Object[]{"test"}); + new ParametersParameterAccessor(parameters, new Object[] { "test" }); } - @Test(expected = IllegalArgumentException.class) public void rejectsNullParameters() throws Exception { new ParametersParameterAccessor(null, new Object[0]); } - @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"}); + new ParametersParameterAccessor(parameters, new Object[] { "test", "test" }); } - @Test public void returnsNullForPageableAndSortIfNoneAvailable() throws Exception { - ParameterAccessor accessor = - new ParametersParameterAccessor(parameters, new Object[]{"test"}); + ParameterAccessor accessor = new ParametersParameterAccessor(parameters, new Object[] { "test" }); assertThat(accessor.getPageable(), is(nullValue())); assertThat(accessor.getSort(), is(nullValue())); } - @Test public void returnsSortIfAvailable() { Sort sort = new Sort("foo"); - ParameterAccessor accessor = - new ParametersParameterAccessor(sortParameters, new Object[]{ - "test", sort}); + ParameterAccessor accessor = new ParametersParameterAccessor(sortParameters, new Object[] { "test", sort }); assertThat(accessor.getSort(), is(sort)); assertThat(accessor.getPageable(), is(nullValue())); } - @Test public void returnsPageableIfAvailable() { Pageable pageable = new PageRequest(0, 10); - ParameterAccessor accessor = - new ParametersParameterAccessor(pageableParameters, new Object[]{ - "test", pageable}); + ParameterAccessor accessor = new ParametersParameterAccessor(pageableParameters, new Object[] { "test", pageable }); assertThat(accessor.getPageable(), is(pageable)); assertThat(accessor.getSort(), is(nullValue())); } - @Test public void returnsSortFromPageableIfAvailable() throws Exception { Sort sort = new Sort("foo"); Pageable pageable = new PageRequest(0, 10, sort); - ParameterAccessor accessor = - new ParametersParameterAccessor(pageableParameters, new Object[]{ - "test", pageable}); + ParameterAccessor accessor = new ParametersParameterAccessor(pageableParameters, new Object[] { "test", pageable }); assertThat(accessor.getPageable(), is(pageable)); assertThat(accessor.getSort(), is(sort)); } @@ -134,10 +111,8 @@ public class SimpleParameterAccessorUnitTests { void sample(String firstname); - void sample1(String firstname, Sort sort); - void sample2(String firstname, Pageable pageable); } } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/parser/OrderBySourceUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/parser/OrderBySourceUnitTests.java index 4e1c03e89..7bd486093 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/parser/OrderBySourceUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/query/parser/OrderBySourceUnitTests.java @@ -23,10 +23,9 @@ import org.junit.Test; import org.springframework.data.domain.Sort; import org.springframework.data.domain.Sort.Order; - /** * Unit test for {@link OrderBySource}. - * + * * @author Oliver Gierke */ public class OrderBySourceUnitTests { @@ -34,36 +33,28 @@ public class OrderBySourceUnitTests { @Test public void handlesSingleDirectionAndPropertyCorrectly() throws Exception { - assertThat(new OrderBySource("UsernameDesc").toSort(), is(new Sort( - DESC, "username"))); + assertThat(new OrderBySource("UsernameDesc").toSort(), is(new Sort(DESC, "username"))); } - @Test public void handlesCamelCasePropertyCorrecty() throws Exception { - assertThat(new OrderBySource("LastnameUsernameDesc").toSort(), - is(new Sort(DESC, "lastnameUsername"))); + assertThat(new OrderBySource("LastnameUsernameDesc").toSort(), is(new Sort(DESC, "lastnameUsername"))); } - @Test public void handlesMultipleDirectionsCorrectly() throws Exception { - OrderBySource orderBySource = - new OrderBySource("LastnameAscUsernameDesc"); - assertThat(orderBySource.toSort(), is(new Sort(new Order(ASC, - "lastname"), new Order(DESC, "username")))); + OrderBySource orderBySource = new OrderBySource("LastnameAscUsernameDesc"); + assertThat(orderBySource.toSort(), is(new Sort(new Order(ASC, "lastname"), new Order(DESC, "username")))); } - @Test(expected = IllegalArgumentException.class) public void rejectsMissingProperty() throws Exception { new OrderBySource("Desc"); } - @Test public void usesNestedPropertyCorrectly() throws Exception { diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/sample/SampleAnnotatedRepository.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/sample/SampleAnnotatedRepository.java index beb36e53a..37d897b8a 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/sample/SampleAnnotatedRepository.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/sample/SampleAnnotatedRepository.java @@ -21,7 +21,7 @@ import org.springframework.data.repository.RepositoryDefinition; /** * Sample interface for annotation based repository declaration. - * + * * @author Oliver Gierke */ @RepositoryDefinition(domainClass = Object.class, idClass = Serializable.class) diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassConverterUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassConverterUnitTests.java index 3df6e0475..9d489d954 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassConverterUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassConverterUnitTests.java @@ -39,10 +39,9 @@ import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.core.EntityInformation; import org.springframework.data.repository.core.support.RepositoryFactoryInformation; - /** * Unit test for {@link DomainClassConverter}. - * + * * @author Oliver Gierke */ @RunWith(MockitoJUnitRunner.class) @@ -69,9 +68,8 @@ public class DomainClassConverterUnitTests { @Mock RepositoryFactoryInformation provider; - @Before - @SuppressWarnings({"unchecked", "rawtypes"}) + @SuppressWarnings({ "unchecked", "rawtypes" }) public void setUp() { converter = new DomainClassConverter(service); @@ -82,16 +80,13 @@ public class DomainClassConverterUnitTests { Map map = getBeanAsMap(repository); when(context.getBeansOfType(UserRepository.class)).thenReturn(map); - when(context.getBeansOfType(RepositoryFactoryInformation.class)) - .thenReturn(providers); + when(context.getBeansOfType(RepositoryFactoryInformation.class)).thenReturn(providers); when(provider.getEntityInformation()).thenReturn(information); - when(provider.getRepositoryInterface()).thenReturn( - (Class) UserRepository.class); + when(provider.getRepositoryInterface()).thenReturn((Class) UserRepository.class); when(information.getJavaType()).thenReturn(User.class); when(information.getIdType()).thenReturn(Long.class); } - @Test public void matchFailsIfNoDaoAvailable() throws Exception { @@ -99,7 +94,6 @@ public class DomainClassConverterUnitTests { assertMatches(false); } - @Test public void matchesIfConversionInBetweenIsPossible() throws Exception { @@ -111,10 +105,8 @@ public class DomainClassConverterUnitTests { assertMatches(true); } - @Test - public void matchFailsIfNoIntermediateConversionIsPossible() - throws Exception { + public void matchFailsIfNoIntermediateConversionIsPossible() throws Exception { letContextContain(provider); converter.setApplicationContext(context); @@ -124,14 +116,11 @@ public class DomainClassConverterUnitTests { assertMatches(false); } - private void assertMatches(boolean matchExpected) { - assertThat(converter.matches(sourceDescriptor, targetDescriptor), - is(matchExpected)); + assertThat(converter.matches(sourceDescriptor, targetDescriptor), is(matchExpected)); } - @Test public void convertsStringToUserCorrectly() throws Exception { @@ -142,21 +131,17 @@ public class DomainClassConverterUnitTests { when(service.convert(anyString(), eq(Long.class))).thenReturn(1L); when(repository.findOne(1L)).thenReturn(USER); - Object user = - converter.convert("1", sourceDescriptor, targetDescriptor); + Object user = converter.convert("1", sourceDescriptor, targetDescriptor); assertThat(user, is(instanceOf(User.class))); assertThat(user, is((Object) USER)); } - private void letContextContain(Object bean) { Map beanMap = getBeanAsMap(bean); - when(context.getBeansOfType(argThat(is(subtypeOf(bean.getClass()))))) - .thenReturn(beanMap); + when(context.getBeansOfType(argThat(is(subtypeOf(bean.getClass()))))).thenReturn(beanMap); } - private Map getBeanAsMap(T bean) { Map beanMap = new HashMap(); @@ -164,9 +149,7 @@ public class DomainClassConverterUnitTests { return beanMap; } - - private static TypeSafeMatcher> subtypeOf( - final Class type) { + private static TypeSafeMatcher> subtypeOf(final Class type) { return new TypeSafeMatcher>() { @@ -175,7 +158,6 @@ public class DomainClassConverterUnitTests { arg0.appendText("not a subtype of"); } - @Override public boolean matchesSafely(Class arg0) { diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassPropertyEditorRegistrarUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassPropertyEditorRegistrarUnitTests.java index 3fad4b989..7c682b867 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassPropertyEditorRegistrarUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassPropertyEditorRegistrarUnitTests.java @@ -37,17 +37,15 @@ import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.core.EntityInformation; import org.springframework.data.repository.core.support.RepositoryFactoryInformation; - /** * Unit test for {@link DomainClassPropertyEditorRegistrar}. - * + * * @author Oliver Gierke */ @RunWith(MockitoJUnitRunner.class) public class DomainClassPropertyEditorRegistrarUnitTests { - DomainClassPropertyEditorRegistrar registrar = - new DomainClassPropertyEditorRegistrar(); + DomainClassPropertyEditorRegistrar registrar = new DomainClassPropertyEditorRegistrar(); @Mock ApplicationContext context; @Mock @@ -61,27 +59,21 @@ public class DomainClassPropertyEditorRegistrarUnitTests { DomainClassPropertyEditor reference; - @Before - @SuppressWarnings({"unchecked", "rawtypes"}) + @SuppressWarnings({ "unchecked", "rawtypes" }) public void setup() { when(information.getJavaType()).thenReturn(Entity.class); when(provider.getEntityInformation()).thenReturn(information); - when(provider.getRepositoryInterface()).thenReturn( - (Class) EntityRepository.class); + when(provider.getRepositoryInterface()).thenReturn((Class) EntityRepository.class); Map map = getBeanAsMap(repository); when(context.getBeansOfType(EntityRepository.class)).thenReturn(map); - reference = - new DomainClassPropertyEditor(repository, - information, registry); + reference = new DomainClassPropertyEditor(repository, information, registry); } - @Test - public void addsRepositoryForEntityIfAvailableInAppContext() - throws Exception { + public void addsRepositoryForEntityIfAvailableInAppContext() throws Exception { letContextContain(provider); registrar.setApplicationContext(context); @@ -90,27 +82,22 @@ public class DomainClassPropertyEditorRegistrarUnitTests { verify(registry).registerCustomEditor(eq(Entity.class), eq(reference)); } - @Test public void doesNotAddDaoAtAllIfNoDaosFound() throws Exception { letContextContain(provider); registrar.registerCustomEditors(registry); - verify(registry, never()).registerCustomEditor(eq(Entity.class), - eq(reference)); + verify(registry, never()).registerCustomEditor(eq(Entity.class), eq(reference)); } - private void letContextContain(Object bean) { Map beanMap = getBeanAsMap(bean); - when(context.getBeansOfType(argThat(is(subtypeOf(bean.getClass()))))) - .thenReturn(beanMap); + when(context.getBeansOfType(argThat(is(subtypeOf(bean.getClass()))))).thenReturn(beanMap); } - private Map getBeanAsMap(T bean) { Map beanMap = new HashMap(); @@ -127,9 +114,7 @@ public class DomainClassPropertyEditorRegistrarUnitTests { } - - private static TypeSafeMatcher> subtypeOf( - final Class type) { + private static TypeSafeMatcher> subtypeOf(final Class type) { return new TypeSafeMatcher>() { @@ -138,7 +123,6 @@ public class DomainClassPropertyEditorRegistrarUnitTests { arg0.appendText("not a subtype of"); } - @Override public boolean matchesSafely(Class arg0) { diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassPropertyEditorUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassPropertyEditorUnitTests.java index c5504b14e..2982c2c7c 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassPropertyEditorUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/support/DomainClassPropertyEditorUnitTests.java @@ -31,10 +31,9 @@ import org.springframework.data.domain.Persistable; import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.core.EntityInformation; - /** * Unit test for {@link DomainClassPropertyEditor}. - * + * * @author Oliver Gierke */ @RunWith(MockitoJUnitRunner.class) @@ -49,17 +48,13 @@ public class DomainClassPropertyEditorUnitTests { @Mock EntityInformation information; - @Before public void setUp() { when(information.getIdType()).thenReturn(Integer.class); - editor = - new DomainClassPropertyEditor(userRepository, - information, registry); + editor = new DomainClassPropertyEditor(userRepository, information, registry); } - @Test public void convertsPlainIdTypeCorrectly() throws Exception { @@ -72,7 +67,6 @@ public class DomainClassPropertyEditorUnitTests { verify(userRepository, times(1)).findOne(1); } - @Test public void convertsEntityToIdCorrectly() throws Exception { @@ -82,22 +76,19 @@ public class DomainClassPropertyEditorUnitTests { assertThat(editor.getAsText(), is("1")); } - @Test public void usesCustomEditorIfConfigured() throws Exception { PropertyEditor customEditor = mock(PropertyEditor.class); when(customEditor.getValue()).thenReturn(1); - when(registry.findCustomEditor(Integer.class, null)).thenReturn( - customEditor); + when(registry.findCustomEditor(Integer.class, null)).thenReturn(customEditor); convertsPlainIdTypeCorrectly(); verify(customEditor, times(1)).setAsText("1"); } - @Test public void returnsNullIdIfNoEntitySet() throws Exception { @@ -105,23 +96,19 @@ public class DomainClassPropertyEditorUnitTests { assertThat(editor.getAsText(), is(nullValue())); } - @Test public void resetsValueToNullAfterEmptyStringConversion() throws Exception { assertValueResetToNullAfterConverting(""); } - @Test public void resetsValueToNullAfterNullStringConversion() throws Exception { assertValueResetToNullAfterConverting(null); } - - private void assertValueResetToNullAfterConverting(String source) - throws Exception { + private void assertValueResetToNullAfterConverting(String source) throws Exception { convertsPlainIdTypeCorrectly(); assertThat(editor.getValue(), is(notNullValue())); @@ -132,7 +119,7 @@ public class DomainClassPropertyEditorUnitTests { /** * Sample entity. - * + * * @author Oliver Gierke */ @SuppressWarnings("serial") @@ -140,13 +127,11 @@ public class DomainClassPropertyEditorUnitTests { private Integer id; - public User(Integer id) { this.id = id; } - /* * (non-Javadoc) * @@ -157,7 +142,6 @@ public class DomainClassPropertyEditorUnitTests { return id; } - /* * (non-Javadoc) * @@ -171,7 +155,7 @@ public class DomainClassPropertyEditorUnitTests { /** * Sample generic DAO interface. - * + * * @author Oliver Gierke */ private static interface UserRepository extends CrudRepository { diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/repository/util/ClassUtilsUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/repository/util/ClassUtilsUnitTests.java index d6bafa77f..c8266b11d 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/repository/util/ClassUtilsUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/repository/util/ClassUtilsUnitTests.java @@ -27,10 +27,9 @@ import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import org.springframework.data.repository.Repository; - /** * Unit test for {@link ClassUtils}. - * + * * @author Oliver Gierke */ public class ClassUtilsUnitTests { @@ -38,8 +37,7 @@ public class ClassUtilsUnitTests { @Test(expected = IllegalStateException.class) public void rejectsInvalidReturnType() throws Exception { - assertReturnTypeAssignable(SomeDao.class.getMethod("findByFirstname", - Pageable.class, String.class), User.class); + assertReturnTypeAssignable(SomeDao.class.getMethod("findByFirstname", Pageable.class, String.class), User.class); } @Test @@ -55,7 +53,6 @@ public class ClassUtilsUnitTests { private String firstname; - public String getAddress() { return null; diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/util/ClassTypeInformationUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/util/ClassTypeInformationUnitTests.java index e8ac60a83..0b412dc36 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/util/ClassTypeInformationUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/util/ClassTypeInformationUnitTests.java @@ -55,40 +55,33 @@ public class ClassTypeInformationUnitTests { TypeInformation content = wrapper.getProperty("content"); assertEquals(String.class, content.getType()); - assertEquals(String.class, - discoverer.getProperty("wrapped").getProperty("content").getType()); - assertEquals(String.class, discoverer.getProperty("wrapped.content") - .getType()); + assertEquals(String.class, discoverer.getProperty("wrapped").getProperty("content").getType()); + assertEquals(String.class, discoverer.getProperty("wrapped.content").getType()); } @Test @SuppressWarnings("rawtypes") public void discoversBoundType() { - TypeInformation information = ClassTypeInformation.from( - GenericTypeWithBound.class); + TypeInformation information = ClassTypeInformation.from(GenericTypeWithBound.class); assertEquals(Person.class, information.getProperty("person").getType()); } @Test public void discoversBoundTypeForSpecialization() { - TypeInformation information = ClassTypeInformation.from( - SpecialGenericTypeWithBound.class); - assertEquals(SpecialPerson.class, information.getProperty("person") - .getType()); + TypeInformation information = ClassTypeInformation + .from(SpecialGenericTypeWithBound.class); + assertEquals(SpecialPerson.class, information.getProperty("person").getType()); } @Test @SuppressWarnings("rawtypes") public void discoversBoundTypeForNested() { - TypeInformation information = ClassTypeInformation.from( - AnotherGenericType.class); - assertEquals(GenericTypeWithBound.class, information.getProperty("nested") - .getType()); - assertEquals(Person.class, information.getProperty("nested.person") - .getType()); + TypeInformation information = ClassTypeInformation.from(AnotherGenericType.class); + assertEquals(GenericTypeWithBound.class, information.getProperty("nested").getType()); + assertEquals(Person.class, information.getProperty("nested.person").getType()); } @Test @@ -125,25 +118,25 @@ public class ClassTypeInformationUnitTests { assertEquals(Map.class, map.getType()); assertEquals(Calendar.class, map.getMapValueType().getType()); } - + @Test public void typeInfoDoesNotEqualForGenericTypesWithDifferentParent() { - + TypeInformation first = ClassTypeInformation.from(ConcreteWrapper.class); TypeInformation second = ClassTypeInformation.from(AnotherConcreteWrapper.class); - + assertFalse(first.getProperty("wrapped").equals(second.getProperty("wrapped"))); } @Test public void handlesPropertyFieldMismatchCorrectly() { - + TypeInformation from = ClassTypeInformation.from(PropertyGetter.class); - + TypeInformation property = from.getProperty("_name"); assertThat(property, is(notNullValue())); assertThat(property.getType(), is(typeCompatibleWith(String.class))); - + property = from.getProperty("name"); assertThat(property, is(notNullValue())); assertThat(property.getType(), is(typeCompatibleWith(byte[].class))); @@ -166,14 +159,14 @@ public class ClassTypeInformationUnitTests { public void resolvesWildCardTypeCorrectly() { TypeInformation information = ClassTypeInformation.from(ClassWithWildCardBound.class); - + TypeInformation property = information.getProperty("wildcard"); assertThat(property.isCollectionLike(), is(true)); assertThat(property.getComponentType().getType(), is(typeCompatibleWith(String.class))); - + property = information.getProperty("complexWildcard"); assertThat(property.isCollectionLike(), is(true)); - + TypeInformation component = property.getComponentType(); assertThat(component.isCollectionLike(), is(true)); assertThat(component.getComponentType().getType(), is(typeCompatibleWith(String.class))); @@ -210,8 +203,7 @@ public class ClassTypeInformationUnitTests { S nested; } - static class SpecialGenericTypeWithBound extends - GenericTypeWithBound { + static class SpecialGenericTypeWithBound extends GenericTypeWithBound { } @@ -239,14 +231,14 @@ public class ClassTypeInformationUnitTests { static class ConcreteWrapper extends GenericWrapper { } - + static class AnotherConcreteWrapper extends GenericWrapper { - + } static class PropertyGetter { private String _name; - + public byte[] getName() { return _name.getBytes(); } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/util/ParameterizedTypeUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/util/ParameterizedTypeUnitTests.java index 587fac87e..6dadb7417 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/util/ParameterizedTypeUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/util/ParameterizedTypeUnitTests.java @@ -29,65 +29,66 @@ import org.mockito.runners.MockitoJUnitRunner; /** * Unit tests for {@link ParameterizedTypeInformation}. - * + * * @author Oliver Gierke */ @RunWith(MockitoJUnitRunner.class) public class ParameterizedTypeUnitTests { - @Mock ParameterizedType one, two; - + @Mock + ParameterizedType one, two; + @Test public void considersTypeInformationsWithDifferingParentsNotEqual() { - + TypeDiscoverer stringParent = new TypeDiscoverer(String.class, null); TypeDiscoverer objectParent = new TypeDiscoverer(Object.class, null); - + ParameterizedTypeInformation first = new ParameterizedTypeInformation(one, stringParent); ParameterizedTypeInformation second = new ParameterizedTypeInformation(one, objectParent); - + assertFalse(first.equals(second)); } - + @Test public void considersTypeInformationsWithSameParentsNotEqual() { - + TypeDiscoverer stringParent = new TypeDiscoverer(String.class, null); - + ParameterizedTypeInformation first = new ParameterizedTypeInformation(one, stringParent); ParameterizedTypeInformation second = new ParameterizedTypeInformation(one, stringParent); - + assertTrue(first.equals(second)); } - + /** * @see DATACMNS-88 */ @Test public void resolvesMapValueTypeCorrectly() { - + TypeInformation type = ClassTypeInformation.from(Foo.class); TypeInformation propertyType = type.getProperty("param"); assertThat(propertyType.getProperty("value").getType(), is(typeCompatibleWith(String.class))); assertThat(propertyType.getMapValueType().getType(), is(typeCompatibleWith(String.class))); - + propertyType = type.getProperty("param2"); assertThat(propertyType.getProperty("value").getType(), is(typeCompatibleWith(String.class))); assertThat(propertyType.getMapValueType().getType(), is(typeCompatibleWith(Locale.class))); } - + @SuppressWarnings("serial") class Localized extends HashMap { S value; } - + @SuppressWarnings("serial") class Localized2 extends HashMap { S value; } - + class Foo { - Localized param; - Localized2 param2; + Localized param; + Localized2 param2; } } diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/util/TypeDiscovererUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/util/TypeDiscovererUnitTests.java index d90158ccd..b45217c1c 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/util/TypeDiscovererUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/util/TypeDiscovererUnitTests.java @@ -133,7 +133,7 @@ public class TypeDiscovererUnitTests { assertThat(discoverer.getComponentType(), is(nullValue())); assertThat(discoverer.getMapValueType(), is(nullValue())); } - + class SelfReferencing { Map parent; diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/web/PageableArgumentResolverUnitTests.java b/spring-data-commons-core/src/test/java/org/springframework/data/web/PageableArgumentResolverUnitTests.java index d79782005..0241815ac 100644 --- a/spring-data-commons-core/src/test/java/org/springframework/data/web/PageableArgumentResolverUnitTests.java +++ b/spring-data-commons-core/src/test/java/org/springframework/data/web/PageableArgumentResolverUnitTests.java @@ -30,10 +30,9 @@ import org.springframework.mock.web.MockHttpServletRequest; import org.springframework.web.context.request.NativeWebRequest; import org.springframework.web.context.request.ServletWebRequest; - /** * Unit test for {@link PageableArgumentResolver}. - * + * * @author Oliver Gierke - gierke@synyx.de */ public class PageableArgumentResolverUnitTests { @@ -45,23 +44,14 @@ public class PageableArgumentResolverUnitTests { MockHttpServletRequest request; - @Before public void setUp() throws SecurityException, NoSuchMethodException { - correctMethod = - SampleController.class.getMethod("correctMethod", - Pageable.class, Pageable.class); - failedMethod = - SampleController.class.getMethod("failedMethod", - Pageable.class, Pageable.class); - invalidQualifiers = - SampleController.class.getMethod("invalidQualifiers", - Pageable.class, Pageable.class); + correctMethod = SampleController.class.getMethod("correctMethod", Pageable.class, Pageable.class); + failedMethod = SampleController.class.getMethod("failedMethod", Pageable.class, Pageable.class); + invalidQualifiers = SampleController.class.getMethod("invalidQualifiers", Pageable.class, Pageable.class); - defaultsMethod = - SampleController.class.getMethod("defaultsMethod", - Pageable.class); + defaultsMethod = SampleController.class.getMethod("defaultsMethod", Pageable.class); request = new MockHttpServletRequest(); @@ -74,7 +64,6 @@ public class PageableArgumentResolverUnitTests { request.addParameter("bar_page.size", "60"); } - @Test public void testname() throws Exception { @@ -82,7 +71,6 @@ public class PageableArgumentResolverUnitTests { assertSizeForPrefix(60, null, 1); } - @Test(expected = IllegalStateException.class) public void rejectsInvalidlyMappedPageables() throws Exception { @@ -92,7 +80,6 @@ public class PageableArgumentResolverUnitTests { new PageableArgumentResolver().resolveArgument(parameter, webRequest); } - @Test(expected = IllegalStateException.class) public void rejectsInvalidQualifiers() throws Exception { @@ -102,13 +89,11 @@ public class PageableArgumentResolverUnitTests { new PageableArgumentResolver().resolveArgument(parameter, webRequest); } - @Test public void assertDefaults() throws Exception { MethodParameter parameter = new MethodParameter(defaultsMethod, 0); - NativeWebRequest webRequest = - new ServletWebRequest(new MockHttpServletRequest()); + NativeWebRequest webRequest = new ServletWebRequest(new MockHttpServletRequest()); PageableArgumentResolver resolver = new PageableArgumentResolver(); Object argument = resolver.resolveArgument(parameter, webRequest); @@ -116,11 +101,9 @@ public class PageableArgumentResolverUnitTests { Pageable pageable = (Pageable) argument; assertEquals(SampleController.DEFAULT_PAGESIZE, pageable.getPageSize()); - assertEquals(SampleController.DEFAULT_PAGENUMBER, - pageable.getPageNumber()); + assertEquals(SampleController.DEFAULT_PAGENUMBER, pageable.getPageNumber()); } - @Test public void assertOverridesDefaults() throws Exception { @@ -141,9 +124,7 @@ public class PageableArgumentResolverUnitTests { assertEquals(sizeParam - 1, pageable.getPageNumber()); } - - private void assertSizeForPrefix(int size, Sort sort, int index) - throws Exception { + private void assertSizeForPrefix(int size, Sort sort, int index) throws Exception { MethodParameter parameter = new MethodParameter(correctMethod, index); NativeWebRequest webRequest = new ServletWebRequest(request); @@ -167,26 +148,20 @@ public class PageableArgumentResolverUnitTests { static final int DEFAULT_PAGESIZE = 198; static final int DEFAULT_PAGENUMBER = 42; - public void defaultsMethod( @PageableDefaults(value = DEFAULT_PAGESIZE, pageNumber = DEFAULT_PAGENUMBER) Pageable pageable) { } - - public void correctMethod(@Qualifier("foo") Pageable first, - @Qualifier("bar") Pageable second) { + public void correctMethod(@Qualifier("foo") Pageable first, @Qualifier("bar") Pageable second) { } - public void failedMethod(Pageable first, Pageable second) { } - - public void invalidQualifiers(@Qualifier("foo") Pageable first, - @Qualifier("foo") Pageable second) { + public void invalidQualifiers(@Qualifier("foo") Pageable first, @Qualifier("foo") Pageable second) { } }