All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.github.theangrydev.fluentbdd.assertj.WithFluentAssertJ 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 io.github.theangrydev.fluentbdd.assertj;
import io.github.theangrydev.fluentbdd.core.WithFluentBdd;
import java.io.File;
import java.io.InputStream;
import java.math.BigDecimal;
import java.nio.charset.Charset;
import java.text.DateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.ZonedDateTime;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.OptionalInt;
import java.util.OptionalLong;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Stream;
import org.assertj.core.api.AbstractBigDecimalAssert;
import org.assertj.core.api.AbstractBooleanArrayAssert;
import org.assertj.core.api.AbstractBooleanAssert;
import org.assertj.core.api.AbstractByteArrayAssert;
import org.assertj.core.api.AbstractByteAssert;
import org.assertj.core.api.AbstractCharArrayAssert;
import org.assertj.core.api.AbstractCharSequenceAssert;
import org.assertj.core.api.AbstractCharacterAssert;
import org.assertj.core.api.AbstractClassAssert;
import org.assertj.core.api.AbstractComparableAssert;
import org.assertj.core.api.AbstractDateAssert;
import org.assertj.core.api.AbstractDoubleArrayAssert;
import org.assertj.core.api.AbstractDoubleAssert;
import org.assertj.core.api.AbstractFileAssert;
import org.assertj.core.api.AbstractFloatArrayAssert;
import org.assertj.core.api.AbstractFloatAssert;
import org.assertj.core.api.AbstractInputStreamAssert;
import org.assertj.core.api.AbstractIntArrayAssert;
import org.assertj.core.api.AbstractIntegerAssert;
import org.assertj.core.api.AbstractIterableAssert;
import org.assertj.core.api.AbstractListAssert;
import org.assertj.core.api.AbstractLocalDateAssert;
import org.assertj.core.api.AbstractLocalDateTimeAssert;
import org.assertj.core.api.AbstractLocalTimeAssert;
import org.assertj.core.api.AbstractLongArrayAssert;
import org.assertj.core.api.AbstractLongAssert;
import org.assertj.core.api.AbstractMapAssert;
import org.assertj.core.api.AbstractObjectArrayAssert;
import org.assertj.core.api.AbstractObjectAssert;
import org.assertj.core.api.AbstractOffsetDateTimeAssert;
import org.assertj.core.api.AbstractOffsetTimeAssert;
import org.assertj.core.api.AbstractShortArrayAssert;
import org.assertj.core.api.AbstractShortAssert;
import org.assertj.core.api.AbstractThrowableAssert;
import org.assertj.core.api.AbstractZonedDateTimeAssert;
import org.assertj.core.api.AssertDelegateTarget;
import org.assertj.core.api.CompletableFutureAssert;
import org.assertj.core.api.Condition;
import org.assertj.core.api.ObjectAssert;
import org.assertj.core.api.OptionalAssert;
import org.assertj.core.api.OptionalDoubleAssert;
import org.assertj.core.api.OptionalIntAssert;
import org.assertj.core.api.OptionalLongAssert;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.assertj.core.api.ThrowableTypeAssert;
import org.assertj.core.api.filter.Filters;
import org.assertj.core.condition.DoesNotHave;
import org.assertj.core.condition.Not;
import org.assertj.core.data.Index;
import org.assertj.core.data.MapEntry;
import org.assertj.core.data.Offset;
import org.assertj.core.groups.Properties;
import org.assertj.core.groups.Tuple;
/**
* This file was generated by the assertj-extensions-generator module of fluent-bdd using the org.assertj.core.api.WithAssertions.java source code.
* The original documentation from WithAssertions.java has been preserved.
* The modifications involve renaming 'assertThat' methods to 'then' and 'and' to better match the language used in fluent-bdd.
*
* A unified entry point to all non-deprecated assertions from both the new Java 8 core API and the pre-Java 8 core API.
*
* As a convenience, the methods are defined in an interface so that no static imports are necessary if the test class
* implements this interface.
*
* Based on an idea by David Gageot :
*
* http://blog.javabien.net/2014/04/23/what-if-assertj-used-java-8/
*
* @author Alan Rothkopf
*
*/
@SuppressWarnings("PMD")
public interface WithFluentAssertJ extends WithFluentBdd {
DelegateWithAssertions DELEGATE = new DelegateWithAssertions();
/**
* Delegate call to {@link org.assertj.core.api.Assertions#offset(Float)}
*/
default Offset offset(Float value) {
return DELEGATE.offset(value);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#offset(Double)}
*/
default Offset offset(Double value) {
return DELEGATE.offset(value);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#entry(Object, Object)}
*/
default MapEntry entry(K key, V value) {
return DELEGATE.entry(key,value);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#fail(String)}
*/
default void fail(String failureMessage) {
DELEGATE.fail(failureMessage);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#fail(String,Throwable)}
*/
default void fail(String failureMessage, Throwable realCause) {
DELEGATE.fail(failureMessage,realCause);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#not(Condition)}
*/
default Not not(Condition condition) {
return DELEGATE.not(condition);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#allOf(Iterable)}
*/
default Condition allOf(Iterable> conditions) {
return DELEGATE.allOf(conditions);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#allOf(Condition[])}
*/
@SuppressWarnings("unchecked")
default Condition allOf(Condition conditions) {
return DELEGATE.allOf(conditions);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(T[])}
*/
default AbstractObjectArrayAssert then(T[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(T[])}
*/
default AbstractObjectArrayAssert and(T[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(AssertDelegateTarget)}
*/
default T then(T assertion) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(assertion);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(AssertDelegateTarget)}
*/
default T and(T assertion) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(assertion);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Map)}
*/
default AbstractMapAssert, K, V> then(Map actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Map)}
*/
default AbstractMapAssert, K, V> and(Map actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(short)}
*/
default AbstractShortAssert then(short actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(short)}
*/
default AbstractShortAssert and(short actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(long)}
*/
default AbstractLongAssert then(long actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(long)}
*/
default AbstractLongAssert and(long actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Long)}
*/
default AbstractLongAssert then(Long actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Long)}
*/
default AbstractLongAssert and(Long actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(long[])}
*/
default AbstractLongArrayAssert then(long[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(long[])}
*/
default AbstractLongArrayAssert and(long[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(T)}
*/
default AbstractObjectAssert then(T actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(T)}
*/
default AbstractObjectAssert and(T actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(String)}
*/
default AbstractCharSequenceAssert then(String actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(String)}
*/
default AbstractCharSequenceAssert and(String actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Date)}
*/
default AbstractDateAssert then(Date actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Date)}
*/
default AbstractDateAssert and(Date actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Throwable)}
*/
default AbstractThrowableAssert then(Throwable actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Throwable)}
*/
default AbstractThrowableAssert and(Throwable actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(BigDecimal)}
*/
default AbstractBigDecimalAssert then(BigDecimal actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(BigDecimal)}
*/
default AbstractBigDecimalAssert and(BigDecimal actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(CharSequence)}
*/
default AbstractCharSequenceAssert then(CharSequence actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(CharSequence)}
*/
default AbstractCharSequenceAssert and(CharSequence actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(short[])}
*/
default AbstractShortArrayAssert then(short[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(short[])}
*/
default AbstractShortArrayAssert and(short[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Short)}
*/
default AbstractShortAssert then(Short actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Short)}
*/
default AbstractShortAssert and(Short actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Class)}
*/
default AbstractClassAssert then(Class actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Class)}
*/
default AbstractClassAssert and(Class actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Character)}
*/
default AbstractCharacterAssert then(Character actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Character)}
*/
default AbstractCharacterAssert and(Character actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(char[])}
*/
default AbstractCharArrayAssert then(char[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(char[])}
*/
default AbstractCharArrayAssert and(char[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(char)}
*/
default AbstractCharacterAssert then(char actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(char)}
*/
default AbstractCharacterAssert and(char actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Comparable)}
*/
default > AbstractComparableAssert then(T actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Comparable)}
*/
default > AbstractComparableAssert and(T actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Iterable)}
*/
default AbstractIterableAssert, T, ObjectAssert> then(Iterable actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Iterable)}
*/
default AbstractIterableAssert, T, ObjectAssert> and(Iterable actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Iterator)}
*/
default AbstractIterableAssert, T, ObjectAssert> then(Iterator actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Iterator)}
*/
default AbstractIterableAssert, T, ObjectAssert> and(Iterator actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Boolean)}
*/
default AbstractBooleanAssert then(Boolean actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Boolean)}
*/
default AbstractBooleanAssert and(Boolean actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(boolean)}
*/
default AbstractBooleanArrayAssert then(boolean[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(boolean)}
*/
default AbstractBooleanArrayAssert and(boolean[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(byte)}
*/
default AbstractByteAssert then(byte actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(byte)}
*/
default AbstractByteAssert and(byte actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Byte)}
*/
default AbstractByteAssert then(Byte actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Byte)}
*/
default AbstractByteAssert and(Byte actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(byte[])}
*/
default AbstractByteArrayAssert then(byte[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(byte[])}
*/
default AbstractByteArrayAssert and(byte[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(boolean)}
*/
default AbstractBooleanAssert then(boolean actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(boolean)}
*/
default AbstractBooleanAssert and(boolean actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(float)}
*/
default AbstractFloatAssert then(float actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(float)}
*/
default AbstractFloatAssert and(float actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(InputStream)}
*/
default AbstractInputStreamAssert then(InputStream actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(InputStream)}
*/
default AbstractInputStreamAssert and(InputStream actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(File)}
*/
default AbstractFileAssert then(File actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(File)}
*/
default AbstractFileAssert and(File actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(int[])}
*/
default AbstractIntArrayAssert then(int[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(int[])}
*/
default AbstractIntArrayAssert and(int[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Float)}
*/
default AbstractFloatAssert then(Float actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Float)}
*/
default AbstractFloatAssert and(Float actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(int)}
*/
default AbstractIntegerAssert then(int actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(int)}
*/
default AbstractIntegerAssert and(int actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(float[])}
*/
default AbstractFloatArrayAssert then(float[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(float[])}
*/
default AbstractFloatArrayAssert and(float[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Integer)}
*/
default AbstractIntegerAssert then(Integer actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Integer)}
*/
default AbstractIntegerAssert and(Integer actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(double)}
*/
default AbstractDoubleAssert then(double actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(double)}
*/
default AbstractDoubleAssert and(double actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Double)}
*/
default AbstractDoubleAssert then(Double actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Double)}
*/
default AbstractDoubleAssert and(Double actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(List)}
*/
default AbstractListAssert, T, ObjectAssert> then(List actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(List)}
*/
default AbstractListAssert, T, ObjectAssert> and(List actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(List)}
*/
default AbstractListAssert, T, ObjectAssert> then(Stream actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(List)}
*/
default AbstractListAssert, T, ObjectAssert> and(Stream actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(double[])}
*/
default AbstractDoubleArrayAssert then(double[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(double[])}
*/
default AbstractDoubleArrayAssert and(double[] actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#extractProperty(String)}
*/
default Properties extractProperty(String propertyName) {
return DELEGATE.extractProperty(propertyName);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#extractProperty(String,Class)}
*/
default Properties extractProperty(String propertyName, Class propertyType) {
return DELEGATE.extractProperty(propertyName,propertyType);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#tuple(Object[])}
*/
default Tuple tuple(Object values) {
return DELEGATE.tuple(values);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#atIndex(int)}
*/
default Index atIndex(int actual) {
return DELEGATE.atIndex(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#within(Double)}
*/
default Offset within(Double actual) {
return DELEGATE.within(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#within(BigDecimal)}
*/
default Offset within(BigDecimal actual) {
return DELEGATE.within(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#within(Float)}
*/
default Offset within(Float actual) {
return DELEGATE.within(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#anyOf(Iterable)}
*/
default Condition anyOf(Iterable> conditions) {
return DELEGATE.anyOf(conditions);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#anyOf(Condition[])}
*/
@SuppressWarnings("unchecked")
default Condition anyOf(Condition conditions) {
return DELEGATE.anyOf(conditions);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#doesNotHave(Condition)}
*/
default DoesNotHave doesNotHave(Condition condition) {
return DELEGATE.doesNotHave(condition);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#contentOf(File,String)}
*/
default String contentOf(File file, String charsetName) {
return DELEGATE.contentOf(file,charsetName);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#contentOf(File)}
*/
default String contentOf(File actual) {
return DELEGATE.contentOf(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#contentOf(File,Charset)}
*/
default String contentOf(File file, Charset charset) {
return DELEGATE.contentOf(file,charset);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#linesOf(File)}
*/
default List linesOf(File actual) {
return DELEGATE.linesOf(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#linesOf(File,String)}
*/
default List linesOf(File file, String charsetName) {
return DELEGATE.linesOf(file,charsetName);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#linesOf(File,Charset)}
*/
default List linesOf(File actual, Charset arg1) {
return DELEGATE.linesOf(actual,arg1);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#setRemoveAssertJRelatedElementsFromStackTrace}
*/
default void setRemoveAssertJRelatedElementsFromStackTrace(boolean actual) {
DELEGATE.setRemoveAssertJRelatedElementsFromStackTrace(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#failBecauseExceptionWasNotThrown}
*/
default void failBecauseExceptionWasNotThrown(Class exceptionClass) {
DELEGATE.failBecauseExceptionWasNotThrown(exceptionClass);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#setAllowExtractingPrivateFields}
*/
default void setAllowExtractingPrivateFields(boolean actual) {
DELEGATE.setAllowExtractingPrivateFields(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#registerCustomDateFormat(DateFormat)}
*/
default void registerCustomDateFormat(DateFormat actual) {
DELEGATE.registerCustomDateFormat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#registerCustomDateFormat(String)}
*/
default void registerCustomDateFormat(String actual) {
DELEGATE.registerCustomDateFormat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#useDefaultDateFormatsOnly}
*/
default void useDefaultDateFormatsOnly() {
DELEGATE.useDefaultDateFormatsOnly();
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(ZonedDateTime)}
*/
default AbstractZonedDateTimeAssert then(ZonedDateTime actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(ZonedDateTime)}
*/
default AbstractZonedDateTimeAssert and(ZonedDateTime actual) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(actual);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(CompletableFuture)}
*/
default CompletableFutureAssert then(CompletableFuture future) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(future);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(CompletableFuture)}
*/
default CompletableFutureAssert and(CompletableFuture future) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(future);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Optional)}
*/
default OptionalAssert then(Optional optional) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(optional);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(Optional)}
*/
default OptionalAssert and(Optional optional) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(optional);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(java.util.OptionalDouble)}
*/
default OptionalDoubleAssert then(OptionalDouble optional) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(optional);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(java.util.OptionalDouble)}
*/
default OptionalDoubleAssert and(OptionalDouble optional) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(optional);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(java.util.OptionalInt)}
*/
default OptionalIntAssert then(OptionalInt optional) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(optional);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(java.util.OptionalInt)}
*/
default OptionalIntAssert and(OptionalInt optional) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(optional);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(java.util.OptionalLong)}
*/
default OptionalLongAssert then(OptionalLong optional) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(optional);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(java.util.OptionalLong)}
*/
default OptionalLongAssert and(OptionalLong optional) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(optional);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(LocalDateTime)}
*/
default AbstractLocalDateTimeAssert then(LocalDateTime localDateTime) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(localDateTime);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(LocalDateTime)}
*/
default AbstractLocalDateTimeAssert and(LocalDateTime localDateTime) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(localDateTime);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(LocalDate)}
*/
default AbstractLocalDateAssert then(LocalDate localDate) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(localDate);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(LocalDate)}
*/
default AbstractLocalDateAssert and(LocalDate localDate) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(localDate);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(LocalTime)}
*/
default AbstractLocalTimeAssert then(LocalTime localTime) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(localTime);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(LocalTime)}
*/
default AbstractLocalTimeAssert and(LocalTime localTime) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(localTime);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(OffsetTime)}
*/
default AbstractOffsetTimeAssert then(OffsetTime offsetTime) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(offsetTime);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(OffsetTime)}
*/
default AbstractOffsetTimeAssert and(OffsetTime offsetTime) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(offsetTime);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(OffsetDateTime)}
*/
default AbstractOffsetDateTimeAssert then(OffsetDateTime offsetDateTime) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(offsetDateTime);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThat(OffsetDateTime)}
*/
default AbstractOffsetDateTimeAssert and(OffsetDateTime offsetDateTime) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThat(offsetDateTime);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThatThrownBy(ThrowingCallable)}
*/
default AbstractThrowableAssert thenThrownBy(ThrowingCallable shouldRaiseThrowable) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThatThrownBy(shouldRaiseThrowable);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#assertThatThrownBy(ThrowingCallable)}
*/
default AbstractThrowableAssert andThrownBy(ThrowingCallable shouldRaiseThrowable) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThatThrownBy(shouldRaiseThrowable);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#catchThrowable(ThrowingCallable)}
*/
default Throwable catchThrowable(ThrowingCallable shouldRaiseThrowable) {
return DELEGATE.catchThrowable(shouldRaiseThrowable);
}
/**
* Entry point to check that an exception of type T is thrown by a given {@code throwingCallable}
* which allows to chain assertions on the thrown exception.
*
* Example:
*
assertThatExceptionOfType(IOException.class).isThrownBy(() -> { throw new IOException("boom!"); })
* .withMessage("boom!"); ThrowableTypeAssert thenExceptionOfType(Class exceptionType) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThatExceptionOfType(exceptionType);
}
/**
* Entry point to check that an exception of type T is thrown by a given {@code throwingCallable}
* which allows to chain assertions on the thrown exception.
*
* Example:
*
assertThatExceptionOfType(IOException.class).isThrownBy(() -> { throw new IOException("boom!"); })
* .withMessage("boom!"); ThrowableTypeAssert andExceptionOfType(Class exceptionType) {
fluentBdd().verification.recordThen(this);
return DELEGATE.assertThatExceptionOfType(exceptionType);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#filter(E[])}
*/
default Filters filter(E[] array) {
return DELEGATE.filter(array);
}
/**
* Delegate call to {@link org.assertj.core.api.Assertions#filter(Iterable)}
*/
default Filters filter(Iterable iterableToFilter) {
return DELEGATE.filter(iterableToFilter);
}
}
