Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use contains method of org.assertj.core.api.AbstractOptionalAssert class

Best Assertj code snippet using org.assertj.core.api.AbstractOptionalAssert.contains

Source:AbstractOptionalAssert.java

...103  public SELF isNotPresent() {104    return isEmpty();105  }106  /**107   * Verifies that the actual {@link java.util.Optional} contains the given value (alias of {@link #hasValue(Object)}).108   * <p>109   * Assertion will pass :110   * <pre><code class='java'> assertThat(Optional.of("something")).contains("something");111   * assertThat(Optional.of(10)).contains(10);</code></pre>112   *113   * Assertion will fail :114   * <pre><code class='java'> assertThat(Optional.of("something")).contains("something else");115   * assertThat(Optional.of(20)).contains(10);</code></pre>116   *117   * @param expectedValue the expected value inside the {@link java.util.Optional}.118   * @return this assertion object.119   */120  public SELF contains(VALUE expectedValue) {121    isNotNull();122    checkNotNull(expectedValue);123    if (!actual.isPresent()) throwAssertionError(shouldContain(expectedValue));124    if (!optionalValueComparisonStrategy.areEqual(actual.get(), expectedValue))125      throwAssertionError(shouldContain(actual, expectedValue));126    return myself;127  }128  /**129   * Verifies that the actual {@link java.util.Optional} contains a value and gives this value to the given130   * {@link java.util.function.Consumer} for further assertions. Should be used as a way of deeper asserting on the131   * containing object, as further requirement(s) for the value.132   * <p>133   * Assertions will pass :134   * <pre><code class='java'> // one requirement 135   * assertThat(Optional.of(10)).hasValueSatisfying(i -&gt; { assertThat(i).isGreaterThan(9); });136   *137   * // multiple requirements138   * assertThat(Optional.of(someString)).hasValueSatisfying(s -&gt; {139   *   assertThat(s).isEqualTo("something");140   *   assertThat(s).startsWith("some");141   *   assertThat(s).endsWith("thing");142   * }); </code></pre>143   *144   * Assertions will fail :145   * <pre><code class='java'> assertThat(Optional.of("something")).hasValueSatisfying(s -&gt; {146   *     assertThat(s).isEqualTo("something else");147   *   });148   *149   * // fail because optional is empty, there is no value to perform assertion on  150   * assertThat(Optional.empty()).hasValueSatisfying(o -&gt; {});</code></pre>151   *152   * @param requirement to further assert on the object contained inside the {@link java.util.Optional}.153   * @return this assertion object.154   */155  public SELF hasValueSatisfying(Consumer<VALUE> requirement) {156    assertValueIsPresent();157    requirement.accept(actual.get());158    return myself;159  }160  /**161   * Verifies that the actual {@link Optional} contains a value which satisfies the given {@link Condition}.162   * <p>163   * Examples:164   * <pre><code class='java'> Condition&lt;TolkienCharacter&gt; isAnElf = new Condition&lt;&gt;(character -&gt; character.getRace() == ELF, "an elf"); 165   * 166   * TolkienCharacter legolas = new TolkienCharacter("Legolas", 1000, ELF);167   * TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);168   * 169   * // assertion succeeds170   * assertThat(Optional.of(legolas)).hasValueSatisfying(isAnElf);171   *                                     172   * // assertion fails173   * assertThat(Optional.of(frodo)).hasValueSatisfying(isAnElf);</code></pre>174   *175   * @param condition the given condition.176   * @return this assertion object.177   * @throws AssertionError       if the actual {@link Optional} is null or empty.178   * @throws NullPointerException if the given condition is {@code null}.179   * @throws AssertionError       if the actual value does not satisfy the given condition.180   * @since 3.6.0181   */182  public SELF hasValueSatisfying(Condition<? super VALUE> condition) {183    assertValueIsPresent();184    conditions.assertIs(info, actual.get(), condition);185    return myself;186  }187  /**188   * Verifies that the actual {@link java.util.Optional} contains the given value (alias of {@link #contains(Object)}).189   * <p>190   * Assertion will pass :191   * <pre><code class='java'> assertThat(Optional.of("something")).hasValue("something");192   * assertThat(Optional.of(10)).contains(10);</code></pre>193   *194   * Assertion will fail :195   * <pre><code class='java'> assertThat(Optional.of("something")).hasValue("something else");196   * assertThat(Optional.of(20)).contains(10);</code></pre>197   *198   * @param expectedValue the expected value inside the {@link java.util.Optional}.199   * @return this assertion object.200   */201  public SELF hasValue(VALUE expectedValue) {202    return contains(expectedValue);203  }204  /**205   * Verifies that the actual {@link Optional} contains a value that is an instance of the argument.206   * <p>207   * Assertions will pass:208   *209   * <pre><code class='java'> assertThat(Optional.of("something")).containsInstanceOf(String.class)210   *                                     .containsInstanceOf(Object.class);211   *212   * assertThat(Optional.of(10)).containsInstanceOf(Integer.class);</code></pre>213   *214   * Assertion will fail:215   *216   * <pre><code class='java'> assertThat(Optional.of("something")).containsInstanceOf(Integer.class);</code></pre>217   *218   * @param clazz the expected class of the value inside the {@link Optional}.219   * @return this assertion object.220   */221  public SELF containsInstanceOf(Class<?> clazz) {222    assertValueIsPresent();223    if (!clazz.isInstance(actual.get())) throwAssertionError(shouldContainInstanceOf(actual, clazz));224    return myself;225  }226  /**227   * Use field/property by field/property comparison (including inherited fields/properties) instead of relying on228   * actual type A <code>equals</code> method to compare the {@link Optional} value's object for incoming assertion229   * checks. Private fields are included but this can be disabled using230   * {@link Assertions#setAllowExtractingPrivateFields(boolean)}.231   * <p>232   * This can be handy if <code>equals</code> method of the {@link Optional} value's object to compare does not suit233   * you.234   * </p>235   * Note that the comparison is <b>not</b> recursive, if one of the fields/properties is an Object, it will be236   * compared to the other field/property using its <code>equals</code> method.237   * <p>238   * Example:239   *240   * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);241   * TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);242   *243   * // Fail if equals has not been overridden in TolkienCharacter as equals default implementation only compares references244   * assertThat(Optional.of(frodo)).contains(frodoClone);245   *246   * // frodo and frodoClone are equals when doing a field by field comparison.247   * assertThat(Optional.of(frodo)).usingFieldByFieldValueComparator().contains(frodoClone);</code></pre>248   *249   * @return {@code this} assertion object.250   */251  @CheckReturnValue252  public SELF usingFieldByFieldValueComparator() {253    return usingValueComparator(new FieldByFieldComparator());254  }255  /**256   * Use given custom comparator instead of relying on actual type A <code>equals</code> method to compare the257   * {@link Optional} value's object for incoming assertion checks.258   * <p>259   * Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default260   * comparison strategy.261   * <p>262   * Examples :263   *264   * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);265   * TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);266   *267   * // Fail if equals has not been overridden in TolkienCharacter as equals default implementation only compares references268   * assertThat(Optional.of(frodo)).contains(frodoClone);269   *270   * // frodo and frodoClone are equals when doing a field by field comparison.271   * assertThat(Optional.of(frodo)).usingValueComparator(new FieldByFieldComparator()).contains(frodoClone);</code></pre>272   *273   * @param customComparator the comparator to use for incoming assertion checks.274   * @throws NullPointerException if the given comparator is {@code null}.275   * @return {@code this} assertion object.276   */277  @CheckReturnValue278  public SELF usingValueComparator(Comparator<? super VALUE> customComparator) {279    optionalValueComparisonStrategy = new ComparatorBasedComparisonStrategy(customComparator);280    return myself;281  }282  /**283   * Revert to standard comparison for incoming assertion {@link Optional} value checks.284   * <p>285   * This method should be used to disable a custom comparison strategy set by calling286   * {@link #usingValueComparator(Comparator)}.287   *288   * @return {@code this} assertion object.289   */290  @CheckReturnValue291  public SELF usingDefaultValueComparator() {292    // fall back to default strategy to compare actual with other objects.293    optionalValueComparisonStrategy = StandardComparisonStrategy.instance();294    return myself;295  }296  /**297   * Verifies that the actual {@link java.util.Optional} contains the instance given as an argument (i.e. it must be the298   * same instance).299   * <p>300   * Assertion will pass :301   *302   * <pre><code class='java'> String someString = "something";303   * assertThat(Optional.of(someString)).containsSame(someString);304   *305   * // Java will create the same 'Integer' instance when boxing small ints306   * assertThat(Optional.of(10)).containsSame(10);</code></pre>307   *308   * Assertion will fail :309   *310   * <pre><code class='java'> // not even equal:311   * assertThat(Optional.of("something")).containsSame("something else");312   * assertThat(Optional.of(20)).containsSame(10);313   *314   * // equal but not the same: 315   * assertThat(Optional.of(new String("something"))).containsSame(new String("something"));316   * assertThat(Optional.of(new Integer(10))).containsSame(new Integer(10));</code></pre>317   *318   * @param expectedValue the expected value inside the {@link java.util.Optional}.319   * @return this assertion object.320   */321  public SELF containsSame(VALUE expectedValue) {322    isNotNull();323    checkNotNull(expectedValue);324    if (!actual.isPresent()) throwAssertionError(shouldContain(expectedValue));325    if (actual.get() != expectedValue) throwAssertionError(shouldContainSame(actual, expectedValue));326    return myself;327  }328  /**329   * Call {@link Optional#flatMap(Function) flatMap} on the {@code Optional} under test, assertions chained afterwards are performed on the {@code Optional} resulting from the flatMap call.330   * <p>331   * Examples:332   * <pre><code class='java'> Function&lt;String, Optional&lt;String&gt;&gt; UPPER_CASE_OPTIONAL_STRING = 333   *       s -&gt; s == null ? Optional.empty() : Optional.of(s.toUpperCase());334   * 335   * // assertions succeed336   * assertThat(Optional.of("something")).contains("something")337   *                                     .flatMap(UPPER_CASE_OPTIONAL_STRING)338   *                                     .contains("SOMETHING");339   *                                     340   * assertThat(Optional.&lt;String&gt;empty()).flatMap(UPPER_CASE_OPTIONAL_STRING)341   *                                     .isEmpty();342   *                                     343   * assertThat(Optional.&lt;String&gt;ofNullable(null)).flatMap(UPPER_CASE_OPTIONAL_STRING)344   *                                              .isEmpty();345   *                                     346   * // assertion fails347   * assertThat(Optional.of("something")).flatMap(UPPER_CASE_OPTIONAL_STRING)348   *                                     .contains("something");</code></pre>349   *350   * @param <U> the type wrapped in the {@link Optional} after the {@link Optional#flatMap(Function) flatMap} operation.351   * @param mapper the {@link Function} to use in the {@link Optional#flatMap(Function) flatMap} operation.352   * @return a new {@link AbstractOptionalAssert} for assertions chaining on the flatMap of the Optional.353   * @throws AssertionError if the actual {@link Optional} is null.354   * @since 3.6.0355   */356  @CheckReturnValue357  public <U> AbstractOptionalAssert<?, U> flatMap(Function<? super VALUE, Optional<U>> mapper) {358    isNotNull();359    return assertThat(actual.flatMap(mapper));360  }361  /**362   * Call {@link Optional#map(Function) map} on the {@code Optional} under test, assertions chained afterwards are performed on the {@code Optional} resulting from the map call.363   * <p>364   * Examples:365   * <pre><code class='java'> // assertions succeed 366   * assertThat(Optional.&lt;String&gt;empty()).map(String::length)367   *                                     .isEmpty();368   * 369   * assertThat(Optional.of("42")).contains("42")370   *                              .map(String::length)371   *                              .contains(2);372   *                              373   * // assertion fails374   * assertThat(Optional.of("42")).map(String::length)375   *                              .contains(3);</code></pre>376   *377   * @param <U> the type wrapped in the {@link Optional} after the {@link Optional#map(Function) map} operation.378   * @param mapper the {@link Function} to use in the {@link Optional#map(Function) map} operation.379   * @return a new {@link AbstractOptionalAssert} for assertions chaining on the map of the Optional.380   * @throws AssertionError if the actual {@link Optional} is null.381   * @since 3.6.0382   */383  @CheckReturnValue384  public <U> AbstractOptionalAssert<?, U> map(Function<? super VALUE, ? extends U> mapper) {385    isNotNull();386    return assertThat(actual.map(mapper));387  }388  /**389   * Verifies that the actual {@link Optional} is not {@code null} and not empty and returns an Object assertion ...

Source:AssertJOptionalRules.java

...79    AbstractAssert<?, ?> before(AbstractOptionalAssert<?, T> optionalAssert, T value) {80      return Refaster.anyOf(81          optionalAssert.get().isEqualTo(value),82          optionalAssert.isEqualTo(Optional.of(value)),83          optionalAssert.contains(value),84          optionalAssert.isPresent().hasValue(value));85    }86    @AfterTemplate87    AbstractOptionalAssert<?, T> after(AbstractOptionalAssert<?, T> optionalAssert, T value) {88      return optionalAssert.hasValue(value);89    }90  }91  static final class AbstractOptionalAssertContainsSame<T> {92    @BeforeTemplate93    AbstractAssert<?, ?> before(AbstractOptionalAssert<?, T> optionalAssert, T value) {94      return Refaster.anyOf(95          optionalAssert.get().isSameAs(value), optionalAssert.isPresent().isSameAs(value));96    }97    @AfterTemplate98    AbstractOptionalAssert<?, T> after(AbstractOptionalAssert<?, T> optionalAssert, T value) {99      return optionalAssert.containsSame(value);100    }101  }102  static final class AssertThatOptionalHasValueMatching<T> {103    @BeforeTemplate104    AbstractOptionalAssert<?, T> before(Optional<T> optional, Predicate<? super T> predicate) {105      return assertThat(optional.filter(predicate)).isPresent();106    }107    @AfterTemplate108    @UseImportPolicy(STATIC_IMPORT_ALWAYS)109    AbstractObjectAssert<?, T> after(Optional<T> optional, Predicate<? super T> predicate) {110      return assertThat(optional).get().matches(predicate);111    }112  }113}...

contains

Using AI Code Generation

1import java.util.Optional;2import org.assertj.core.api.AbstractOptionalAssert;3import org.assertj.core.api.Assertions;4public class 1 {5    public static void main(String[] args) {6        AbstractOptionalAssert<?, ?> optionalAssert = Assertions.assertThat(Optional.of("test"));7        optionalAssert.contains("test");8    }9}10import java.util.Optional;11import org.assertj.core.api.AbstractOptionalAssert;12import org.assertj.core.api.Assertions;13public class 1 {14    public static void main(String[] args) {15        AbstractOptionalAssert<?, ?> optionalAssert = Assertions.assertThat(Optional.of("test"));16        optionalAssert.contains("test");17    }18}

contains

Using AI Code Generation

1import java.util.Optional;2import org.assertj.core.api.Assertions;3public class 1 {4    public static void main(String[] args) {5        Optional<String> optional = Optional.of("foo");6        Assertions.assertThat(optional).contains("foo");7    }8}9import java.util.Optional;10import org.assertj.core.api.Assertions;11public class 2 {12    public static void main(String[] args) {13        Optional<String> optional = Optional.of("foo");14        Assertions.assertThat(optional).contains("foo");15    }16}17import java.util.Optional;18import org.assertj.core.api.Assertions;19public class 3 {20    public static void main(String[] args) {21        Optional<String> optional = Optional.of("foo");22        Assertions.assertThat(optional).contains("foo");23    }24}25import java.util.Optional;26import org.assertj.core.api.Assertions;27public class 4 {28    public static void main(String[] args) {29        Optional<String> optional = Optional.of("foo");30        Assertions.assertThat(optional).contains("foo");31    }32}33import java.util.Optional;34import org.assertj.core.api.Assertions;35public class 5 {36    public static void main(String[] args) {37        Optional<String> optional = Optional.of("foo");38        Assertions.assertThat(optional).contains("foo");39    }40}41import java.util.Optional;42import org.assertj.core.api.Assertions;43public class 6 {44    public static void main(String[] args) {45        Optional<String> optional = Optional.of("foo");46        Assertions.assertThat(optional).contains("foo");47    }48}49import java.util.Optional;50import org.assertj.core.api.Assertions;51public class 7 {52    public static void main(String[] args) {53        Optional<String> optional = Optional.of("foo");54        Assertions.assertThat(optional).contains("foo");55    }56}

contains

Using AI Code Generation

1import org.assertj.core.api.AbstractOptionalAssert;2import org.assertj.core.api.Assertions;3import org.junit.Test;4import java.util.Optional;5public class AssertjOptionalAssertTest {6    public void testOptionalAssert() {7        Optional<String> optional = Optional.of("test");8        AbstractOptionalAssert<?, String> optionalAssert = Assertions.assertThat(optional);9        optionalAssert.contains("test");10    }11}12import org.assertj.core.api.Assertions;13import org.junit.Test;14import java.util.Optional;15public class AssertjOptionalAssertTest {16    public void testOptionalAssert() {17        Optional<String> optional = Optional.of("test");18        Assertions.assertThat(optional).contains("test");19    }20}21import org.assertj.core.api.Assertions;22import org.junit.Test;23import java.util.Optional;24public class AssertjOptionalAssertTest {25    public void testOptionalAssert() {26        Optional<String> optional = Optional.of("test");27        Assertions.assertThat(optional).contains("test");28    }29}30import org.assertj.core.api.Assertions;31import org.junit.Test;32import java.util.Optional;33public class AssertjOptionalAssertTest {34    public void testOptionalAssert() {35        Optional<String> optional = Optional.of("test");36        Assertions.assertThat(optional).contains("test");37    }38}39import org.assertj.core.api.Assertions;40import org.junit.Test;41import java.util.Optional;42public class AssertjOptionalAssertTest {43    public void testOptionalAssert() {44        Optional<String> optional = Optional.of("test");45        Assertions.assertThat(optional).contains("test");46    }47}48import org.assertj.core.api.Assertions;49import org.junit.Test;50import java.util.Optional;51public class AssertjOptionalAssertTest {52    public void testOptionalAssert() {53        Optional<String> optional = Optional.of("test");54        Assertions.assertThat(optional).contains("test");

contains

Using AI Code Generation

1public class Example {2    public static void main(String[] args) {3        Optional<String> opt = Optional.of("Hello World");4        assertThat(opt).contains("Hello World");5    }6}7public class Example {8    public static void main(String[] args) {9        Optional<String> opt = Optional.of("Hello World");10        assertThat(opt).contains("Hello World");11    }12}

contains

Using AI Code Generation

1import org.assertj.core.api.AbstractOptionalAssert;2import org.assertj.core.api.Assertions;3import java.util.Optional;4public class AssertJExample {5    public static void main(String[] args) {6        Optional<String> optional = Optional.of("Hello");7        AbstractOptionalAssert<?, ? extends Optional<?>> assertion = Assertions.assertThat(optional);8        assertion.contains("Hello");9    }10}11import org.assertj.core.api.AbstractOptionalAssert;12import org.assertj.core.api.Assertions;13import java.util.Optional;14public class AssertJExample {15    public static void main(String[] args) {16        Optional<String> optional = Optional.of("Hello");17        AbstractOptionalAssert<?, ? extends Optional<?>> assertion = Assertions.assertThat(optional);18        assertion.contains("Hello");19    }20}21import org.assertj.core.api.AbstractOptionalAssert;22import org.assertj.core.api.Assertions;23import java.util.Optional;24public class AssertJExample {25    public static void main(String[] args) {26        Optional<String> optional = Optional.of("Hello");27        AbstractOptionalAssert<?, ? extends Optional<?>> assertion = Assertions.assertThat(optional);28        assertion.contains("Hello");29    }30}31import org.assertj.core.api.AbstractOptionalAssert;32import org.assertj.core.api.Assertions;33import java.util.Optional;34public class AssertJExample {35    public static void main(String[] args) {36        Optional<String> optional = Optional.of("Hello");37        AbstractOptionalAssert<?, ? extends Optional<?>> assertion = Assertions.assertThat(optional);38        assertion.contains("Hello");39    }40}41import org.assertj.core.api.AbstractOptionalAssert;42import org.assertj.core.api.Assertions;43import java.util.Optional;44public class AssertJExample {45    public static void main(String[] args) {46        Optional<String> optional = Optional.of("Hello");47        AbstractOptionalAssert<?, ? extends Optional<?>> assertion = Assertions.assertThat(optional);48        assertion.contains("Hello");49    }50}51import org.assertj.core.api.AbstractOptionalAssert;52import org.assertj.core.api.Assertions;53import java.util.Optional;54public class AssertJExample {55    public static void main(String[] args) {56        Optional<String> optional = Optional.of("Hello");57        AbstractOptionalAssert<?, ? extends Optional<?>> assertion = Assertions.assertThat(optional);58        assertion.contains("Hello");59    }60}61import org.assertj.core.api.AbstractOptionalAssert;62import org.assertj.core.api.Assertions;63import java

contains

Using AI Code Generation

1package org.example;2import static org.assertj.core.api.Assertions.assertThat;3import java.util.Optional;4public class App {5    public static void main(String[] args) {6        Optional<String> optional = Optional.of("abc");7        assertThat(optional).contains("abc");8    }9}

contains

Using AI Code Generation

1import java.util.Optional;2import org.assertj.core.api.Assertions;3public class OptionalAssertContains {4public static void main(String[] args) {5Optional<String> opt = Optional.of("Hello");6Assertions.assertThat(opt).contains("Hello");7}8}9<"Optional.empty"> at org.junit.Assert.assertEquals(Assert.java:115) at org.junit.Assert.assertEquals(Assert.java:144) at org.assertj.core.api.AbstractOptionalAssert.contains(AbstractOptionalAssert.java:137) at OptionalAssertContains.main(OptionalAssertContains.java:14)10import java.util.Optional;11import org.assertj.core.api.Assertions;12public class OptionalAssertContains {13public static void main(String[] args) {14Optional<String> opt = Optional.of("Hello");15Assertions.assertThat(opt).contains("Hello");16}17}18<"Optional.empty"> at org.junit.Assert.assertEquals(Assert.java:115) at org.junit.Assert.assertEquals(Assert.java:144) at org.assertj.core.api.AbstractOptionalAssert.contains(AbstractOptionalAssert.java:137) at OptionalAssertContains.main(OptionalAssertContains.java:14)19import java.util.Optional;20import org.assertj.core.api.Assertions;21public class OptionalAssertContains {22public static void main(String[] args) {23Optional<String> opt = Optional.of("Hello");24Assertions.assertThat(opt).contains("Hello");25}26}27<"Optional.empty"> at org.junit.Assert.assertEquals(Assert.java:115) at org.junit.Assert.assertEquals(Assert.java:144) at org.assertj.core.api.AbstractOptionalAssert.contains(AbstractOptionalAssert.java:137) at OptionalAssertContains

contains

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import java.util.Optional;3public class AssertjOptional {4   public static void main(String[] args) {5      Optional<String> opt = Optional.of("Hello World");6      assertThat(opt).contains("Hello World");7   }8}9import static org.assertj.core.api.Assertions.assertThat;10import java.util.Optional;11public class AssertjOptional {12   public static void main(String[] args) {13      Optional<String> opt = Optional.of("Hello World");14      assertThat(opt).contains("Hello World");15   }16}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.