All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • 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!"); 
    
	 *
	 * This method is more or less the same of {@link #thenThrownBy(ThrowingCallable)} but in a more natural way.
	 * @param actual the actual value.
	 * @return the created {@link ThrowableTypeAssert}.
	 */
	default  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!"); 
    
	 *
	 * This method is more or less the same of {@link #andThrownBy(ThrowingCallable)} but in a more natural way.
	 * @param actual the actual value.
	 * @return the created {@link ThrowableTypeAssert}.
	 */
	default  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);
	}
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy