com.fitbur.assertj.api.AbstractOffsetDateTimeAssert Maven / Gradle / Ivy
/**
* 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.
*
* Copyright 2012-2016 the original author or authors.
*/
package com.fitbur.assertj.api;
import static com.fitbur.assertj.error.ShouldBeAfter.shouldBeAfter;
import static com.fitbur.assertj.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
import static com.fitbur.assertj.error.ShouldBeBefore.shouldBeBefore;
import static com.fitbur.assertj.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
import static com.fitbur.assertj.error.ShouldBeEqualIgnoringHours.shouldBeEqualIgnoringHours;
import static com.fitbur.assertj.error.ShouldBeEqualIgnoringMinutes.shouldBeEqualIgnoringMinutes;
import static com.fitbur.assertj.error.ShouldBeEqualIgnoringNanos.shouldBeEqualIgnoringNanos;
import static com.fitbur.assertj.error.ShouldBeEqualIgnoringSeconds.shouldBeEqualIgnoringSeconds;
import static com.fitbur.assertj.error.ShouldBeEqualIgnoringTimezone.shouldBeEqualIgnoringTimezone;
import java.time.OffsetDateTime;
import com.fitbur.assertj.internal.Failures;
import com.fitbur.assertj.internal.Objects;
/**
* Assertions for {@link java.time.OffsetDateTime} type from new Date & Time API introduced in Java 8.
*
* @author Paweł Stawicki
* @author Joel Costigliola
* @author Marcin Zajączkowski
*/
public abstract class AbstractOffsetDateTimeAssert> extends
AbstractAssert {
public static final String NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE = "The OffsetDateTime to compare actual with should not be null";
/**
* Creates a new {@link com.fitbur.assertj.api.AbstractOffsetDateTimeAssert}.
*
* @param selfType the "self type"
* @param actual the actual value to verify
*/
protected AbstractOffsetDateTimeAssert(OffsetDateTime actual, Class selfType) {
super(actual, selfType);
}
// visible for test
protected OffsetDateTime getActual() {
return actual;
}
/**
* Verifies that the actual {@code OffsetDateTime} is strictly before the given one.
*
* Example :
*
*
*
assertThat(parse("2000-01-01T23:59:59Z")).isBefore(parse("2000-01-02T00:00:00Z"));
*
* @param other the given {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if other {@code OffsetDateTime} is {@code null}.
* @throws AssertionError if the actual {@code OffsetDateTime} is not strictly before the given one.
*/
public S isBefore(OffsetDateTime other) {
Objects.instance().assertNotNull(info, actual);
assertOffsetDateTimeParameterIsNotNull(other);
if (!actual.isBefore(other)) {
throw Failures.instance().failure(info, shouldBeBefore(actual, other));
}
return myself;
}
/**
* Same assertion as {@link #isBefore(java.time.OffsetDateTime)} but the {@link java.time.OffsetDateTime} is built
* from given String, which
* must follow ISO OffsetDateTime format to allow calling {@link java.time.OffsetDateTime#parse(CharSequence)} method.
*
* Example :
*
*
*
// use directly String in comparison to avoid writing the code to perform the conversion
* assertThat(parse("2000-01-01T23:59:59Z")).isBefore("2000-01-02T00:00:00Z");
*
* @param offsetDateTimeAsString String representing a {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if given String is null or can't be converted to a
* {@link java.time.OffsetDateTime}.
* @throws AssertionError if the actual {@code OffsetDateTime} is not strictly before the
* {@link java.time.OffsetDateTime} built
* from given String.
*/
public S isBefore(String offsetDateTimeAsString) {
assertOffsetDateTimeAsStringParameterIsNotNull(offsetDateTimeAsString);
return isBefore(OffsetDateTime.parse(offsetDateTimeAsString));
}
/**
* Verifies that the actual {@code OffsetDateTime} is before or equals to the given one.
*
* Example :
*
*
*
assertThat(parse("2000-01-01T23:59:59Z")).isBeforeOrEqualTo(parse("2000-01-01T23:59:59Z"))
* .isBeforeOrEqualTo(parse("2000-01-02T00:00:00Z"));
*
* @param other the given {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if other {@code OffsetDateTime} is {@code null}.
* @throws AssertionError if the actual {@code OffsetDateTime} is not before or equals to the given one.
*/
public S isBeforeOrEqualTo(OffsetDateTime other) {
Objects.instance().assertNotNull(info, actual);
assertOffsetDateTimeParameterIsNotNull(other);
if (actual.isAfter(other)) {
throw Failures.instance().failure(info, shouldBeBeforeOrEqualsTo(actual, other));
}
return myself;
}
/**
* Same assertion as {@link #isBeforeOrEqualTo(java.time.OffsetDateTime)} but the {@link java.time.OffsetDateTime} is
* built from given
* String, which must follow ISO OffsetDateTime format to allow calling {@link java.time.OffsetDateTime#parse(CharSequence)} method.
*
* Example :
*
*
*
// use String in comparison to avoid conversion
* assertThat(parse("2000-01-01T23:59:59Z")).isBeforeOrEqualTo("2000-01-01T23:59:59Z")
* .isBeforeOrEqualTo("2000-01-02T00:00:00Z");
*
* @param offsetDateTimeAsString String representing a {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if given String is null or can't be converted to a
* {@link java.time.OffsetDateTime}.
* @throws AssertionError if the actual {@code OffsetDateTime} is not before or equals to the
* {@link java.time.OffsetDateTime} built from given String.
*/
public S isBeforeOrEqualTo(String offsetDateTimeAsString) {
assertOffsetDateTimeAsStringParameterIsNotNull(offsetDateTimeAsString);
return isBeforeOrEqualTo(OffsetDateTime.parse(offsetDateTimeAsString));
}
/**
* Verifies that the actual {@code OffsetDateTime} is after or equals to the given one.
*
* Example :
*
*
*
assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo(parse("2000-01-01T00:00:00Z"))
* .isAfterOrEqualTo(parse("1999-12-31T23:59:59Z"));
*
* @param other the given {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if other {@code OffsetDateTime} is {@code null}.
* @throws AssertionError if the actual {@code OffsetDateTime} is not after or equals to the given one.
*/
public S isAfterOrEqualTo(OffsetDateTime other) {
Objects.instance().assertNotNull(info, actual);
assertOffsetDateTimeParameterIsNotNull(other);
if (actual.isBefore(other)) {
throw Failures.instance().failure(info, shouldBeAfterOrEqualsTo(actual, other));
}
return myself;
}
/**
* Same assertion as {@link #isAfterOrEqualTo(java.time.OffsetDateTime)} but the {@link java.time.OffsetDateTime} is
* built from given
* String, which must follow ISO OffsetDateTime format to allow calling {@link java.time.OffsetDateTime#parse(CharSequence)} method.
*
* Example :
*
*
*
// use String in comparison to avoid conversion
* assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo("2000-01-01T00:00:00Z")
* .isAfterOrEqualTo("1999-12-31T23:59:59Z");
*
* @param offsetDateTimeAsString String representing a {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if given String is null or can't be converted to a
* {@link java.time.OffsetDateTime}.
* @throws AssertionError if the actual {@code OffsetDateTime} is not after or equals to the
* {@link java.time.OffsetDateTime} built from given String.
*/
public S isAfterOrEqualTo(String offsetDateTimeAsString) {
assertOffsetDateTimeAsStringParameterIsNotNull(offsetDateTimeAsString);
return isAfterOrEqualTo(OffsetDateTime.parse(offsetDateTimeAsString));
}
/**
* Verifies that the actual {@code OffsetDateTime} is strictly after the given one.
*
* Example :
*
*
*
assertThat(parse("2000-01-01T00:00:00Z")).isAfter(parse("1999-12-31T23:59:59Z"));
*
* @param other the given {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if other {@code OffsetDateTime} is {@code null}.
* @throws AssertionError if the actual {@code OffsetDateTime} is not strictly after the given one.
*/
public S isAfter(OffsetDateTime other) {
Objects.instance().assertNotNull(info, actual);
assertOffsetDateTimeParameterIsNotNull(other);
if (!actual.isAfter(other)) {
throw Failures.instance().failure(info, shouldBeAfter(actual, other));
}
return myself;
}
/**
* Same assertion as {@link #isAfter(java.time.OffsetDateTime)} but the {@link java.time.OffsetDateTime} is built from
* given a String that
* must follow ISO OffsetDateTime format to allow calling {@link java.time.OffsetDateTime#parse(CharSequence)} method.
*
* Example :
*
*
*
// use String in comparison to avoid conversion
* assertThat(parse("2000-01-01T00:00:00Z")).isAfter("1999-12-31T23:59:59Z");
*
* @param offsetDateTimeAsString String representing a {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if given String is null or can't be converted to a
* {@link java.time.OffsetDateTime}.
* @throws AssertionError if the actual {@code OffsetDateTime} is not strictly after the
* {@link java.time.OffsetDateTime} built from given String.
*/
public S isAfter(String offsetDateTimeAsString) {
assertOffsetDateTimeAsStringParameterIsNotNull(offsetDateTimeAsString);
return isAfter(OffsetDateTime.parse(offsetDateTimeAsString));
}
/**
* Same assertion as {@link #isEqualTo(Object)} (where Object is expected to be {@link java.time.OffsetDateTime}) but
* here you
* pass {@link java.time.OffsetDateTime} String representation that must follow ISO OffsetDateTime format to allow calling {@link java.time.OffsetDateTime#parse(CharSequence)} method.
*
* Example :
*
*
*
// use directly String in comparison to avoid writing the code to perform the conversion
* assertThat(parse("2000-01-01T00:00:00Z")).isEqualTo("2000-01-01T00:00:00Z");
*
* @param dateTimeAsString String representing a {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if given String is null or can't be converted to a
* {@link java.time.OffsetDateTime}.
* @throws AssertionError if the actual {@code OffsetDateTime} is not equal to the {@link java.time.OffsetDateTime}
* built from given String.
*/
public S isEqualTo(String dateTimeAsString) {
assertOffsetDateTimeAsStringParameterIsNotNull(dateTimeAsString);
return isEqualTo(OffsetDateTime.parse(dateTimeAsString));
}
/**
* Same assertion as {@link #isNotEqualTo(Object)} (where Object is expected to be {@link java.time.OffsetDateTime})
* but here you
* pass {@link java.time.OffsetDateTime} String representation that must follow ISO OffsetDateTime format to allow calling {@link java.time.OffsetDateTime#parse(CharSequence)} method.
*
* Example :
*
*
*
// use directly String in comparison to avoid writing the code to perform the conversion
* assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo("2000-01-15T00:00:00Z");
*
* @param dateTimeAsString String representing a {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if given String is null or can't be converted to a
* {@link java.time.OffsetDateTime}.
* @throws AssertionError if the actual {@code OffsetDateTime} is equal to the {@link java.time.OffsetDateTime} built
* from given String.
*/
public S isNotEqualTo(String dateTimeAsString) {
assertOffsetDateTimeAsStringParameterIsNotNull(dateTimeAsString);
return isNotEqualTo(OffsetDateTime.parse(dateTimeAsString));
}
/**
* Same assertion as {@link #isIn(Object...)} (where Objects are expected to be {@link java.time.OffsetDateTime}) but
* here you
* pass {@link java.time.OffsetDateTime} String representations that must follow ISO OffsetDateTime format to allow calling {@link java.time.OffsetDateTime#parse(CharSequence)} method.
*
* Example :
*
*
*
// use String based representation of OffsetDateTime
* assertThat(parse("2000-01-01T00:00:00Z")).isIn("1999-12-31T00:00:00Z", "2000-01-01T00:00:00Z");
*
* @param dateTimesAsString String array representing {@link java.time.OffsetDateTime}s.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if given String is null or can't be converted to a
* {@link java.time.OffsetDateTime}.
* @throws AssertionError if the actual {@code OffsetDateTime} is not in the {@link java.time.OffsetDateTime}s built
* from given Strings.
*/
public S isIn(String... dateTimesAsString) {
checkIsNotNullAndNotEmpty(dateTimesAsString);
return isIn(convertToOffsetDateTimeArray(dateTimesAsString));
}
/**
* Same assertion as {@link #isNotIn(Object...)} (where Objects are expected to be {@link java.time.OffsetDateTime})
* but here you
* pass {@link java.time.OffsetDateTime} String representations that must follow ISO OffsetDateTime format to allow calling {@link java.time.OffsetDateTime#parse(CharSequence)} method.
*
* Example :
*
*
*
// use String based representation of OffsetDateTime
* assertThat(parse("2000-01-01T00:00:00Z")).isNotIn("1999-12-31T00:00:00Z", "2000-01-02T00:00:00Z");
*
* @param dateTimesAsString Array of String representing a {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if given String is null or can't be converted to a
* {@link java.time.OffsetDateTime}.
* @throws AssertionError if the actual {@code OffsetDateTime} is in the {@link java.time.OffsetDateTime}s built from
* given Strings.
*/
public S isNotIn(String... dateTimesAsString) {
checkIsNotNullAndNotEmpty(dateTimesAsString);
return isNotIn(convertToOffsetDateTimeArray(dateTimesAsString));
}
/**
* Verifies that actual and given {@code OffsetDateTime} have same year, month, day, hour, minute and second fields,
* (nanosecond fields are ignored in comparison).
*
* Assertion can fail with OffsetDateTimes in same chronological nanosecond time window, e.g :
*
* 2000-01-01T00:00:01.000000000+01:00 and 2000-01-01T00:00:00.999999999+01:00.
*
* Assertion fails as second fields differ even if time difference is only 1ns.
*
* Code example :
*
*
*
// successful assertions
* OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC);
* OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 456, ZoneOffset.UTC);
* assertThat(OffsetDateTime1).isEqualToIgnoringNanos(OffsetDateTime2);
*
* // failing assertions (even if time difference is only 1ns)
* OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC);
* OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 0, 0, 0, 999999999, ZoneOffset.UTC);
* assertThat(OffsetDateTimeA).isEqualToIgnoringNanos(OffsetDateTimeB);
*
* @param other the given {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if other {@code OffsetDateTime} is {@code null}.
* @throws AssertionError if the actual {@code OffsetDateTime} is are not equal with nanoseconds ignored.
*/
public S isEqualToIgnoringNanos(OffsetDateTime other) {
Objects.instance().assertNotNull(info, actual);
assertOffsetDateTimeParameterIsNotNull(other);
if (!areEqualIgnoringNanos(actual, other)) {
throw Failures.instance().failure(info, shouldBeEqualIgnoringNanos(actual, other));
}
return myself;
}
/**
* Verifies that actual and given {@code OffsetDateTime} have same year, month, day, hour, minute, second and
* nanosecond fields,
* (timezone fields are ignored in comparison).
*
* Code example :
*
*
*
// successful assertions
* OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC);
* OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.MAX);
* assertThat(OffsetDateTime1).isEqualToIgnoringTimezone(OffsetDateTime2);
*
* // failing assertions
* OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC);
* OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 0, 0, 0, 999999999, ZoneOffset.UTC);
* assertThat(OffsetDateTimeA).isEqualToIgnoringTimezone(OffsetDateTimeB);
*
* @param other the given {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if other {@code OffsetDateTime} is {@code null}.
* @throws AssertionError if the actual {@code OffsetDateTime} is are not equal with timezone ignored.
*/
public S isEqualToIgnoringTimezone(OffsetDateTime other) {
Objects.instance().assertNotNull(info, actual);
assertOffsetDateTimeParameterIsNotNull(other);
if (!areEqualIgnoringTimezone(actual, other)) {
throw Failures.instance().failure(info, shouldBeEqualIgnoringTimezone(actual, other));
}
return myself;
}
/**
* Verifies that actual and given {@link java.time.OffsetDateTime} have same year, month, day, hour and minute fields
* (second and
* nanosecond fields are ignored in comparison).
*
* Assertion can fail with OffsetDateTimes in same chronological second time window, e.g :
*
* 2000-01-01T00:01:00.000+01:00 and 2000-01-01T00:00:59.000+01:00.
*
* Assertion fails as minute fields differ even if time difference is only 1s.
*
* Code example :
*
*
*
// successful assertions
* OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 23, 50, 0, 0, ZoneOffset.UTC);
* OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 23, 50, 10, 456, ZoneOffset.UTC);
* assertThat(OffsetDateTime1).isEqualToIgnoringSeconds(OffsetDateTime2);
*
* // failing assertions (even if time difference is only 1ms)
* OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 23, 50, 00, 000, ZoneOffset.UTC);
* OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 23, 49, 59, 999, ZoneOffset.UTC);
* assertThat(OffsetDateTimeA).isEqualToIgnoringSeconds(OffsetDateTimeB);
*
* @param other the given {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if other {@code OffsetDateTime} is {@code null}.
* @throws AssertionError if the actual {@code OffsetDateTime} is are not equal with second and nanosecond fields
* ignored.
*/
public S isEqualToIgnoringSeconds(OffsetDateTime other) {
Objects.instance().assertNotNull(info, actual);
assertOffsetDateTimeParameterIsNotNull(other);
if (!areEqualIgnoringSeconds(actual, other)) {
throw Failures.instance().failure(info, shouldBeEqualIgnoringSeconds(actual, other));
}
return myself;
}
/**
* Verifies that actual and given {@code OffsetDateTime} have same year, month, day and hour fields (minute, second
* and
* nanosecond fields are ignored in comparison).
*
* Assertion can fail with OffsetDateTimes in same chronological second time window, e.g :
*
* 2000-01-01T01:00:00.000+01:00 and 2000-01-01T00:59:59.000+01:00.
*
* Time difference is only 1s but hour fields differ.
*
* Code example :
*
*
*
// successful assertions
* OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 23, 50, 0, 0, ZoneOffset.UTC);
* OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 23, 00, 2, 7, ZoneOffset.UTC);
* assertThat(OffsetDateTime1).isEqualToIgnoringMinutes(OffsetDateTime2);
*
* // failing assertions (even if time difference is only 1ms)
* OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 01, 00, 00, 000, ZoneOffset.UTC);
* OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 00, 59, 59, 999, ZoneOffset.UTC);
* assertThat(OffsetDateTimeA).isEqualToIgnoringMinutes(OffsetDateTimeB);
*
* @param other the given {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if other {@code OffsetDateTime} is {@code null}.
* @throws AssertionError if the actual {@code OffsetDateTime} is are not equal ignoring minute, second and nanosecond
* fields.
*/
public S isEqualToIgnoringMinutes(OffsetDateTime other) {
Objects.instance().assertNotNull(info, actual);
assertOffsetDateTimeParameterIsNotNull(other);
if (!areEqualIgnoringMinutes(actual, other)) {
throw Failures.instance().failure(info, shouldBeEqualIgnoringMinutes(actual, other));
}
return myself;
}
/**
* Verifies that actual and given {@code OffsetDateTime} have same year, month and day fields (hour, minute, second
* and
* nanosecond fields are ignored in comparison).
*
* Assertion can fail with OffsetDateTimes in same chronological minute time window, e.g :
*
* 2000-01-01T23:59:00.000+01:00 and 2000-01-02T00:00:00.000+01:00.
*
* Time difference is only 1min but day fields differ.
*
* Code example :
*
*
*
// successful assertions
* OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 23, 59, 59, 999, ZoneOffset.UTC);
* OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 00, 00, 00, 000, ZoneOffset.UTC);
* assertThat(OffsetDateTime1).isEqualToIgnoringHours(OffsetDateTime2);
*
* // failing assertions (even if time difference is only 1ms)
* OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 2, 00, 00, 00, 000, ZoneOffset.UTC);
* OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 23, 59, 59, 999, ZoneOffset.UTC);
* assertThat(OffsetDateTimeA).isEqualToIgnoringHours(OffsetDateTimeB);
*
* @param other the given {@link java.time.OffsetDateTime}.
* @return this assertion object.
* @throws AssertionError if the actual {@code OffsetDateTime} is {@code null}.
* @throws IllegalArgumentException if other {@code OffsetDateTime} is {@code null}.
* @throws AssertionError if the actual {@code OffsetDateTime} is are not equal with second and nanosecond fields
* ignored.
*/
public S isEqualToIgnoringHours(OffsetDateTime other) {
Objects.instance().assertNotNull(info, actual);
assertOffsetDateTimeParameterIsNotNull(other);
if (!haveSameYearMonthAndDayOfMonth(actual, other)) {
throw Failures.instance().failure(info, shouldBeEqualIgnoringHours(actual, other));
}
return myself;
}
/**
* Returns true if both OffsetDateTime are in the same year, month and day of month, hour, minute and second, false
* otherwise.
*
* @param actual the actual OffsetDateTime. expected not be null
* @param other the other OffsetDateTime. expected not be null
* @return true if both OffsetDateTime are in the same year, month and day of month, hour, minute and second, false
* otherwise.
*/
private static boolean areEqualIgnoringNanos(OffsetDateTime actual, OffsetDateTime other) {
return areEqualIgnoringSeconds(actual, other) && actual.getSecond() == other.getSecond();
}
/**
* Returns true if both OffsetDateTime are in the same year, month, day of month, hour and minute, false otherwise.
*
* @param actual the actual OffsetDateTime. expected not be null
* @param other the other OffsetDateTime. expected not be null
* @return true if both OffsetDateTime are in the same year, month, day of month, hour and minute, false otherwise.
*/
private static boolean areEqualIgnoringSeconds(OffsetDateTime actual, OffsetDateTime other) {
return areEqualIgnoringMinutes(actual, other) && actual.getMinute() == other.getMinute();
}
/**
* Returns true if both OffsetDateTime are in the same year, month, day of month and hour, false otherwise.
*
* @param actual the actual OffsetDateTime. expected not be null
* @param other the other OffsetDateTime. expected not be null
* @return true if both OffsetDateTime are in the same year, month, day of month and hour, false otherwise.
*/
private static boolean areEqualIgnoringMinutes(OffsetDateTime actual, OffsetDateTime other) {
return haveSameYearMonthAndDayOfMonth(actual, other) && actual.getHour() == other.getHour();
}
/**
* Returns true if both OffsetDateTime are in the same year, month and day of month, false otherwise.
*
* @param actual the actual OffsetDateTime. expected not be null
* @param other the other OffsetDateTime. expected not be null
* @return true if both OffsetDateTime are in the same year, month and day of month, false otherwise
*/
private static boolean haveSameYearMonthAndDayOfMonth(OffsetDateTime actual, OffsetDateTime other) {
return haveSameYearAndMonth(actual, other) && actual.getDayOfMonth() == other.getDayOfMonth();
}
/**
* Returns true if both OffsetDateTime are in the same year and month, false otherwise.
*
* @param actual the actual OffsetDateTime. expected not be null
* @param other the other OffsetDateTime. expected not be null
* @return true if both OffsetDateTime are in the same year and month, false otherwise
*/
private static boolean haveSameYearAndMonth(OffsetDateTime actual, OffsetDateTime other) {
return haveSameYear(actual, other) && actual.getMonth() == other.getMonth();
}
/**
* Returns true if both OffsetDateTime are in the same year, false otherwise.
*
* @param actual the actual OffsetDateTime. expected not be null
* @param other the other OffsetDateTime. expected not be null
* @return true if both OffsetDateTime are in the same year, false otherwise
*/
private static boolean haveSameYear(OffsetDateTime actual, OffsetDateTime other) {
return actual.getYear() == other.getYear();
}
/**
* Returns true if both OffsetDateTime are in the same hour, minute, second and nanosecond false otherwise.
*
* @param actual the actual OffsetDateTime. expected not be null
* @param other the other OffsetDateTime. expected not be null
* @return true if both OffsetDateTime are in the same hour, minute, second and nanosecond false otherwise.
*/
private static boolean areEqualIgnoringTimezone(OffsetDateTime actual, OffsetDateTime other) {
return areEqualIgnoringNanos(actual, other) && haveSameNano(actual, other);
}
/**
* Returns true if both OffsetDateTime are in the same nanosecond, false otherwise.
*
* @param actual the actual OffsetDateTime. expected not be null
* @param other the other OffsetDateTime. expected not be null
* @return true if both OffsetDateTime are in the same year, false otherwise
*/
private static boolean haveSameNano(OffsetDateTime actual, OffsetDateTime other) {
return actual.getNano() == other.getNano();
}
private static Object[] convertToOffsetDateTimeArray(String... dateTimesAsString) {
OffsetDateTime[] dates = new OffsetDateTime[dateTimesAsString.length];
for (int i = 0; i < dateTimesAsString.length; i++) {
dates[i] = OffsetDateTime.parse(dateTimesAsString[i]);
}
return dates;
}
private void checkIsNotNullAndNotEmpty(Object[] values) {
if (values == null) throw new IllegalArgumentException("The given OffsetDateTime array should not be null");
if (values.length == 0) throw new IllegalArgumentException("The given OffsetDateTime array should not be empty");
}
/**
* Check that the {@link java.time.OffsetDateTime} string representation to compare actual
* {@link java.time.OffsetDateTime} to is not null,
* otherwise throws a {@link IllegalArgumentException} with an explicit message
*
* @param offsetDateTimeAsString String representing the {@link java.time.OffsetDateTime} to compare actual with
* @throws IllegalArgumentException with an explicit message if the given {@link String} is null
*/
private static void assertOffsetDateTimeAsStringParameterIsNotNull(String offsetDateTimeAsString) {
if (offsetDateTimeAsString == null) {
// @format:off
throw new IllegalArgumentException("The String representing the OffsetDateTime to compare actual with should not be null");
// @format:on
}
}
/**
* Check that the {@link java.time.OffsetDateTime} to compare actual {@link java.time.OffsetDateTime} to is not null,
* in that case throws a {@link IllegalArgumentException} with an explicit message
*
* @param other the {@link java.time.OffsetDateTime} to check
* @throws IllegalArgumentException with an explicit message if the given {@link java.time.OffsetDateTime} is null
*/
private static void assertOffsetDateTimeParameterIsNotNull(OffsetDateTime other) {
if (other == null) {
throw new IllegalArgumentException("The OffsetDateTime to compare actual with should not be null");
}
}
} © 2015 - 2024 Weber Informatics LLC | Privacy Policy