From 4d9329fab8f009586dfe6e2527332f63899c0d01 Mon Sep 17 00:00:00 2001 From: Mark Paluch Date: Wed, 24 Jan 2018 12:32:29 +0100 Subject: [PATCH] DATACMNS-1249 - Fix line endings to LF. --- .../org/springframework/data/geo/Box.java | 254 +++++----- .../org/springframework/data/geo/Circle.java | 208 ++++---- .../org/springframework/data/geo/Point.java | 274 +++++----- .../AnnotationDetectionFieldCallback.java | 276 +++++----- .../springframework/data/util/Version.java | 444 ++++++++-------- .../springframework/data/domain/jaxb/atom.xsd | 478 +++++++++--------- .../data/util/VersionUnitTests.java | 328 ++++++------ 7 files changed, 1131 insertions(+), 1131 deletions(-) diff --git a/src/main/java/org/springframework/data/geo/Box.java b/src/main/java/org/springframework/data/geo/Box.java index b9a3a5028..7b30f59d2 100644 --- a/src/main/java/org/springframework/data/geo/Box.java +++ b/src/main/java/org/springframework/data/geo/Box.java @@ -1,127 +1,127 @@ -/* - * Copyright 2010-2018 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.data.geo; - -import org.springframework.lang.Nullable; -import org.springframework.util.Assert; - -/** - * Represents a geospatial box value - * - * @author Mark Pollack - * @author Oliver Gierke - * @author Thomas Darimont - * @since 1.8 - */ -public class Box implements Shape { - - private static final long serialVersionUID = 8198095179084040711L; - - private final Point first; - private final Point second; - - /** - * Creates a new Box spanning from the given first to the second {@link Point}. - * - * @param first must not be {@literal null}. - * @param second must not be {@literal null}. - */ - public Box(Point first, Point second) { - - Assert.notNull(first, "First point must not be null!"); - Assert.notNull(second, "Second point must not be null!"); - - this.first = first; - this.second = second; - } - - /** - * Creates a new Box from the given {@code first} to the {@code second} point represented as the {@literal double[]}. - * - * @param first must not be {@literal null} and contain exactly 2 doubles. - * @param second must not be {@literal null} and contain exactly 2 doubles. - */ - public Box(double[] first, double[] second) { - - Assert.isTrue(first.length == 2, "Point array has to have 2 elements!"); - Assert.isTrue(second.length == 2, "Point array has to have 2 elements!"); - - this.first = new Point(first[0], first[1]); - this.second = new Point(second[0], second[1]); - } - - /** - * Returns the first {@link Point} making up the {@link Box}. - * - * @return - */ - public Point getFirst() { - return first; - } - - /** - * Returns the second {@link Point} making up the {@link Box}. - * - * @return - */ - public Point getSecond() { - return second; - } - - /* - * (non-Javadoc) - * @see java.lang.Object#toString() - */ - @Override - public String toString() { - return String.format("Box [%s, %s]", first, second); - } - - /* - * (non-Javadoc) - * @see java.lang.Object#hashCode() - */ - @Override - public int hashCode() { - - int result = 31; - - result += 17 * first.hashCode(); - result += 17 * second.hashCode(); - - return result; - } - - /* - * (non-Javadoc) - * @see java.lang.Object#equals(java.lang.Object) - */ - @Override - public boolean equals(@Nullable Object obj) { - - if (this == obj) { - return true; - } - - if (!(obj instanceof Box)) { - return false; - } - - Box that = (Box) obj; - - return this.first.equals(that.first) && this.second.equals(that.second); - } -} +/* + * Copyright 2010-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.geo; + +import org.springframework.lang.Nullable; +import org.springframework.util.Assert; + +/** + * Represents a geospatial box value + * + * @author Mark Pollack + * @author Oliver Gierke + * @author Thomas Darimont + * @since 1.8 + */ +public class Box implements Shape { + + private static final long serialVersionUID = 8198095179084040711L; + + private final Point first; + private final Point second; + + /** + * Creates a new Box spanning from the given first to the second {@link Point}. + * + * @param first must not be {@literal null}. + * @param second must not be {@literal null}. + */ + public Box(Point first, Point second) { + + Assert.notNull(first, "First point must not be null!"); + Assert.notNull(second, "Second point must not be null!"); + + this.first = first; + this.second = second; + } + + /** + * Creates a new Box from the given {@code first} to the {@code second} point represented as the {@literal double[]}. + * + * @param first must not be {@literal null} and contain exactly 2 doubles. + * @param second must not be {@literal null} and contain exactly 2 doubles. + */ + public Box(double[] first, double[] second) { + + Assert.isTrue(first.length == 2, "Point array has to have 2 elements!"); + Assert.isTrue(second.length == 2, "Point array has to have 2 elements!"); + + this.first = new Point(first[0], first[1]); + this.second = new Point(second[0], second[1]); + } + + /** + * Returns the first {@link Point} making up the {@link Box}. + * + * @return + */ + public Point getFirst() { + return first; + } + + /** + * Returns the second {@link Point} making up the {@link Box}. + * + * @return + */ + public Point getSecond() { + return second; + } + + /* + * (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return String.format("Box [%s, %s]", first, second); + } + + /* + * (non-Javadoc) + * @see java.lang.Object#hashCode() + */ + @Override + public int hashCode() { + + int result = 31; + + result += 17 * first.hashCode(); + result += 17 * second.hashCode(); + + return result; + } + + /* + * (non-Javadoc) + * @see java.lang.Object#equals(java.lang.Object) + */ + @Override + public boolean equals(@Nullable Object obj) { + + if (this == obj) { + return true; + } + + if (!(obj instanceof Box)) { + return false; + } + + Box that = (Box) obj; + + return this.first.equals(that.first) && this.second.equals(that.second); + } +} diff --git a/src/main/java/org/springframework/data/geo/Circle.java b/src/main/java/org/springframework/data/geo/Circle.java index a60feafaf..99875e474 100644 --- a/src/main/java/org/springframework/data/geo/Circle.java +++ b/src/main/java/org/springframework/data/geo/Circle.java @@ -1,104 +1,104 @@ -/* - * Copyright 2010-2018 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.data.geo; - -import lombok.EqualsAndHashCode; - -import org.springframework.data.annotation.PersistenceConstructor; -import org.springframework.util.Assert; - -/** - * Represents a geospatial circle value - * - * @author Mark Pollack - * @author Oliver Gierke - * @author Thomas Darimont - * @since 1.8 - */ -@EqualsAndHashCode -public class Circle implements Shape { - - private static final long serialVersionUID = 5215611530535947924L; - - private final Point center; - private final Distance radius; - - /** - * Creates a new {@link Circle} from the given {@link Point} and radius. - * - * @param center must not be {@literal null}. - * @param radius must not be {@literal null} and it's value greater or equal to zero. - */ - @PersistenceConstructor - public Circle(Point center, Distance radius) { - - Assert.notNull(center, "Center point must not be null!"); - Assert.notNull(radius, "Radius must not be null!"); - Assert.isTrue(radius.getValue() >= 0, "Radius must not be negative!"); - - this.center = center; - this.radius = radius; - } - - /** - * Creates a new {@link Circle} from the given {@link Point} and radius. - * - * @param center must not be {@literal null}. - * @param radius's value must be greater or equal to zero. - */ - public Circle(Point center, double radius) { - this(center, new Distance(radius)); - } - - /** - * Creates a new {@link Circle} from the given coordinates and radius as {@link Distance} with a - * {@link Metrics#NEUTRAL}. - * - * @param centerX - * @param centerY - * @param radius must be greater or equal to zero. - */ - public Circle(double centerX, double centerY, double radius) { - this(new Point(centerX, centerY), new Distance(radius)); - } - - /** - * Returns the center of the {@link Circle}. - * - * @return will never be {@literal null}. - */ - public Point getCenter() { - return center; - } - - /** - * Returns the radius of the {@link Circle}. - * - * @return - */ - public Distance getRadius() { - return radius; - } - - /* - * (non-Javadoc) - * @see java.lang.Object#toString() - */ - @Override - public String toString() { - return String.format("Circle: [center=%s, radius=%s]", center, radius); - } -} +/* + * Copyright 2010-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.geo; + +import lombok.EqualsAndHashCode; + +import org.springframework.data.annotation.PersistenceConstructor; +import org.springframework.util.Assert; + +/** + * Represents a geospatial circle value + * + * @author Mark Pollack + * @author Oliver Gierke + * @author Thomas Darimont + * @since 1.8 + */ +@EqualsAndHashCode +public class Circle implements Shape { + + private static final long serialVersionUID = 5215611530535947924L; + + private final Point center; + private final Distance radius; + + /** + * Creates a new {@link Circle} from the given {@link Point} and radius. + * + * @param center must not be {@literal null}. + * @param radius must not be {@literal null} and it's value greater or equal to zero. + */ + @PersistenceConstructor + public Circle(Point center, Distance radius) { + + Assert.notNull(center, "Center point must not be null!"); + Assert.notNull(radius, "Radius must not be null!"); + Assert.isTrue(radius.getValue() >= 0, "Radius must not be negative!"); + + this.center = center; + this.radius = radius; + } + + /** + * Creates a new {@link Circle} from the given {@link Point} and radius. + * + * @param center must not be {@literal null}. + * @param radius's value must be greater or equal to zero. + */ + public Circle(Point center, double radius) { + this(center, new Distance(radius)); + } + + /** + * Creates a new {@link Circle} from the given coordinates and radius as {@link Distance} with a + * {@link Metrics#NEUTRAL}. + * + * @param centerX + * @param centerY + * @param radius must be greater or equal to zero. + */ + public Circle(double centerX, double centerY, double radius) { + this(new Point(centerX, centerY), new Distance(radius)); + } + + /** + * Returns the center of the {@link Circle}. + * + * @return will never be {@literal null}. + */ + public Point getCenter() { + return center; + } + + /** + * Returns the radius of the {@link Circle}. + * + * @return + */ + public Distance getRadius() { + return radius; + } + + /* + * (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return String.format("Circle: [center=%s, radius=%s]", center, radius); + } +} diff --git a/src/main/java/org/springframework/data/geo/Point.java b/src/main/java/org/springframework/data/geo/Point.java index 06aa1b9f2..df77aeed8 100644 --- a/src/main/java/org/springframework/data/geo/Point.java +++ b/src/main/java/org/springframework/data/geo/Point.java @@ -1,137 +1,137 @@ -/* - * Copyright 2010-2018 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.data.geo; - -import java.io.Serializable; -import java.util.Locale; - -import org.springframework.data.annotation.PersistenceConstructor; -import org.springframework.lang.Nullable; -import org.springframework.util.Assert; - -/** - * Represents a geospatial point value. - * - * @author Mark Pollack - * @author Oliver Gierke - * @author Thomas Darimont - * @since 1.8 - */ -public class Point implements Serializable { - - private static final long serialVersionUID = 3583151228933783558L; - - private final double x; - private final double y; - - /** - * Creates a {@link Point} from the given {@code x}, {@code y} coordinate. - * - * @param x - * @param y - */ - @PersistenceConstructor - public Point(double x, double y) { - this.x = x; - this.y = y; - } - - /** - * Creates a {@link Point} from the given {@link Point} coordinate. - * - * @param point must not be {@literal null}. - */ - public Point(Point point) { - - Assert.notNull(point, "Source point must not be null!"); - - this.x = point.x; - this.y = point.y; - } - - /** - * Returns the x-coordinate of the {@link Point}. - * - * @return - */ - public double getX() { - return x; - } - - /** - * Returns the y-coordinate of the {@link Point}. - * - * @return - */ - public double getY() { - return y; - } - - /* - * (non-Javadoc) - * @see java.lang.Object#hashCode() - */ - @Override - public int hashCode() { - - int result = 1; - - long temp = Double.doubleToLongBits(x); - result = 31 * result + (int) (temp ^ temp >>> 32); - - temp = Double.doubleToLongBits(y); - result = 31 * result + (int) (temp ^ temp >>> 32); - - return result; - } - - /* - * (non-Javadoc) - * @see java.lang.Object#equals(java.lang.Object) - */ - @Override - public boolean equals(@Nullable Object obj) { - - if (this == obj) { - return true; - } - - if (!(obj instanceof Point)) { - return false; - } - - Point other = (Point) obj; - - if (Double.doubleToLongBits(x) != Double.doubleToLongBits(other.x)) { - return false; - } - - if (Double.doubleToLongBits(y) != Double.doubleToLongBits(other.y)) { - return false; - } - - return true; - } - - /* - * (non-Javadoc) - * @see java.lang.Object#toString() - */ - @Override - public String toString() { - return String.format(Locale.ENGLISH, "Point [x=%f, y=%f]", x, y); - } -} +/* + * Copyright 2010-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.geo; + +import java.io.Serializable; +import java.util.Locale; + +import org.springframework.data.annotation.PersistenceConstructor; +import org.springframework.lang.Nullable; +import org.springframework.util.Assert; + +/** + * Represents a geospatial point value. + * + * @author Mark Pollack + * @author Oliver Gierke + * @author Thomas Darimont + * @since 1.8 + */ +public class Point implements Serializable { + + private static final long serialVersionUID = 3583151228933783558L; + + private final double x; + private final double y; + + /** + * Creates a {@link Point} from the given {@code x}, {@code y} coordinate. + * + * @param x + * @param y + */ + @PersistenceConstructor + public Point(double x, double y) { + this.x = x; + this.y = y; + } + + /** + * Creates a {@link Point} from the given {@link Point} coordinate. + * + * @param point must not be {@literal null}. + */ + public Point(Point point) { + + Assert.notNull(point, "Source point must not be null!"); + + this.x = point.x; + this.y = point.y; + } + + /** + * Returns the x-coordinate of the {@link Point}. + * + * @return + */ + public double getX() { + return x; + } + + /** + * Returns the y-coordinate of the {@link Point}. + * + * @return + */ + public double getY() { + return y; + } + + /* + * (non-Javadoc) + * @see java.lang.Object#hashCode() + */ + @Override + public int hashCode() { + + int result = 1; + + long temp = Double.doubleToLongBits(x); + result = 31 * result + (int) (temp ^ temp >>> 32); + + temp = Double.doubleToLongBits(y); + result = 31 * result + (int) (temp ^ temp >>> 32); + + return result; + } + + /* + * (non-Javadoc) + * @see java.lang.Object#equals(java.lang.Object) + */ + @Override + public boolean equals(@Nullable Object obj) { + + if (this == obj) { + return true; + } + + if (!(obj instanceof Point)) { + return false; + } + + Point other = (Point) obj; + + if (Double.doubleToLongBits(x) != Double.doubleToLongBits(other.x)) { + return false; + } + + if (Double.doubleToLongBits(y) != Double.doubleToLongBits(other.y)) { + return false; + } + + return true; + } + + /* + * (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return String.format(Locale.ENGLISH, "Point [x=%f, y=%f]", x, y); + } +} diff --git a/src/main/java/org/springframework/data/util/AnnotationDetectionFieldCallback.java b/src/main/java/org/springframework/data/util/AnnotationDetectionFieldCallback.java index a990f7342..aba0dc355 100755 --- a/src/main/java/org/springframework/data/util/AnnotationDetectionFieldCallback.java +++ b/src/main/java/org/springframework/data/util/AnnotationDetectionFieldCallback.java @@ -1,138 +1,138 @@ -/* - * Copyright 2012-2018 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.data.util; - -import java.lang.annotation.Annotation; -import java.lang.reflect.Field; - -import org.springframework.core.annotation.AnnotatedElementUtils; -import org.springframework.lang.Nullable; -import org.springframework.util.Assert; -import org.springframework.util.ReflectionUtils; -import org.springframework.util.ReflectionUtils.FieldCallback; - -/** - * A {@link FieldCallback} that will inspect each field for a given annotation. This field's type can then be accessed - * afterwards. - * - * @author Oliver Gierke - * @author Christoph Strobl - */ -public class AnnotationDetectionFieldCallback implements FieldCallback { - - private final Class annotationType; - private @Nullable Field field; - - /** - * Creates a new {@link AnnotationDetectionFieldCallback} scanning for an annotation of the given type. - * - * @param annotationType must not be {@literal null}. - */ - public AnnotationDetectionFieldCallback(Class annotationType) { - - Assert.notNull(annotationType, "AnnotationType must not be null!"); - - this.annotationType = annotationType; - } - - /* - * (non-Javadoc) - * @see org.springframework.util.ReflectionUtils.FieldCallback#doWith(java.lang.reflect.Field) - */ - public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException { - - if (this.field != null) { - return; - } - - if (AnnotatedElementUtils.findMergedAnnotation(field, annotationType) != null) { - - ReflectionUtils.makeAccessible(field); - this.field = field; - } - } - - /** - * Returns the detected field. - * - * @return the field - */ - @Nullable - public Field getField() { - return field; - } - - /** - * Returns the field that was detected. - * - * @return - * @throws IllegalStateException in case no field with the configured annotation was found. - */ - public Field getRequiredField() { - - Field field = this.field; - - if (field == null) { - throw new IllegalStateException(String.format("No field found for annotation %s!", annotationType)); - } - - return field; - } - - /** - * Returns the type of the field. - * - * @return - */ - @Nullable - public Class getType() { - - Field field = this.field; - - return field == null ? null : field.getType(); - } - - /** - * Returns the type of the field or throws an {@link IllegalArgumentException} if no field could be found. - * - * @return - * @throws IllegalStateException in case no field with the configured annotation was found. - */ - public Class getRequiredType() { - return getRequiredField().getType(); - } - - /** - * Retrieves the value of the field by reflection. - * - * @param source must not be {@literal null}. - * @return - */ - @Nullable - @SuppressWarnings("unchecked") - public T getValue(Object source) { - - Assert.notNull(source, "Source object must not be null!"); - - Field field = this.field; - - if (field == null) { - return null; - } - - return (T) ReflectionUtils.getField(field, source); - } -} +/* + * Copyright 2012-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.util; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Field; + +import org.springframework.core.annotation.AnnotatedElementUtils; +import org.springframework.lang.Nullable; +import org.springframework.util.Assert; +import org.springframework.util.ReflectionUtils; +import org.springframework.util.ReflectionUtils.FieldCallback; + +/** + * A {@link FieldCallback} that will inspect each field for a given annotation. This field's type can then be accessed + * afterwards. + * + * @author Oliver Gierke + * @author Christoph Strobl + */ +public class AnnotationDetectionFieldCallback implements FieldCallback { + + private final Class annotationType; + private @Nullable Field field; + + /** + * Creates a new {@link AnnotationDetectionFieldCallback} scanning for an annotation of the given type. + * + * @param annotationType must not be {@literal null}. + */ + public AnnotationDetectionFieldCallback(Class annotationType) { + + Assert.notNull(annotationType, "AnnotationType must not be null!"); + + this.annotationType = annotationType; + } + + /* + * (non-Javadoc) + * @see org.springframework.util.ReflectionUtils.FieldCallback#doWith(java.lang.reflect.Field) + */ + public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException { + + if (this.field != null) { + return; + } + + if (AnnotatedElementUtils.findMergedAnnotation(field, annotationType) != null) { + + ReflectionUtils.makeAccessible(field); + this.field = field; + } + } + + /** + * Returns the detected field. + * + * @return the field + */ + @Nullable + public Field getField() { + return field; + } + + /** + * Returns the field that was detected. + * + * @return + * @throws IllegalStateException in case no field with the configured annotation was found. + */ + public Field getRequiredField() { + + Field field = this.field; + + if (field == null) { + throw new IllegalStateException(String.format("No field found for annotation %s!", annotationType)); + } + + return field; + } + + /** + * Returns the type of the field. + * + * @return + */ + @Nullable + public Class getType() { + + Field field = this.field; + + return field == null ? null : field.getType(); + } + + /** + * Returns the type of the field or throws an {@link IllegalArgumentException} if no field could be found. + * + * @return + * @throws IllegalStateException in case no field with the configured annotation was found. + */ + public Class getRequiredType() { + return getRequiredField().getType(); + } + + /** + * Retrieves the value of the field by reflection. + * + * @param source must not be {@literal null}. + * @return + */ + @Nullable + @SuppressWarnings("unchecked") + public T getValue(Object source) { + + Assert.notNull(source, "Source object must not be null!"); + + Field field = this.field; + + if (field == null) { + return null; + } + + return (T) ReflectionUtils.getField(field, source); + } +} diff --git a/src/main/java/org/springframework/data/util/Version.java b/src/main/java/org/springframework/data/util/Version.java index 23251f19a..1093bce42 100644 --- a/src/main/java/org/springframework/data/util/Version.java +++ b/src/main/java/org/springframework/data/util/Version.java @@ -1,222 +1,222 @@ -/* - * Copyright 2013-2018 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.data.util; - -import java.util.ArrayList; -import java.util.List; - -import org.springframework.lang.Nullable; -import org.springframework.util.Assert; -import org.springframework.util.StringUtils; - -/** - * Value object to represent a Version consisting of major, minor and bugfix part. - * - * @author Oliver Gierke - */ -public class Version implements Comparable { - - private static final String VERSION_PARSE_ERROR = "Invalid version string! Could not parse segment %s within %s."; - - private final int major; - private final int minor; - private final int bugfix; - private final int build; - - /** - * Creates a new {@link Version} from the given integer values. At least one value has to be given but a maximum of 4. - * - * @param parts must not be {@literal null} or empty. - */ - public Version(int... parts) { - - Assert.notNull(parts, "Parts must not be null!"); - Assert.isTrue(parts.length > 0 && parts.length < 5, - String.format("Invalid parts length. 0 < %s < 5", parts.length)); - - this.major = parts[0]; - this.minor = parts.length > 1 ? parts[1] : 0; - this.bugfix = parts.length > 2 ? parts[2] : 0; - this.build = parts.length > 3 ? parts[3] : 0; - - Assert.isTrue(major >= 0, "Major version must be greater or equal zero!"); - Assert.isTrue(minor >= 0, "Minor version must be greater or equal zero!"); - Assert.isTrue(bugfix >= 0, "Bugfix version must be greater or equal zero!"); - Assert.isTrue(build >= 0, "Build version must be greater or equal zero!"); - } - - /** - * Parses the given string representation of a version into a {@link Version} object. - * - * @param version must not be {@literal null} or empty. - * @return - */ - public static Version parse(String version) { - - Assert.hasText(version, "Version must not be null o empty!"); - - String[] parts = version.trim().split("\\."); - int[] intParts = new int[parts.length]; - - for (int i = 0; i < parts.length; i++) { - - String input = i == parts.length - 1 ? parts[i].replaceAll("\\D.*", "") : parts[i]; - - if (StringUtils.hasText(input)) { - try { - intParts[i] = Integer.parseInt(input); - } catch (IllegalArgumentException o_O) { - throw new IllegalArgumentException(String.format(VERSION_PARSE_ERROR, input, version), o_O); - } - } - } - - return new Version(intParts); - } - - /** - * Returns whether the current {@link Version} is greater (newer) than the given one. - * - * @param version - * @return - */ - public boolean isGreaterThan(Version version) { - return compareTo(version) > 0; - } - - /** - * Returns whether the current {@link Version} is greater (newer) or the same as the given one. - * - * @param version - * @return - */ - public boolean isGreaterThanOrEqualTo(Version version) { - return compareTo(version) >= 0; - } - - /** - * Returns whether the current {@link Version} is the same as the given one. - * - * @param version - * @return - */ - public boolean is(Version version) { - return equals(version); - } - - /** - * Returns whether the current {@link Version} is less (older) than the given one. - * - * @param version - * @return - */ - public boolean isLessThan(Version version) { - return compareTo(version) < 0; - } - - /** - * Returns whether the current {@link Version} is less (older) or equal to the current one. - * - * @param version - * @return - */ - public boolean isLessThanOrEqualTo(Version version) { - return compareTo(version) <= 0; - } - - /* - * (non-Javadoc) - * @see java.lang.Comparable#compareTo(java.lang.Object) - */ - public int compareTo(@SuppressWarnings("null") Version that) { - - if (major != that.major) { - return major - that.major; - } - - if (minor != that.minor) { - return minor - that.minor; - } - - if (bugfix != that.bugfix) { - return bugfix - that.bugfix; - } - - if (build != that.build) { - return build - that.build; - } - - return 0; - } - - /* - * (non-Javadoc) - * @see java.lang.Object#equals(java.lang.Object) - */ - @Override - public boolean equals(@Nullable Object obj) { - - if (this == obj) { - return true; - } - - if (!(obj instanceof Version)) { - return false; - } - - Version that = (Version) obj; - - return this.major == that.major && this.minor == that.minor && this.bugfix == that.bugfix - && this.build == that.build; - } - - /* - * (non-Javadoc) - * @see java.lang.Object#hashCode() - */ - @Override - public int hashCode() { - - int result = 17; - result += 31 * major; - result += 31 * minor; - result += 31 * bugfix; - result += 31 * build; - return result; - } - - /* - * (non-Javadoc) - * @see java.lang.Object#toString() - */ - @Override - public String toString() { - - List digits = new ArrayList<>(); - digits.add(major); - digits.add(minor); - - if (build != 0 || bugfix != 0) { - digits.add(bugfix); - } - - if (build != 0) { - digits.add(build); - } - - return StringUtils.collectionToDelimitedString(digits, "."); - } -} +/* + * Copyright 2013-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.util; + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.lang.Nullable; +import org.springframework.util.Assert; +import org.springframework.util.StringUtils; + +/** + * Value object to represent a Version consisting of major, minor and bugfix part. + * + * @author Oliver Gierke + */ +public class Version implements Comparable { + + private static final String VERSION_PARSE_ERROR = "Invalid version string! Could not parse segment %s within %s."; + + private final int major; + private final int minor; + private final int bugfix; + private final int build; + + /** + * Creates a new {@link Version} from the given integer values. At least one value has to be given but a maximum of 4. + * + * @param parts must not be {@literal null} or empty. + */ + public Version(int... parts) { + + Assert.notNull(parts, "Parts must not be null!"); + Assert.isTrue(parts.length > 0 && parts.length < 5, + String.format("Invalid parts length. 0 < %s < 5", parts.length)); + + this.major = parts[0]; + this.minor = parts.length > 1 ? parts[1] : 0; + this.bugfix = parts.length > 2 ? parts[2] : 0; + this.build = parts.length > 3 ? parts[3] : 0; + + Assert.isTrue(major >= 0, "Major version must be greater or equal zero!"); + Assert.isTrue(minor >= 0, "Minor version must be greater or equal zero!"); + Assert.isTrue(bugfix >= 0, "Bugfix version must be greater or equal zero!"); + Assert.isTrue(build >= 0, "Build version must be greater or equal zero!"); + } + + /** + * Parses the given string representation of a version into a {@link Version} object. + * + * @param version must not be {@literal null} or empty. + * @return + */ + public static Version parse(String version) { + + Assert.hasText(version, "Version must not be null o empty!"); + + String[] parts = version.trim().split("\\."); + int[] intParts = new int[parts.length]; + + for (int i = 0; i < parts.length; i++) { + + String input = i == parts.length - 1 ? parts[i].replaceAll("\\D.*", "") : parts[i]; + + if (StringUtils.hasText(input)) { + try { + intParts[i] = Integer.parseInt(input); + } catch (IllegalArgumentException o_O) { + throw new IllegalArgumentException(String.format(VERSION_PARSE_ERROR, input, version), o_O); + } + } + } + + return new Version(intParts); + } + + /** + * Returns whether the current {@link Version} is greater (newer) than the given one. + * + * @param version + * @return + */ + public boolean isGreaterThan(Version version) { + return compareTo(version) > 0; + } + + /** + * Returns whether the current {@link Version} is greater (newer) or the same as the given one. + * + * @param version + * @return + */ + public boolean isGreaterThanOrEqualTo(Version version) { + return compareTo(version) >= 0; + } + + /** + * Returns whether the current {@link Version} is the same as the given one. + * + * @param version + * @return + */ + public boolean is(Version version) { + return equals(version); + } + + /** + * Returns whether the current {@link Version} is less (older) than the given one. + * + * @param version + * @return + */ + public boolean isLessThan(Version version) { + return compareTo(version) < 0; + } + + /** + * Returns whether the current {@link Version} is less (older) or equal to the current one. + * + * @param version + * @return + */ + public boolean isLessThanOrEqualTo(Version version) { + return compareTo(version) <= 0; + } + + /* + * (non-Javadoc) + * @see java.lang.Comparable#compareTo(java.lang.Object) + */ + public int compareTo(@SuppressWarnings("null") Version that) { + + if (major != that.major) { + return major - that.major; + } + + if (minor != that.minor) { + return minor - that.minor; + } + + if (bugfix != that.bugfix) { + return bugfix - that.bugfix; + } + + if (build != that.build) { + return build - that.build; + } + + return 0; + } + + /* + * (non-Javadoc) + * @see java.lang.Object#equals(java.lang.Object) + */ + @Override + public boolean equals(@Nullable Object obj) { + + if (this == obj) { + return true; + } + + if (!(obj instanceof Version)) { + return false; + } + + Version that = (Version) obj; + + return this.major == that.major && this.minor == that.minor && this.bugfix == that.bugfix + && this.build == that.build; + } + + /* + * (non-Javadoc) + * @see java.lang.Object#hashCode() + */ + @Override + public int hashCode() { + + int result = 17; + result += 31 * major; + result += 31 * minor; + result += 31 * bugfix; + result += 31 * build; + return result; + } + + /* + * (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + + List digits = new ArrayList<>(); + digits.add(major); + digits.add(minor); + + if (build != 0 || bugfix != 0) { + digits.add(bugfix); + } + + if (build != 0) { + digits.add(build); + } + + return StringUtils.collectionToDelimitedString(digits, "."); + } +} diff --git a/src/main/resources/org/springframework/data/domain/jaxb/atom.xsd b/src/main/resources/org/springframework/data/domain/jaxb/atom.xsd index fc606ba37..1a904830b 100644 --- a/src/main/resources/org/springframework/data/domain/jaxb/atom.xsd +++ b/src/main/resources/org/springframework/data/domain/jaxb/atom.xsd @@ -1,240 +1,240 @@ - - - - - This version of the Atom schema is based on version 1.0 of the format specifications, - found here http://www.atomenabled.org/developers/syndication/atom-format-spec.php. - - - - - - An Atom document may have two root elements, feed and entry, as defined in section 2. - - - - - - - - The Atom text construct is defined in section 3.1 of the format spec. - - - - - - - - - - - - - - - - - - - - The Atom person construct is defined in section 3.2 of the format spec. - - - - - - - - - - - - - - Schema definition for an email address. - - - - - - - - - - The Atom feed construct is defined in section 4.1.1 of the format spec. - - - - - - - - - - - - - - - - - - - - - - - - The Atom entry construct is defined in section 4.1.2 of the format spec. - - - - - - - - - - - - - - - - - - - - - - - The Atom content construct is defined in section 4.1.3 of the format spec. - - - - - - - - - - - - - The Atom cagegory construct is defined in section 4.2.2 of the format spec. - - - - - - - - - - - The Atom generator element is defined in section 4.2.4 of the format spec. - - - - - - - - - - - - - - The Atom icon construct is defined in section 4.2.5 of the format spec. - - - - - - - - - - - - The Atom id construct is defined in section 4.2.6 of the format spec. - - - - - - - - - - - - The Atom link construct is defined in section 3.4 of the format spec. - - - - - - - - - - - - - - The Atom logo construct is defined in section 4.2.8 of the format spec. - - - - - - - - - - - - The Atom source construct is defined in section 4.2.11 of the format spec. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + This version of the Atom schema is based on version 1.0 of the format specifications, + found here http://www.atomenabled.org/developers/syndication/atom-format-spec.php. + + + + + + An Atom document may have two root elements, feed and entry, as defined in section 2. + + + + + + + + The Atom text construct is defined in section 3.1 of the format spec. + + + + + + + + + + + + + + + + + + + + The Atom person construct is defined in section 3.2 of the format spec. + + + + + + + + + + + + + + Schema definition for an email address. + + + + + + + + + + The Atom feed construct is defined in section 4.1.1 of the format spec. + + + + + + + + + + + + + + + + + + + + + + + + The Atom entry construct is defined in section 4.1.2 of the format spec. + + + + + + + + + + + + + + + + + + + + + + + The Atom content construct is defined in section 4.1.3 of the format spec. + + + + + + + + + + + + + The Atom cagegory construct is defined in section 4.2.2 of the format spec. + + + + + + + + + + + The Atom generator element is defined in section 4.2.4 of the format spec. + + + + + + + + + + + + + + The Atom icon construct is defined in section 4.2.5 of the format spec. + + + + + + + + + + + + The Atom id construct is defined in section 4.2.6 of the format spec. + + + + + + + + + + + + The Atom link construct is defined in section 3.4 of the format spec. + + + + + + + + + + + + + + The Atom logo construct is defined in section 4.2.8 of the format spec. + + + + + + + + + + + + The Atom source construct is defined in section 4.2.11 of the format spec. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/test/java/org/springframework/data/util/VersionUnitTests.java b/src/test/java/org/springframework/data/util/VersionUnitTests.java index 22cdeec12..5795030af 100755 --- a/src/test/java/org/springframework/data/util/VersionUnitTests.java +++ b/src/test/java/org/springframework/data/util/VersionUnitTests.java @@ -1,164 +1,164 @@ -/* - * Copyright 2015-2018 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.data.util; - -import static org.assertj.core.api.Assertions.*; - -import org.hamcrest.Matchers; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.ExpectedException; - -/** - * Unit tests for {@link Version}. - * - * @author Oliver Gierke - */ -public class VersionUnitTests { - - public @Rule ExpectedException exception = ExpectedException.none(); - - @Test // DATCMNS-384 - public void sameVersionsEqualOneDigits() { - - Version first = new Version(6); - Version second = new Version(6); - - assertThat(first).isEqualTo(second); - assertThat(second).isEqualTo(first); - } - - @Test // DATCMNS-384 - public void sameVersionsEqualTwoDigits() { - - Version first = new Version(5, 2); - Version second = new Version(5, 2); - - assertThat(first).isEqualTo(second); - assertThat(second).isEqualTo(first); - } - - @Test // DATCMNS-384 - public void sameVersionsEqualThreeDigits() { - - Version first = new Version(1, 2, 3); - Version second = new Version(1, 2, 3); - - assertThat(first).isEqualTo(second); - assertThat(second).isEqualTo(first); - } - - @Test // DATCMNS-384 - public void sameVersionsEqualFourDigits() { - - Version first = new Version(1, 2, 3, 1000); - Version second = new Version(1, 2, 3, 1000); - - assertThat(first).isEqualTo(second); - assertThat(second).isEqualTo(first); - } - - @Test // DATCMNS-384 - public void parsesVersionCorrectlyOneDigits() { - - Version version = Version.parse("5"); - assertThat(version).isEqualTo(new Version(5)); - } - - @Test // DATCMNS-384 - public void parsesVersionCorrectlyTwoDigits() { - - Version version = Version.parse("5.2"); - assertThat(version).isEqualTo(new Version(5, 2)); - } - - @Test // DATCMNS-384 - public void parsesVersionCorrectlyThreeDigits() { - - Version version = Version.parse("12.1.3"); - assertThat(version).isEqualTo(new Version(12, 1, 3)); - } - - @Test // DATCMNS-384 - public void parsesVersionCorrectlyFourDigits() { - - Version version = Version.parse("12.1.3.1000"); - assertThat(version).isEqualTo(new Version(12, 1, 3, 1000)); - } - - @Test // DATCMNS-384 - public void comparesToCorrectly() { - - Version version = new Version(1, 2, 3, 1000); - Version nextBuild = new Version(1, 2, 3, 1001); - Version nextBugfix = new Version(1, 2, 4); - Version nextMinor = new Version(1, 3); - Version nextMajor = new Version(2); - - assertThat(nextMajor.isGreaterThan(nextMinor)).isTrue(); - assertThat(nextMajor.isGreaterThan(nextMajor)).isFalse(); - assertThat(nextMajor.is(nextMajor)).isTrue(); - assertThat(nextMinor.isLessThan(nextMajor)).isTrue(); - assertThat(nextMinor.isLessThan(nextMinor)).isFalse(); - - assertThat(nextMajor.compareTo(nextMajor)).isEqualTo(0); - assertThat(nextMinor.compareTo(nextMinor)).isEqualTo(0); - assertThat(nextBugfix.compareTo(nextBugfix)).isEqualTo(0); - assertThat(nextBuild.compareTo(nextBuild)).isEqualTo(0); - - assertThat(version.compareTo(nextMajor)).isLessThan(0); - assertThat(version.compareTo(nextMinor)).isLessThan(0); - assertThat(version.compareTo(nextBugfix)).isLessThan(0); - assertThat(version.compareTo(nextBuild)).isLessThan(0); - - assertThat(nextMajor.compareTo(version)).isGreaterThan(0); - assertThat(nextMinor.compareTo(version)).isGreaterThan(0); - assertThat(nextBugfix.compareTo(version)).isGreaterThan(0); - assertThat(nextBuild.compareTo(version)).isGreaterThan(0); - } - - @Test // DATCMNS-384 - public void removesTrailingZerosAfterSecondValueForToString() { - - assertThat(new Version(2).toString()).isEqualTo("2.0"); - assertThat(new Version(2, 0).toString()).isEqualTo("2.0"); - assertThat(new Version(2, 0, 0).toString()).isEqualTo("2.0"); - assertThat(new Version(2, 0, 0, 0).toString()).isEqualTo("2.0"); - assertThat(new Version(2, 0, 1).toString()).isEqualTo("2.0.1"); - assertThat(new Version(2, 0, 1, 0).toString()).isEqualTo("2.0.1"); - assertThat(new Version(2, 0, 0, 1).toString()).isEqualTo("2.0.0.1"); - } - - @Test // DATACMNS-496 - public void parseShouldRemoveNonNumericVersionParts() { - assertThat(Version.parse("2.0.0-rc1")).isEqualTo(new Version(2, 0, 0)); - } - - @Test // DATACMNS-719, DATACMNS-496 - public void removesNonNumericSuffix() { - assertThat(Version.parse("4.2.0.RELEASE")).isEqualTo(new Version(4, 2, 0)); - } - - @Test // DATACMNS-719, DATACMNS-496 - public void rejectsNonNumericPartOnNonLastPosition() { - - exception.expect(IllegalArgumentException.class); - exception.expectCause(Matchers.instanceOf(IllegalArgumentException.class)); - exception.expectMessage("1.RELEASE.2"); - - Version.parse("1.RELEASE.2"); - } -} +/* + * Copyright 2015-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.util; + +import static org.assertj.core.api.Assertions.*; + +import org.hamcrest.Matchers; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; + +/** + * Unit tests for {@link Version}. + * + * @author Oliver Gierke + */ +public class VersionUnitTests { + + public @Rule ExpectedException exception = ExpectedException.none(); + + @Test // DATCMNS-384 + public void sameVersionsEqualOneDigits() { + + Version first = new Version(6); + Version second = new Version(6); + + assertThat(first).isEqualTo(second); + assertThat(second).isEqualTo(first); + } + + @Test // DATCMNS-384 + public void sameVersionsEqualTwoDigits() { + + Version first = new Version(5, 2); + Version second = new Version(5, 2); + + assertThat(first).isEqualTo(second); + assertThat(second).isEqualTo(first); + } + + @Test // DATCMNS-384 + public void sameVersionsEqualThreeDigits() { + + Version first = new Version(1, 2, 3); + Version second = new Version(1, 2, 3); + + assertThat(first).isEqualTo(second); + assertThat(second).isEqualTo(first); + } + + @Test // DATCMNS-384 + public void sameVersionsEqualFourDigits() { + + Version first = new Version(1, 2, 3, 1000); + Version second = new Version(1, 2, 3, 1000); + + assertThat(first).isEqualTo(second); + assertThat(second).isEqualTo(first); + } + + @Test // DATCMNS-384 + public void parsesVersionCorrectlyOneDigits() { + + Version version = Version.parse("5"); + assertThat(version).isEqualTo(new Version(5)); + } + + @Test // DATCMNS-384 + public void parsesVersionCorrectlyTwoDigits() { + + Version version = Version.parse("5.2"); + assertThat(version).isEqualTo(new Version(5, 2)); + } + + @Test // DATCMNS-384 + public void parsesVersionCorrectlyThreeDigits() { + + Version version = Version.parse("12.1.3"); + assertThat(version).isEqualTo(new Version(12, 1, 3)); + } + + @Test // DATCMNS-384 + public void parsesVersionCorrectlyFourDigits() { + + Version version = Version.parse("12.1.3.1000"); + assertThat(version).isEqualTo(new Version(12, 1, 3, 1000)); + } + + @Test // DATCMNS-384 + public void comparesToCorrectly() { + + Version version = new Version(1, 2, 3, 1000); + Version nextBuild = new Version(1, 2, 3, 1001); + Version nextBugfix = new Version(1, 2, 4); + Version nextMinor = new Version(1, 3); + Version nextMajor = new Version(2); + + assertThat(nextMajor.isGreaterThan(nextMinor)).isTrue(); + assertThat(nextMajor.isGreaterThan(nextMajor)).isFalse(); + assertThat(nextMajor.is(nextMajor)).isTrue(); + assertThat(nextMinor.isLessThan(nextMajor)).isTrue(); + assertThat(nextMinor.isLessThan(nextMinor)).isFalse(); + + assertThat(nextMajor.compareTo(nextMajor)).isEqualTo(0); + assertThat(nextMinor.compareTo(nextMinor)).isEqualTo(0); + assertThat(nextBugfix.compareTo(nextBugfix)).isEqualTo(0); + assertThat(nextBuild.compareTo(nextBuild)).isEqualTo(0); + + assertThat(version.compareTo(nextMajor)).isLessThan(0); + assertThat(version.compareTo(nextMinor)).isLessThan(0); + assertThat(version.compareTo(nextBugfix)).isLessThan(0); + assertThat(version.compareTo(nextBuild)).isLessThan(0); + + assertThat(nextMajor.compareTo(version)).isGreaterThan(0); + assertThat(nextMinor.compareTo(version)).isGreaterThan(0); + assertThat(nextBugfix.compareTo(version)).isGreaterThan(0); + assertThat(nextBuild.compareTo(version)).isGreaterThan(0); + } + + @Test // DATCMNS-384 + public void removesTrailingZerosAfterSecondValueForToString() { + + assertThat(new Version(2).toString()).isEqualTo("2.0"); + assertThat(new Version(2, 0).toString()).isEqualTo("2.0"); + assertThat(new Version(2, 0, 0).toString()).isEqualTo("2.0"); + assertThat(new Version(2, 0, 0, 0).toString()).isEqualTo("2.0"); + assertThat(new Version(2, 0, 1).toString()).isEqualTo("2.0.1"); + assertThat(new Version(2, 0, 1, 0).toString()).isEqualTo("2.0.1"); + assertThat(new Version(2, 0, 0, 1).toString()).isEqualTo("2.0.0.1"); + } + + @Test // DATACMNS-496 + public void parseShouldRemoveNonNumericVersionParts() { + assertThat(Version.parse("2.0.0-rc1")).isEqualTo(new Version(2, 0, 0)); + } + + @Test // DATACMNS-719, DATACMNS-496 + public void removesNonNumericSuffix() { + assertThat(Version.parse("4.2.0.RELEASE")).isEqualTo(new Version(4, 2, 0)); + } + + @Test // DATACMNS-719, DATACMNS-496 + public void rejectsNonNumericPartOnNonLastPosition() { + + exception.expect(IllegalArgumentException.class); + exception.expectCause(Matchers.instanceOf(IllegalArgumentException.class)); + exception.expectMessage("1.RELEASE.2"); + + Version.parse("1.RELEASE.2"); + } +}