How to use OptionalAssert class of org.assertj.core.api package

Best Assertj code snippet using org.assertj.core.api.OptionalAssert

Source:OptionalAssertionsExamples.java

...30 * {@link Optional} assertions example.31 *32 * @author Joel Costigliola33 */34public class OptionalAssertionsExamples extends AbstractAssertionsExamples {35  @Test36  public void optional_assertions_examples() {37    Optional<String> optional = Optional.of("Test");38    assertThat(optional).isPresent()39                        .containsInstanceOf(String.class)40                        .contains("Test");41    Optional<Object> emptyOptional = Optional.empty();42    assertThat(emptyOptional).isEmpty();43    String someString = "something";44    assertThat(Optional.of(someString)).containsSame(someString);45    assertThat(Optional.of(someString)).hasValueSatisfying(s -> {46      assertThat(s).isEqualTo("something");47      assertThat(s).startsWith("some");48      assertThat(s).endsWith("thing");49    });50    Condition<TolkienCharacter> isAnElf = new Condition<>(character -> character.getRace() == Race.ELF, "an elf");51    assertThat(Optional.of(legolas)).hasValueSatisfying(isAnElf);52    assertThat(Optional.of(legolas)).satisfiesAnyOf(tc -> then(tc).isEmpty(), tc -> then(tc.get().getRace()).isEqualTo(Race.ELF));53    assertThat(Optional.empty()).satisfiesAnyOf(tc -> then(tc).isEmpty(), tc -> then(true).isFalse());54    // log some error messages to have a look at them55    try {56      assertThat(emptyOptional).isPresent();57    } catch (AssertionError e) {58      logAssertionErrorMessage("OptionalAssert.isPresent", e);59    }60    try {61      assertThat(emptyOptional).contains("Test");62    } catch (AssertionError e) {63      logAssertionErrorMessage("OptionalAssert.contains", e);64    }65    try {66      assertThat(optional).contains("Foo");67    } catch (AssertionError e) {68      logAssertionErrorMessage("OptionalAssert.contains", e);69    }70    try {71      assertThat(optional).isEmpty();72    } catch (AssertionError e) {73      logAssertionErrorMessage("OptionalAssert.isEmpty", e);74    }75    try {76      assertThat(optional).hasValueSatisfying(s -> {77        assertThat(s).isEqualTo("Not Test");78      });79    } catch (AssertionError e) {80      logAssertionErrorMessage("OptionalAssert.containing", e);81    }82    try {83      assertThat(emptyOptional).hasValueSatisfying(o -> {});84    } catch (AssertionError e) {85      logAssertionErrorMessage("OptionalAssert.containing", e);86    }87  }88  @Test89  public void primitives_optional_assertions_examples() {90    OptionalInt optional = OptionalInt.of(12);91    assertThat(optional).isPresent()92                        .hasValue(12);93    OptionalDouble emptyOptional = OptionalDouble.empty();94    assertThat(emptyOptional).isEmpty();95  }96  @Test97  public void optional_comparator_assertions_examples() {98    Optional<String> optional = Optional.of("YODA");99    assertThat(optional).usingValueComparator(caseInsensitiveStringComparator)100                        .hasValue("yoda")101                        .contains("yoda");102  }103  @Test104  public void map_optional_assertion_example() {105    Optional<String> optional = Optional.of("YODA");106    assertThat(optional).map(String::length)107                        .hasValue(4);108  }109  @Test110  public void hasValueSatisfying_with_condition_assertion_example() {111    assertThat(Optional.of("Yoda")).hasValueSatisfying(JEDI);112    Condition<TolkienCharacter> isAnElf = new Condition<>(character -> character.getRace() == ELF, "an elf");113    TolkienCharacter legolas = new TolkienCharacter("Legolas", 1000, ELF);114    TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);115    // assertion succeeds116    assertThat(Optional.of(legolas)).hasValueSatisfying(isAnElf);117    try {118      assertThat(Optional.of(frodo)).hasValueSatisfying(isAnElf);119    } catch (AssertionError e) {120      logAssertionErrorMessage("OptionalAssert.hasValueSatisfying with condition", e);121    }122  }123  @Test124  public void flatMap_optional_assertion_example() {125    Function<String, Optional<String>> UPPER_CASE_OPTIONAL_STRING = s -> s == null ? Optional.empty()126        : Optional.of(s.toUpperCase());127    // assertions succeed128    assertThat(Optional.of("something")).contains("something")129                                        .flatMap(UPPER_CASE_OPTIONAL_STRING)130                                        .contains("SOMETHING");131    assertThat(Optional.<String> empty()).flatMap(UPPER_CASE_OPTIONAL_STRING)132                                         .isEmpty();133    assertThat(Optional.<String> ofNullable(null)).flatMap(UPPER_CASE_OPTIONAL_STRING)134                                                  .isEmpty();...

Source:TestHelper.java

...14package jp.root42.indolently;15import java.util.Optional;16import jp.root42.indolently.ref.$;17import org.assertj.core.api.Assertions;18import org.assertj.core.api.OptionalAssert;19/**20 * @author root42 Inc.21 * @version $22 */23@SuppressWarnings("OptionalUsedAsFieldOrParameterType")24public final class TestHelper {25    private TestHelper() {}26    public static <VALUE> OptionalAssert<VALUE> assertThat(final Optional<VALUE> actual) {27        return Assertions.assertThat(actual);28    }29    public static <VALUE> OptionalAssert<VALUE> assertThat(final $<VALUE> actual) { return assertThat$(actual); }30    public static <VALUE> OptionalAssert<VALUE> assertThat$(final $<VALUE> actual) {31        return new OptionalAssert<>(actual.opt) {32            @SuppressWarnings("rawtypes")33            @Override34            public OptionalAssert<VALUE> isEqualTo(final Object expected) {35                if (expected instanceof $) {36                    this.objects.assertEqual(this.info, this.actual, (($) expected).opt);37                } else {38                    this.objects.assertEqual(this.info, this.actual, expected);39                }40                return this.myself;41            }42            @SuppressWarnings("rawtypes")43            @Override44            public OptionalAssert<VALUE> isNotEqualTo(final Object other) {45                if (other instanceof $) {46                    this.objects.assertNotEqual(this.info, this.actual, (($) other).opt);47                } else {48                    this.objects.assertNotEqual(this.info, this.actual, other);49                }50                return this.myself;51            }52        };53    }54}...

OptionalAssert

Using AI Code Generation

1package org.example;2import org.junit.jupiter.api.Test;3import static org.assertj.core.api.Assertions.assertThat;4import static org.assertj.core.api.Assertions.assertThatThrownBy;5import static org.assertj.core.api.Assertions.catchThrowable;6import static org.assertj.core.api.Assertions.catchThrowableOfType;7import static org.assertj.core.api.Assertions.catchThrowableWithCause;8import static org.assertj.core.api.Assertions.catchThrowableWithCauseOfType;9import static org.assertj.core.api.Assertions.catchThrowableWithMessage;10import static org.assertj.core.api.Assertions.catchThrowableWithMessageContaining;11import static org.assertj.core.api.Assertions.catchThrowableWithMessageMatching;12import static org.assertj.core.api.Assertions.catchThrowableWithMessageStartingWith;13import static org.assertj.core.api.Assertions.catchThrowableWithMessageEndingWith;14import static org.assertj.core.api.Assertions.catchThrowableWithMessageContainingAll;15import static org.assertj.core.api.Assertions.catchThrowableWithMessageMatchingAll;16import static org.assertj.core.api.Assertions.catchThrowableWithMessageStartingWithAll;17import static org.assertj.core.api.Assertions.catchThrowableWithMessageEndingWithAll;18import static org.assertj.core.api.Assertions.catchThrowableWithMessageContainingAny;19import static org.assertj.core.api.Assertions.catchThrowableWithMessageMatchingAny;20import static org.assertj.core.api.Assertions.catchThrowableWithMessageStartingWithAny;21import static org.assertj.core.api.Assertions.catchThrowableWithMessageEndingWithAny;22import static org.assertj.core.api.Assertions.catchThrowableWithMessageContainingSequence;23import static org.assertj.core.api.Assertions.catchThrowableWithMessageContainingAllSequence;24import static org.assertj.core.api.Assertions.catchThrowableWithMessageContainingAnySequence;25import static org.assertj.core.api.Assertions.catchThrowableWithMessageMatchingSequence;26import static org.assertj.core.api.Assertions.catchThrowableWithMessageMatchingAllSequence;27import static org.assertj.core.api.Assertions.catchThrowableWithMessageMatchingAnySequence;28import static org.assertj.core.api.Assertions.catchThrowableWithMessageStartingWithSequence;29import static org.assertj.core.api.Assertions.catchThrowableWithMessageStartingWithAllSequence;30import static org.assertj.core.api.Assertions.catchThrowableWithMessageStartingWithAnySequence;31import static org.assertj.core.api.Assertions.catchThrowableWithMessageEndingWithSequence;32import static org.assertj.core.api.Assertions.catchThrowableWithMessageEndingWithAllSequence;33import static org.assertj.core.api.Assertions.catchThrowableWithMessageEndingWithAnySequence;34import static org.assertj.core.api.Assertions.catchThrowableWithMessageMatchingPattern;35import static org.assertj.core.api.Assertions.catchThrowableWithMessageMatchingAllPattern;36import static org.assertj.core.api.Assertions.catchThrowableWithMessageMatchingAnyPattern;37import static org.assertj.core.api.Assertions.catchThrowableWithMessageMatchingPattern

OptionalAssert

Using AI Code Generation

1package com.mycompany.app;2import static org.assertj.core.api.Assertions.assertThat;3import static org.assertj.core.api.Assertions.assertThatThrownBy;4import java.util.Optional;5import org.junit.Test;6public class OptionalAssertTest {7    public void testOptionalAssert() {8        Optional<String> optional = Optional.of("Hello");9        assertThat(optional).isPresent();10        assertThat(optional).hasValue("Hello");11        assertThat(optional).hasValueSatisfying(s -> assertThat(s).startsWith("H"));12        assertThat(optional).contains("Hello");13        assertThat(optional).containsInstanceOf(String.class);14        assertThat(optional).containsInstanceOf(Object.class);15        assertThat(optional).containsSame("Hello");16        assertThat(optional).containsExactly("Hello");17        assertThat(optional).containsExactlyInAnyOrder("Hello");18        assertThat(optional).containsExactlyInAnyOrderElementsOf(Optional.of("Hello"));19        assertThat(optional).containsExactlyElementsOf(Optional.of("Hello"));20        assertThat(optional).isEqualTo(Optional.of("Hello"));21        assertThat(optional).isNotEqualTo(Optional.of("Hello"));22        assertThat(optional).hasValueSatisfying(s -> assertThat(s).startsWith("H"));23        assertThat(optional).hasValueSatisfying(s -> assertThat(s).startsWith("H"));24        assertThat(optional).hasValueSatisfying(s -> assertThat(s).startsWith("H"));25    }26    public void testOptionalAssertEmpty() {27        Optional<String> optional = Optional.empty();28        assertThat(optional).isNotPresent();29        assertThat(optional).isEmpty();30        assertThat(optional).hasValueSatisfying(s -> assertThat(s).startsWith("H"));31        assertThat(optional).isEmpty();

OptionalAssert

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import java.util.Optional;3public class OptionalAssert {4   public static void main(String[] args) {5      OptionalAssert optionalAssert = new OptionalAssert();6      optionalAssert.testOptionalAssert();7   }8   public void testOptionalAssert() {9      Optional<String> optional = Optional.of("abc");10      assertThat(optional).isPresent().hasValue("abc");11      assertThat(optional).isNotNull();12   }13}14BUILD SUCCESSFUL (total time: 0 seconds)15Java 8 Optional Class – isPresent(), get() and ifPresent()16Java 8 Optional Class – orElse() and orElseGet()17Java 8 Optional Class – orElseThrow()18Java 8 Optional Class – filter()19Java 8 Optional Class – map()20Java 8 Optional Class – flatMap()21Java 8 Optional Class – ofNullable()22Java 8 Optional Class – isPresent(), get() and ifPresent() Java 8 Optional Class – ofNullable() »

OptionalAssert

Using AI Code Generation

1package com.automationrhapsody.junit5;2import org.junit.jupiter.api.Test;3import static org.assertj.core.api.Assertions.assertThat;4public class OptionalAssertTest {5    public void testOptionalAssert() {6        assertThat(Optional.of("Test")).isPresent();7    }8}

OptionalAssert

Using AI Code Generation

1import org.assertj.core.api.OptionalAssert;2import java.util.Optional;3public class OptionalAssertExample {4   public static void main(String[] args) {5      Optional<String> opt = Optional.of("Java Optional");6      OptionalAssert<String> optAssert = new OptionalAssert<>(opt);7      optAssert.isPresent();8      optAssert.contains("Java Optional");9   }10}

OptionalAssert

Using AI Code Generation

1import org.assertj.core.api.OptionalAssert;2import org.assertj.core.api.Assertions;3import java.util.Optional;4public class AssertJOptional {5	public static void main(String[] args) {6		Optional<String> optional = Optional.of("Hello World");7		OptionalAssert<String> optionalAssert = Assertions.assertThat(optional);8		optionalAssert.isPresent();9		optionalAssert.hasValue("Hello World");10	}11}

OptionalAssert

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import static org.assertj.core.api.Assertions.assertThatThrownBy;3import java.util.Optional;4import org.junit.Test;5public class OptionalsTest {6	public void givenOptional_whenIsPresentWorks_thenCorrect() {7		Optional<String> opt = Optional.of("bam");8		assertThat(opt.isPresent()).isTrue();9		assertThat(opt.get()).isEqualTo("bam");10	}11	public void givenOptional_whenIsPresentWorks_thenCorrect2() {12		Optional<String> opt = Optional.empty();13		assertThat(opt.isPresent()).isFalse();14	}15	public void givenOptional_whenIfPresentWorks_thenCorrect() {16		Optional<String> opt = Optional.of("bam");17		opt.ifPresent(name -> assertThat(name).isEqualTo("bam"));18	}19	public void givenOptional_whenIfPresentWorks_thenCorrect2() {20		Optional<String> opt = Optional.empty();21		opt.ifPresent(name -> assertThat(name).isEqualTo("bam"));22	}23	public void givenOptional_whenOrElseWorks_thenCorrect() {24		Optional<String> opt = Optional.of("bam");25		assertThat(opt.orElse("fallback")).isEqualTo("bam");26	}27	public void givenOptional_whenOrElseWorks_thenCorrect2() {28		Optional<String> opt = Optional.empty();29		assertThat(opt.orElse("fallback")).isEqualTo("fallback");30	}31	public void givenOptional_whenOrElseGetWorks_thenCorrect() {32		Optional<String> opt = Optional.of("bam");33		assertThat(opt.orElseGet(() -> "fallback")).isEqualTo("bam");34	}35	public void givenOptional_whenOrElseGetWorks_thenCorrect2() {36		Optional<String> opt = Optional.empty();37		assertThat(opt.orElseGet(() -> "fallback")).isEqualTo("fallback");38	}39	public void givenOptional_whenOrElseThrowWorks_thenCorrect() {40		Optional<String> opt = Optional.of("bam");41		assertThat(opt.orElseThrow(IllegalArgumentException::new)).isEqualTo("bam");42	}43	public void givenOptional_whenOrElseThrowWorks_thenCorrect2() {44		Optional<String> opt = Optional.empty();45		assertThatThrownBy(() -> opt.orElseThrow(IllegalArgumentException::new))46				.isInstanceOf(IllegalArgumentException.class);47	}48	public void givenOptional_whenMapWorks_thenCorrect() {49		Optional<String> opt = Optional.of("bam");50		assertThat(opt.map(String::toUpperCase).get()).isEqualTo("BAM");51	}

OptionalAssert

Using AI Code Generation

1import org.assertj.core.api.OptionalAssert;2import java.util.Optional;3public class OptionalAssertTest {4   public static void main(String[] args) {5      Optional<String> opt = Optional.of("Java");6      OptionalAssert<String> optionalAssert = new OptionalAssert<String>(opt);7      optionalAssert.isPresent();8      optionalAssert.contains("Java");9   }10}

OptionalAssert

Using AI Code Generation

1import static org.assertj.core.api.Assertions.*;2import java.util.Optional;3public class OptionalAssertExample {4    public static void main(String[] args) {5        Optional<String> opt = Optional.of("Java");6        OptionalAssert<String> optAssert = assertThat(opt);7        optAssert.isPresent();8        optAssert.hasValue("Java");9        optAssert.hasValueSatisfying(s -> assertThat(s).startsWith("J"));10        assertThat(opt)11                .isPresent()12                .hasValue("Java")13                .hasValueSatisfying(s -> assertThat(s).startsWith("J"));14        Optional<String> emptyOpt = Optional.empty();15        OptionalAssert<String> emptyOptAssert = assertThat(emptyOpt);16        emptyOptAssert.isEmpty();17    }18}

OptionalAssert

Using AI Code Generation

1import org.assertj.core.api.*;2public class OptionalAssertExample {3    public static void main(String[] args) {4        Integer nullValue = null;5        OptionalAssert.assertThat(Optional.ofNullable(nullValue)).isEmpty();6    }7}

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.