Best Assertj code snippet using org.assertj.core.api.AtomicReferenceArrayAssert.AtomicReferenceArrayAssert
Source:AssertJAssertions.java
...2357 public static AtomicLongAssert assertThat(java.util.concurrent.atomic.AtomicLong p0) { return (AtomicLongAssert) (Object) null; }2358 public static AtomicLongArrayAssert assertThat(java.util.concurrent.atomic.AtomicLongArray p0) { return (AtomicLongArrayAssert) (Object) null; }2359 public static AtomicLongFieldUpdaterAssert assertThat(java.util.concurrent.atomic.AtomicLongFieldUpdater p0) { return (AtomicLongFieldUpdaterAssert) (Object) null; }2360 public static AtomicReferenceAssert assertThat(java.util.concurrent.atomic.AtomicReference p0) { return (AtomicReferenceAssert) (Object) null; }2361 public static AtomicReferenceArrayAssert assertThat(java.util.concurrent.atomic.AtomicReferenceArray p0) { return (AtomicReferenceArrayAssert) (Object) null; }2362 public static AtomicReferenceFieldUpdaterAssert assertThat(java.util.concurrent.atomic.AtomicReferenceFieldUpdater p0) { return (AtomicReferenceFieldUpdaterAssert) (Object) null; }2363 public static AtomicMarkableReferenceAssert assertThat(java.util.concurrent.atomic.AtomicMarkableReference p0) { return (AtomicMarkableReferenceAssert) (Object) null; }2364 public static AtomicStampedReferenceAssert assertThat(java.util.concurrent.atomic.AtomicStampedReference p0) { return (AtomicStampedReferenceAssert) (Object) null; }2365 public static AbstractThrowableAssert assertThat(Throwable p0) { return (AbstractThrowableAssert) (Object) null; }2366 public static AbstractThrowableAssert assertThatThrownBy(ThrowableAssert.ThrowingCallable p0) { return (AbstractThrowableAssert) (Object) null; }2367 public static AbstractThrowableAssert assertThatThrownBy(ThrowableAssert.ThrowingCallable p0, String p1, Object[] p2) { return (AbstractThrowableAssert) (Object) null; }2368 public static AbstractThrowableAssert assertThatCode(ThrowableAssert.ThrowingCallable p0) { return (AbstractThrowableAssert) (Object) null; }2369 public static ObjectAssert assertThatObject(Object p0) { return (ObjectAssert) (Object) null; }2370 public static Throwable catchThrowable(ThrowableAssert.ThrowingCallable p0) { return (Throwable) (Object) null; }2371 public static Throwable catchThrowableOfType(ThrowableAssert.ThrowingCallable p0, Class p1) { return (Throwable) (Object) null; }2372 public static ThrowableTypeAssert assertThatExceptionOfType(Class p0) { return (ThrowableTypeAssert) (Object) null; }2373 public static NotThrownAssert assertThatNoException() { return (NotThrownAssert) (Object) null; }2374 public static ThrowableTypeAssert assertThatNullPointerException() { return (ThrowableTypeAssert) (Object) null; }2375 public static ThrowableTypeAssert assertThatIllegalArgumentException() { return (ThrowableTypeAssert) (Object) null; }2376 public static ThrowableTypeAssert assertThatIOException() { return (ThrowableTypeAssert) (Object) null; }2377 public static ThrowableTypeAssert assertThatIllegalStateException() { return (ThrowableTypeAssert) (Object) null; }2378 public static void setRemoveAssertJRelatedElementsFromStackTrace(boolean p0) {}2379 public static Object fail(String p0) { return (Object) (Object) null; }2380 public static Object fail(String p0, Object[] p1) { return (Object) (Object) null; }2381 public static Object fail(String p0, Throwable p1) { return (Object) (Object) null; }2382 public static Object failBecauseExceptionWasNotThrown(Class p0) { return (Object) (Object) null; }2383 public static Object shouldHaveThrown(Class p0) { return (Object) (Object) null; }2384 public static void setMaxLengthForSingleLineDescription(int p0) {}2385 public static void setMaxElementsForPrinting(int p0) {}2386 public static void setPrintAssertionsDescription(boolean p0) {}2387 public static void setDescriptionConsumer(java.util.function.Consumer p0) {}2388 public static void setMaxStackTraceElementsDisplayed(int p0) {}2389 public static org.assertj.core.groups.Properties extractProperty(String p0, Class p1) { return (org.assertj.core.groups.Properties) (Object) null; }2390 public static org.assertj.core.groups.Properties extractProperty(String p0) { return (org.assertj.core.groups.Properties) (Object) null; }2391 public static org.assertj.core.groups.Tuple tuple(Object[] p0) { return (org.assertj.core.groups.Tuple) (Object) null; }2392 public static void setAllowExtractingPrivateFields(boolean p0) {}2393 public static void setAllowComparingPrivateFields(boolean p0) {}2394 public static void setExtractBareNamePropertyMethods(boolean p0) {}2395 public static org.assertj.core.data.MapEntry entry(Object p0, Object p1) { return (org.assertj.core.data.MapEntry) (Object) null; }2396 public static org.assertj.core.data.Index atIndex(int p0) { return (org.assertj.core.data.Index) (Object) null; }2397 public static org.assertj.core.data.Offset offset(Double p0) { return (org.assertj.core.data.Offset) (Object) null; }2398 public static org.assertj.core.data.Offset offset(Float p0) { return (org.assertj.core.data.Offset) (Object) null; }2399 public static org.assertj.core.data.Offset within(Double p0) { return (org.assertj.core.data.Offset) (Object) null; }2400 public static org.assertj.core.data.Offset withPrecision(Double p0) { return (org.assertj.core.data.Offset) (Object) null; }2401 public static org.assertj.core.data.Offset within(Float p0) { return (org.assertj.core.data.Offset) (Object) null; }2402 public static org.assertj.core.data.Offset withPrecision(Float p0) { return (org.assertj.core.data.Offset) (Object) null; }2403 public static org.assertj.core.data.Offset within(java.math.BigDecimal p0) { return (org.assertj.core.data.Offset) (Object) null; }2404 public static org.assertj.core.data.Offset within(java.math.BigInteger p0) { return (org.assertj.core.data.Offset) (Object) null; }2405 public static org.assertj.core.data.Offset within(Byte p0) { return (org.assertj.core.data.Offset) (Object) null; }2406 public static org.assertj.core.data.Offset within(Integer p0) { return (org.assertj.core.data.Offset) (Object) null; }2407 public static org.assertj.core.data.Offset within(Short p0) { return (org.assertj.core.data.Offset) (Object) null; }2408 public static org.assertj.core.data.Offset within(Long p0) { return (org.assertj.core.data.Offset) (Object) null; }2409 public static org.assertj.core.data.TemporalUnitOffset within(long p0, java.time.temporal.TemporalUnit p1) { return (org.assertj.core.data.TemporalUnitOffset) (Object) null; }2410 public static java.time.Duration withMarginOf(java.time.Duration p0) { return (java.time.Duration) (Object) null; }2411 public static org.assertj.core.data.Percentage withinPercentage(Double p0) { return (org.assertj.core.data.Percentage) (Object) null; }2412 public static org.assertj.core.data.Percentage withinPercentage(Integer p0) { return (org.assertj.core.data.Percentage) (Object) null; }2413 public static org.assertj.core.data.Percentage withinPercentage(Long p0) { return (org.assertj.core.data.Percentage) (Object) null; }2414 public static org.assertj.core.data.Offset byLessThan(Double p0) { return (org.assertj.core.data.Offset) (Object) null; }2415 public static org.assertj.core.data.Offset byLessThan(Float p0) { return (org.assertj.core.data.Offset) (Object) null; }2416 public static org.assertj.core.data.Offset byLessThan(java.math.BigDecimal p0) { return (org.assertj.core.data.Offset) (Object) null; }2417 public static org.assertj.core.data.Offset byLessThan(java.math.BigInteger p0) { return (org.assertj.core.data.Offset) (Object) null; }2418 public static org.assertj.core.data.Offset byLessThan(Byte p0) { return (org.assertj.core.data.Offset) (Object) null; }2419 public static org.assertj.core.data.Offset byLessThan(Integer p0) { return (org.assertj.core.data.Offset) (Object) null; }2420 public static org.assertj.core.data.Offset byLessThan(Short p0) { return (org.assertj.core.data.Offset) (Object) null; }2421 public static org.assertj.core.data.Offset byLessThan(Long p0) { return (org.assertj.core.data.Offset) (Object) null; }2422 public static org.assertj.core.data.TemporalUnitOffset byLessThan(long p0, java.time.temporal.TemporalUnit p1) { return (org.assertj.core.data.TemporalUnitOffset) (Object) null; }2423 public static java.util.function.Function from(java.util.function.Function p0) { return (java.util.function.Function) (Object) null; }2424 public static InstanceOfAssertFactory as(InstanceOfAssertFactory p0) { return (InstanceOfAssertFactory) (Object) null; }2425 public static Condition allOf(Condition[] p0) { return (Condition) (Object) null; }2426 public static Condition allOf(Iterable p0) { return (Condition) (Object) null; }2427 public static Condition anyOf(Condition[] p0) { return (Condition) (Object) null; }2428 public static Condition anyOf(Iterable p0) { return (Condition) (Object) null; }2429 public static org.assertj.core.condition.DoesNotHave doesNotHave(Condition p0) { return (org.assertj.core.condition.DoesNotHave) (Object) null; }2430 public static org.assertj.core.condition.Not not(Condition p0) { return (org.assertj.core.condition.Not) (Object) null; }2431 public static org.assertj.core.api.filter.Filters filter(Object[] p0) { return (org.assertj.core.api.filter.Filters) (Object) null; }2432 public static org.assertj.core.api.filter.Filters filter(Iterable p0) { return (org.assertj.core.api.filter.Filters) (Object) null; }2433 public static org.assertj.core.api.filter.InFilter in(Object[] p0) { return (org.assertj.core.api.filter.InFilter) (Object) null; }2434 public static org.assertj.core.api.filter.NotInFilter notIn(Object[] p0) { return (org.assertj.core.api.filter.NotInFilter) (Object) null; }2435 public static org.assertj.core.api.filter.NotFilter not(Object p0) { return (org.assertj.core.api.filter.NotFilter) (Object) null; }2436 public static String contentOf(File p0, java.nio.charset.Charset p1) { return (String) (Object) null; }2437 public static String contentOf(File p0, String p1) { return (String) (Object) null; }2438 public static String contentOf(File p0) { return (String) (Object) null; }2439 public static java.util.List linesOf(File p0) { return (java.util.List) (Object) null; }2440 public static java.util.List linesOf(File p0, java.nio.charset.Charset p1) { return (java.util.List) (Object) null; }2441 public static java.util.List linesOf(File p0, String p1) { return (java.util.List) (Object) null; }2442 public static String contentOf(java.net.URL p0, java.nio.charset.Charset p1) { return (String) (Object) null; }2443 public static String contentOf(java.net.URL p0, String p1) { return (String) (Object) null; }2444 public static String contentOf(java.net.URL p0) { return (String) (Object) null; }2445 public static java.util.List linesOf(java.net.URL p0) { return (java.util.List) (Object) null; }2446 public static java.util.List linesOf(java.net.URL p0, java.nio.charset.Charset p1) { return (java.util.List) (Object) null; }2447 public static java.util.List linesOf(java.net.URL p0, String p1) { return (java.util.List) (Object) null; }2448 public static void setLenientDateParsing(boolean p0) {}2449 public static void registerCustomDateFormat(java.text.DateFormat p0) {}2450 public static void registerCustomDateFormat(String p0) {}2451 public static void useDefaultDateFormatsOnly() {}2452 public static Object assertThat(AssertProvider p0) { return (Object) (Object) null; }2453 public static AbstractCharSequenceAssert assertThat(CharSequence p0) { return (AbstractCharSequenceAssert) (Object) null; }2454 public static AbstractCharSequenceAssert assertThat(StringBuilder p0) { return (AbstractCharSequenceAssert) (Object) null; }2455 public static AbstractCharSequenceAssert assertThat(StringBuffer p0) { return (AbstractCharSequenceAssert) (Object) null; }2456 public static AbstractStringAssert assertThat(String p0) { return (AbstractStringAssert) (Object) null; }2457 public static IterableAssert assertThat(Iterable p0) { return (IterableAssert) (Object) null; }2458 public static IteratorAssert assertThat(java.util.Iterator p0) { return (IteratorAssert) (Object) null; }2459 public static ListAssert assertThat(java.util.List p0) { return (ListAssert) (Object) null; }2460 public static ListAssert assertThat(java.util.stream.Stream p0) { return (ListAssert) (Object) null; }2461 public static ListAssert assertThat(java.util.stream.DoubleStream p0) { return (ListAssert) (Object) null; }2462 public static ListAssert assertThat(java.util.stream.LongStream p0) { return (ListAssert) (Object) null; }2463 public static ListAssert assertThat(java.util.stream.IntStream p0) { return (ListAssert) (Object) null; }2464 public static SpliteratorAssert assertThat(java.util.Spliterator p0) { return (SpliteratorAssert) (Object) null; }2465 public static AbstractPathAssert assertThat(java.nio.file.Path p0) { return (AbstractPathAssert) (Object) null; }2466 public static MapAssert assertThat(java.util.Map p0) { return (MapAssert) (Object) null; }2467 public static AbstractComparableAssert assertThat(Comparable p0) { return (AbstractComparableAssert) (Object) null; }2468 public static AssertDelegateTarget assertThat(AssertDelegateTarget p0) { return (AssertDelegateTarget) (Object) null; }2469 public static void useRepresentation(org.assertj.core.presentation.Representation p0) {}2470 public static void registerFormatterForType(Class p0, java.util.function.Function p1) {}2471 public static void useDefaultRepresentation() {}2472}2473---2474package org.assertj.core.api;2475import java.io.*;2476public class AssertionsForClassTypes {2477 public static CompletableFutureAssert assertThat(java.util.concurrent.CompletableFuture p0) { return (CompletableFutureAssert) (Object) null; }2478 public static OptionalAssert assertThat(java.util.Optional p0) { return (OptionalAssert) (Object) null; }2479 public static OptionalDoubleAssert assertThat(java.util.OptionalDouble p0) { return (OptionalDoubleAssert) (Object) null; }2480 public static OptionalIntAssert assertThat(java.util.OptionalInt p0) { return (OptionalIntAssert) (Object) null; }2481 public static OptionalLongAssert assertThat(java.util.OptionalLong p0) { return (OptionalLongAssert) (Object) null; }2482 public static AbstractBigDecimalAssert assertThat(java.math.BigDecimal p0) { return (AbstractBigDecimalAssert) (Object) null; }2483 public static AbstractUriAssert assertThat(java.net.URI p0) { return (AbstractUriAssert) (Object) null; }2484 public static AbstractUrlAssert assertThat(java.net.URL p0) { return (AbstractUrlAssert) (Object) null; }2485 public static AbstractBooleanAssert assertThat(boolean p0) { return (AbstractBooleanAssert) (Object) null; }2486 public static AbstractBooleanAssert assertThat(Boolean p0) { return (AbstractBooleanAssert) (Object) null; }2487 public static AbstractBooleanArrayAssert assertThat(boolean[] p0) { return (AbstractBooleanArrayAssert) (Object) null; }2488 public static Boolean2DArrayAssert assertThat(boolean[][] p0) { return (Boolean2DArrayAssert) (Object) null; }2489 public static AbstractByteAssert assertThat(byte p0) { return (AbstractByteAssert) (Object) null; }2490 public static AbstractByteAssert assertThat(Byte p0) { return (AbstractByteAssert) (Object) null; }2491 public static AbstractByteArrayAssert assertThat(byte[] p0) { return (AbstractByteArrayAssert) (Object) null; }2492 public static Byte2DArrayAssert assertThat(byte[][] p0) { return (Byte2DArrayAssert) (Object) null; }2493 public static AbstractCharacterAssert assertThat(char p0) { return (AbstractCharacterAssert) (Object) null; }2494 public static AbstractCharArrayAssert assertThat(char[] p0) { return (AbstractCharArrayAssert) (Object) null; }2495 public static Char2DArrayAssert assertThat(char[][] p0) { return (Char2DArrayAssert) (Object) null; }2496 public static AbstractCharacterAssert assertThat(Character p0) { return (AbstractCharacterAssert) (Object) null; }2497 public static ClassAssert assertThat(Class p0) { return (ClassAssert) (Object) null; }2498 public static AbstractDoubleAssert assertThat(double p0) { return (AbstractDoubleAssert) (Object) null; }2499 public static AbstractDoubleAssert assertThat(Double p0) { return (AbstractDoubleAssert) (Object) null; }2500 public static AbstractDoubleArrayAssert assertThat(double[] p0) { return (AbstractDoubleArrayAssert) (Object) null; }2501 public static Double2DArrayAssert assertThat(double[][] p0) { return (Double2DArrayAssert) (Object) null; }2502 public static AbstractFileAssert assertThat(File p0) { return (AbstractFileAssert) (Object) null; }2503 public static AbstractInputStreamAssert assertThat(InputStream p0) { return (AbstractInputStreamAssert) (Object) null; }2504 public static AbstractFloatAssert assertThat(float p0) { return (AbstractFloatAssert) (Object) null; }2505 public static AbstractFloatAssert assertThat(Float p0) { return (AbstractFloatAssert) (Object) null; }2506 public static AbstractFloatArrayAssert assertThat(float[] p0) { return (AbstractFloatArrayAssert) (Object) null; }2507 public static Float2DArrayAssert assertThat(float[][] p0) { return (Float2DArrayAssert) (Object) null; }2508 public static AbstractIntegerAssert assertThat(int p0) { return (AbstractIntegerAssert) (Object) null; }2509 public static AbstractIntArrayAssert assertThat(int[] p0) { return (AbstractIntArrayAssert) (Object) null; }2510 public static Int2DArrayAssert assertThat(int[][] p0) { return (Int2DArrayAssert) (Object) null; }2511 public static AbstractIntegerAssert assertThat(Integer p0) { return (AbstractIntegerAssert) (Object) null; }2512 public static AbstractLongAssert assertThat(long p0) { return (AbstractLongAssert) (Object) null; }2513 public static AbstractLongAssert assertThat(Long p0) { return (AbstractLongAssert) (Object) null; }2514 public static AbstractLongArrayAssert assertThat(long[] p0) { return (AbstractLongArrayAssert) (Object) null; }2515 public static Long2DArrayAssert assertThat(long[][] p0) { return (Long2DArrayAssert) (Object) null; }2516 public static ObjectAssert assertThat(Object p0) { return (ObjectAssert) (Object) null; }2517 public static ObjectArrayAssert assertThat(Object[] p0) { return (ObjectArrayAssert) (Object) null; }2518 public static Object2DArrayAssert assertThat(Object[][] p0) { return (Object2DArrayAssert) (Object) null; }2519 public static AbstractShortAssert assertThat(short p0) { return (AbstractShortAssert) (Object) null; }2520 public static AbstractShortAssert assertThat(Short p0) { return (AbstractShortAssert) (Object) null; }2521 public static AbstractShortArrayAssert assertThat(short[] p0) { return (AbstractShortArrayAssert) (Object) null; }2522 public static Short2DArrayAssert assertThat(short[][] p0) { return (Short2DArrayAssert) (Object) null; }2523 public static AbstractCharSequenceAssert assertThat(StringBuilder p0) { return (AbstractCharSequenceAssert) (Object) null; }2524 public static AbstractCharSequenceAssert assertThat(StringBuffer p0) { return (AbstractCharSequenceAssert) (Object) null; }2525 public static AbstractStringAssert assertThat(String p0) { return (AbstractStringAssert) (Object) null; }2526 public static AbstractDateAssert assertThat(java.util.Date p0) { return (AbstractDateAssert) (Object) null; }2527 public static AbstractZonedDateTimeAssert assertThat(java.time.ZonedDateTime p0) { return (AbstractZonedDateTimeAssert) (Object) null; }2528 public static AbstractLocalDateTimeAssert assertThat(java.time.LocalDateTime p0) { return (AbstractLocalDateTimeAssert) (Object) null; }2529 public static AbstractOffsetDateTimeAssert assertThat(java.time.OffsetDateTime p0) { return (AbstractOffsetDateTimeAssert) (Object) null; }2530 public static AbstractOffsetTimeAssert assertThat(java.time.OffsetTime p0) { return (AbstractOffsetTimeAssert) (Object) null; }2531 public static AbstractLocalTimeAssert assertThat(java.time.LocalTime p0) { return (AbstractLocalTimeAssert) (Object) null; }2532 public static AbstractLocalDateAssert assertThat(java.time.LocalDate p0) { return (AbstractLocalDateAssert) (Object) null; }2533 public static AbstractInstantAssert assertThat(java.time.Instant p0) { return (AbstractInstantAssert) (Object) null; }2534 public static AbstractDurationAssert assertThat(java.time.Duration p0) { return (AbstractDurationAssert) (Object) null; }2535 public static AbstractPeriodAssert assertThat(java.time.Period p0) { return (AbstractPeriodAssert) (Object) null; }2536 public static AbstractThrowableAssert assertThat(Throwable p0) { return (AbstractThrowableAssert) (Object) null; }2537 public static AbstractThrowableAssert assertThatThrownBy(ThrowableAssert.ThrowingCallable p0) { return (AbstractThrowableAssert) (Object) null; }2538 public static AbstractThrowableAssert assertThatThrownBy(ThrowableAssert.ThrowingCallable p0, String p1, Object[] p2) { return (AbstractThrowableAssert) (Object) null; }2539 public static ThrowableTypeAssert assertThatExceptionOfType(Class p0) { return (ThrowableTypeAssert) (Object) null; }2540 public static NotThrownAssert assertThatNoException() { return (NotThrownAssert) (Object) null; }2541 public static AbstractThrowableAssert assertThatCode(ThrowableAssert.ThrowingCallable p0) { return (AbstractThrowableAssert) (Object) null; }2542 public static Throwable catchThrowable(ThrowableAssert.ThrowingCallable p0) { return (Throwable) (Object) null; }2543 public static Throwable catchThrowableOfType(ThrowableAssert.ThrowingCallable p0, Class p1) { return (Throwable) (Object) null; }2544 public static void setRemoveAssertJRelatedElementsFromStackTrace(boolean p0) {}2545 public static void fail(String p0) {}2546 public static void fail(String p0, Throwable p1) {}2547 public static void failBecauseExceptionWasNotThrown(Class p0) {}2548 public static void shouldHaveThrown(Class p0) {}2549 public static void setMaxLengthForSingleLineDescription(int p0) {}2550 public static org.assertj.core.groups.Properties extractProperty(String p0, Class p1) { return (org.assertj.core.groups.Properties) (Object) null; }2551 public static org.assertj.core.groups.Properties extractProperty(String p0) { return (org.assertj.core.groups.Properties) (Object) null; }2552 public static org.assertj.core.groups.Tuple tuple(Object[] p0) { return (org.assertj.core.groups.Tuple) (Object) null; }2553 public static void setAllowExtractingPrivateFields(boolean p0) {}2554 public static void setAllowComparingPrivateFields(boolean p0) {}2555 public static org.assertj.core.data.MapEntry entry(Object p0, Object p1) { return (org.assertj.core.data.MapEntry) (Object) null; }2556 public static org.assertj.core.data.Index atIndex(int p0) { return (org.assertj.core.data.Index) (Object) null; }2557 public static org.assertj.core.data.Offset offset(Double p0) { return (org.assertj.core.data.Offset) (Object) null; }2558 public static org.assertj.core.data.Offset offset(Float p0) { return (org.assertj.core.data.Offset) (Object) null; }2559 public static org.assertj.core.data.Offset within(Double p0) { return (org.assertj.core.data.Offset) (Object) null; }2560 public static org.assertj.core.data.Offset within(Float p0) { return (org.assertj.core.data.Offset) (Object) null; }2561 public static org.assertj.core.data.Offset within(java.math.BigDecimal p0) { return (org.assertj.core.data.Offset) (Object) null; }2562 public static org.assertj.core.data.Offset within(Byte p0) { return (org.assertj.core.data.Offset) (Object) null; }2563 public static org.assertj.core.data.Offset within(Integer p0) { return (org.assertj.core.data.Offset) (Object) null; }2564 public static org.assertj.core.data.Offset within(Short p0) { return (org.assertj.core.data.Offset) (Object) null; }2565 public static org.assertj.core.data.Offset within(Long p0) { return (org.assertj.core.data.Offset) (Object) null; }2566 public static org.assertj.core.data.Percentage withinPercentage(Double p0) { return (org.assertj.core.data.Percentage) (Object) null; }2567 public static org.assertj.core.data.Percentage withinPercentage(Integer p0) { return (org.assertj.core.data.Percentage) (Object) null; }2568 public static org.assertj.core.data.Percentage withinPercentage(Long p0) { return (org.assertj.core.data.Percentage) (Object) null; }2569 public static Condition allOf(Condition[] p0) { return (Condition) (Object) null; }2570 public static Condition allOf(Iterable p0) { return (Condition) (Object) null; }2571 public static Condition anyOf(Condition[] p0) { return (Condition) (Object) null; }2572 public static Condition anyOf(Iterable p0) { return (Condition) (Object) null; }2573 public static org.assertj.core.condition.DoesNotHave doesNotHave(Condition p0) { return (org.assertj.core.condition.DoesNotHave) (Object) null; }2574 public static org.assertj.core.condition.Not not(Condition p0) { return (org.assertj.core.condition.Not) (Object) null; }2575 public static org.assertj.core.api.filter.Filters filter(Object[] p0) { return (org.assertj.core.api.filter.Filters) (Object) null; }2576 public static org.assertj.core.api.filter.Filters filter(Iterable p0) { return (org.assertj.core.api.filter.Filters) (Object) null; }2577 public static org.assertj.core.api.filter.InFilter in(Object[] p0) { return (org.assertj.core.api.filter.InFilter) (Object) null; }2578 public static org.assertj.core.api.filter.NotInFilter notIn(Object[] p0) { return (org.assertj.core.api.filter.NotInFilter) (Object) null; }2579 public static org.assertj.core.api.filter.NotFilter not(Object p0) { return (org.assertj.core.api.filter.NotFilter) (Object) null; }2580 public static String contentOf(File p0, java.nio.charset.Charset p1) { return (String) (Object) null; }2581 public static String contentOf(File p0, String p1) { return (String) (Object) null; }2582 public static String contentOf(File p0) { return (String) (Object) null; }2583 public static java.util.List linesOf(File p0) { return (java.util.List) (Object) null; }2584 public static java.util.List linesOf(File p0, java.nio.charset.Charset p1) { return (java.util.List) (Object) null; }2585 public static java.util.List linesOf(File p0, String p1) { return (java.util.List) (Object) null; }2586 public static String contentOf(java.net.URL p0, java.nio.charset.Charset p1) { return (String) (Object) null; }2587 public static String contentOf(java.net.URL p0, String p1) { return (String) (Object) null; }2588 public static String contentOf(java.net.URL p0) { return (String) (Object) null; }2589 public static java.util.List linesOf(java.net.URL p0) { return (java.util.List) (Object) null; }2590 public static java.util.List linesOf(java.net.URL p0, java.nio.charset.Charset p1) { return (java.util.List) (Object) null; }2591 public static java.util.List linesOf(java.net.URL p0, String p1) { return (java.util.List) (Object) null; }2592 public static void setLenientDateParsing(boolean p0) {}2593 public static void registerCustomDateFormat(java.text.DateFormat p0) {}2594 public static void registerCustomDateFormat(String p0) {}2595 public static void useDefaultDateFormatsOnly() {}2596}2597---2598package org.assertj.core.api;2599import java.io.*;2600public class AtomicBooleanAssert extends AbstractAssert {2601 public void AtomicBooleanAssert(java.util.concurrent.atomic.AtomicBoolean p0) {}2602 public AtomicBooleanAssert isTrue() { return (AtomicBooleanAssert) (Object) null; }2603 public AtomicBooleanAssert isFalse() { return (AtomicBooleanAssert) (Object) null; }2604 public AtomicBooleanAssert usingComparator(java.util.Comparator p0) { return (AtomicBooleanAssert) (Object) null; }2605 public AtomicBooleanAssert usingComparator(java.util.Comparator p0, String p1) { return (AtomicBooleanAssert) (Object) null; }2606}2607---2608package org.assertj.core.api;2609import java.io.*;2610public class AtomicIntegerArrayAssert extends AbstractEnumerableAssert {2611 public void AtomicIntegerArrayAssert(java.util.concurrent.atomic.AtomicIntegerArray p0) {}2612 public void isNullOrEmpty() {}2613 public void isEmpty() {}2614 public AtomicIntegerArrayAssert isNotEmpty() { return (AtomicIntegerArrayAssert) (Object) null; }2615 public AtomicIntegerArrayAssert hasArray(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2616 public AtomicIntegerArrayAssert hasSize(int p0) { return (AtomicIntegerArrayAssert) (Object) null; }2617 public AtomicIntegerArrayAssert hasSizeGreaterThan(int p0) { return (AtomicIntegerArrayAssert) (Object) null; }2618 public AtomicIntegerArrayAssert hasSizeGreaterThanOrEqualTo(int p0) { return (AtomicIntegerArrayAssert) (Object) null; }2619 public AtomicIntegerArrayAssert hasSizeLessThan(int p0) { return (AtomicIntegerArrayAssert) (Object) null; }2620 public AtomicIntegerArrayAssert hasSizeLessThanOrEqualTo(int p0) { return (AtomicIntegerArrayAssert) (Object) null; }2621 public AtomicIntegerArrayAssert hasSizeBetween(int p0, int p1) { return (AtomicIntegerArrayAssert) (Object) null; }2622 public AtomicIntegerArrayAssert hasSameSizeAs(Iterable p0) { return (AtomicIntegerArrayAssert) (Object) null; }2623 public AtomicIntegerArrayAssert contains(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2624 public AtomicIntegerArrayAssert containsOnly(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2625 public AtomicIntegerArrayAssert containsOnlyOnce(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2626 public AtomicIntegerArrayAssert containsSequence(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2627 public AtomicIntegerArrayAssert containsSubsequence(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2628 public AtomicIntegerArrayAssert contains(int p0, org.assertj.core.data.Index p1) { return (AtomicIntegerArrayAssert) (Object) null; }2629 public AtomicIntegerArrayAssert doesNotContain(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2630 public AtomicIntegerArrayAssert doesNotContain(int p0, org.assertj.core.data.Index p1) { return (AtomicIntegerArrayAssert) (Object) null; }2631 public AtomicIntegerArrayAssert doesNotHaveDuplicates() { return (AtomicIntegerArrayAssert) (Object) null; }2632 public AtomicIntegerArrayAssert startsWith(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2633 public AtomicIntegerArrayAssert endsWith(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2634 public AtomicIntegerArrayAssert isSorted() { return (AtomicIntegerArrayAssert) (Object) null; }2635 public AtomicIntegerArrayAssert isSortedAccordingTo(java.util.Comparator p0) { return (AtomicIntegerArrayAssert) (Object) null; }2636 public AtomicIntegerArrayAssert usingElementComparator(java.util.Comparator p0) { return (AtomicIntegerArrayAssert) (Object) null; }2637 public AtomicIntegerArrayAssert usingDefaultElementComparator() { return (AtomicIntegerArrayAssert) (Object) null; }2638 public AtomicIntegerArrayAssert containsExactly(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2639 public AtomicIntegerArrayAssert containsExactlyInAnyOrder(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2640 public AtomicIntegerArrayAssert containsAnyOf(int[] p0) { return (AtomicIntegerArrayAssert) (Object) null; }2641}2642---2643package org.assertj.core.api;2644import java.io.*;2645public class AtomicIntegerAssert extends AbstractAssert {2646 public void AtomicIntegerAssert(java.util.concurrent.atomic.AtomicInteger p0) {}2647 public AtomicIntegerAssert hasValueBetween(int p0, int p1) { return (AtomicIntegerAssert) (Object) null; }2648 public AtomicIntegerAssert hasValueLessThan(int p0) { return (AtomicIntegerAssert) (Object) null; }2649 public AtomicIntegerAssert hasValueLessThanOrEqualTo(int p0) { return (AtomicIntegerAssert) (Object) null; }2650 public AtomicIntegerAssert hasValueGreaterThan(int p0) { return (AtomicIntegerAssert) (Object) null; }2651 public AtomicIntegerAssert hasValueGreaterThanOrEqualTo(int p0) { return (AtomicIntegerAssert) (Object) null; }2652 public AtomicIntegerAssert hasPositiveValue() { return (AtomicIntegerAssert) (Object) null; }2653 public AtomicIntegerAssert hasNonPositiveValue() { return (AtomicIntegerAssert) (Object) null; }2654 public AtomicIntegerAssert hasNegativeValue() { return (AtomicIntegerAssert) (Object) null; }2655 public AtomicIntegerAssert hasNonNegativeValue() { return (AtomicIntegerAssert) (Object) null; }2656 public AtomicIntegerAssert hasValueCloseTo(int p0, org.assertj.core.data.Percentage p1) { return (AtomicIntegerAssert) (Object) null; }2657 public AtomicIntegerAssert hasValueCloseTo(int p0, org.assertj.core.data.Offset p1) { return (AtomicIntegerAssert) (Object) null; }2658 public AtomicIntegerAssert hasValue(int p0) { return (AtomicIntegerAssert) (Object) null; }2659 public AtomicIntegerAssert doesNotHaveValue(int p0) { return (AtomicIntegerAssert) (Object) null; }2660 public AtomicIntegerAssert usingComparator(java.util.Comparator p0) { return (AtomicIntegerAssert) (Object) null; }2661 public AtomicIntegerAssert usingComparator(java.util.Comparator p0, String p1) { return (AtomicIntegerAssert) (Object) null; }2662 public AtomicIntegerAssert usingDefaultComparator() { return (AtomicIntegerAssert) (Object) null; }2663}2664---2665package org.assertj.core.api;2666import java.io.*;2667public class AtomicIntegerFieldUpdaterAssert extends AbstractAtomicFieldUpdaterAssert {2668 public void AtomicIntegerFieldUpdaterAssert(java.util.concurrent.atomic.AtomicIntegerFieldUpdater p0) {}2669 public AtomicIntegerFieldUpdaterAssert hasValue(Integer p0, Object p1) { return (AtomicIntegerFieldUpdaterAssert) (Object) null; }2670 public AbstractAtomicFieldUpdaterAssert hasValue(Object p0, Object p1) { return (AbstractAtomicFieldUpdaterAssert) (Object) null; }2671}2672---2673package org.assertj.core.api;2674import java.io.*;2675public class AtomicLongArrayAssert extends AbstractEnumerableAssert {2676 public void AtomicLongArrayAssert(java.util.concurrent.atomic.AtomicLongArray p0) {}2677 public void isNullOrEmpty() {}2678 public void isEmpty() {}2679 public AtomicLongArrayAssert isNotEmpty() { return (AtomicLongArrayAssert) (Object) null; }2680 public AtomicLongArrayAssert hasArray(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2681 public AtomicLongArrayAssert hasSize(int p0) { return (AtomicLongArrayAssert) (Object) null; }2682 public AtomicLongArrayAssert hasSizeGreaterThan(int p0) { return (AtomicLongArrayAssert) (Object) null; }2683 public AtomicLongArrayAssert hasSizeGreaterThanOrEqualTo(int p0) { return (AtomicLongArrayAssert) (Object) null; }2684 public AtomicLongArrayAssert hasSizeLessThan(int p0) { return (AtomicLongArrayAssert) (Object) null; }2685 public AtomicLongArrayAssert hasSizeLessThanOrEqualTo(int p0) { return (AtomicLongArrayAssert) (Object) null; }2686 public AtomicLongArrayAssert hasSizeBetween(int p0, int p1) { return (AtomicLongArrayAssert) (Object) null; }2687 public AtomicLongArrayAssert hasSameSizeAs(Iterable p0) { return (AtomicLongArrayAssert) (Object) null; }2688 public AtomicLongArrayAssert contains(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2689 public AtomicLongArrayAssert containsOnly(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2690 public AtomicLongArrayAssert containsOnlyOnce(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2691 public AtomicLongArrayAssert containsSequence(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2692 public AtomicLongArrayAssert containsSubsequence(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2693 public AtomicLongArrayAssert contains(long p0, org.assertj.core.data.Index p1) { return (AtomicLongArrayAssert) (Object) null; }2694 public AtomicLongArrayAssert doesNotContain(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2695 public AtomicLongArrayAssert doesNotContain(long p0, org.assertj.core.data.Index p1) { return (AtomicLongArrayAssert) (Object) null; }2696 public AtomicLongArrayAssert doesNotHaveDuplicates() { return (AtomicLongArrayAssert) (Object) null; }2697 public AtomicLongArrayAssert startsWith(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2698 public AtomicLongArrayAssert endsWith(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2699 public AtomicLongArrayAssert isSorted() { return (AtomicLongArrayAssert) (Object) null; }2700 public AtomicLongArrayAssert isSortedAccordingTo(java.util.Comparator p0) { return (AtomicLongArrayAssert) (Object) null; }2701 public AtomicLongArrayAssert usingElementComparator(java.util.Comparator p0) { return (AtomicLongArrayAssert) (Object) null; }2702 public AtomicLongArrayAssert usingDefaultElementComparator() { return (AtomicLongArrayAssert) (Object) null; }2703 public AtomicLongArrayAssert containsExactly(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2704 public AtomicLongArrayAssert containsExactlyInAnyOrder(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2705 public AtomicLongArrayAssert containsAnyOf(long[] p0) { return (AtomicLongArrayAssert) (Object) null; }2706}2707---2708package org.assertj.core.api;2709import java.io.*;2710public class AtomicLongAssert extends AbstractAssert {2711 public void AtomicLongAssert(java.util.concurrent.atomic.AtomicLong p0) {}2712 public AtomicLongAssert hasValueBetween(long p0, long p1) { return (AtomicLongAssert) (Object) null; }2713 public AtomicLongAssert hasValueLessThan(long p0) { return (AtomicLongAssert) (Object) null; }2714 public AtomicLongAssert hasValueLessThanOrEqualTo(long p0) { return (AtomicLongAssert) (Object) null; }2715 public AtomicLongAssert hasValueGreaterThan(long p0) { return (AtomicLongAssert) (Object) null; }2716 public AtomicLongAssert hasValueGreaterThanOrEqualTo(long p0) { return (AtomicLongAssert) (Object) null; }2717 public AtomicLongAssert hasPositiveValue() { return (AtomicLongAssert) (Object) null; }2718 public AtomicLongAssert hasNonPositiveValue() { return (AtomicLongAssert) (Object) null; }2719 public AtomicLongAssert hasNegativeValue() { return (AtomicLongAssert) (Object) null; }2720 public AtomicLongAssert hasNonNegativeValue() { return (AtomicLongAssert) (Object) null; }2721 public AtomicLongAssert hasValueCloseTo(long p0, org.assertj.core.data.Percentage p1) { return (AtomicLongAssert) (Object) null; }2722 public AtomicLongAssert hasValueCloseTo(long p0, org.assertj.core.data.Offset p1) { return (AtomicLongAssert) (Object) null; }2723 public AtomicLongAssert hasValue(long p0) { return (AtomicLongAssert) (Object) null; }2724 public AtomicLongAssert doesNotHaveValue(long p0) { return (AtomicLongAssert) (Object) null; }2725 public AtomicLongAssert usingComparator(java.util.Comparator p0) { return (AtomicLongAssert) (Object) null; }2726 public AtomicLongAssert usingComparator(java.util.Comparator p0, String p1) { return (AtomicLongAssert) (Object) null; }2727 public AtomicLongAssert usingDefaultComparator() { return (AtomicLongAssert) (Object) null; }2728}2729---2730package org.assertj.core.api;2731import java.io.*;2732public class AtomicLongFieldUpdaterAssert extends AbstractAtomicFieldUpdaterAssert {2733 public void AtomicLongFieldUpdaterAssert(java.util.concurrent.atomic.AtomicLongFieldUpdater p0) {}2734 public AtomicLongFieldUpdaterAssert hasValue(Long p0, Object p1) { return (AtomicLongFieldUpdaterAssert) (Object) null; }2735 public AbstractAtomicFieldUpdaterAssert hasValue(Object p0, Object p1) { return (AbstractAtomicFieldUpdaterAssert) (Object) null; }2736}2737---2738package org.assertj.core.api;2739import java.io.*;2740public class AtomicMarkableReferenceAssert extends AbstractAtomicReferenceAssert {2741 public void AtomicMarkableReferenceAssert(java.util.concurrent.atomic.AtomicMarkableReference p0) {}2742 public AtomicMarkableReferenceAssert hasReference(Object p0) { return (AtomicMarkableReferenceAssert) (Object) null; }2743 public AtomicMarkableReferenceAssert isMarked() { return (AtomicMarkableReferenceAssert) (Object) null; }2744 public AtomicMarkableReferenceAssert isNotMarked() { return (AtomicMarkableReferenceAssert) (Object) null; }2745}2746---2747package org.assertj.core.api;2748import java.io.*;2749public class AtomicReferenceArrayAssert extends AbstractAssert implements IndexedObjectEnumerableAssert, ArraySortedAssert {2750 public void AtomicReferenceArrayAssert(java.util.concurrent.atomic.AtomicReferenceArray p0) {}2751 public AtomicReferenceArrayAssert as(org.assertj.core.description.Description p0) { return (AtomicReferenceArrayAssert) (Object) null; }2752 public AtomicReferenceArrayAssert as(String p0, Object[] p1) { return (AtomicReferenceArrayAssert) (Object) null; }2753 public void isNullOrEmpty() {}2754 public void isEmpty() {}2755 public AtomicReferenceArrayAssert isNotEmpty() { return (AtomicReferenceArrayAssert) (Object) null; }2756 public AtomicReferenceArrayAssert hasArray(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2757 public AtomicReferenceArrayAssert hasOnlyOneElementSatisfying(java.util.function.Consumer p0) { return (AtomicReferenceArrayAssert) (Object) null; }2758 public AtomicReferenceArrayAssert hasSize(int p0) { return (AtomicReferenceArrayAssert) (Object) null; }2759 public AtomicReferenceArrayAssert hasSizeGreaterThan(int p0) { return (AtomicReferenceArrayAssert) (Object) null; }2760 public AtomicReferenceArrayAssert hasSizeGreaterThanOrEqualTo(int p0) { return (AtomicReferenceArrayAssert) (Object) null; }2761 public AtomicReferenceArrayAssert hasSizeLessThan(int p0) { return (AtomicReferenceArrayAssert) (Object) null; }2762 public AtomicReferenceArrayAssert hasSizeLessThanOrEqualTo(int p0) { return (AtomicReferenceArrayAssert) (Object) null; }2763 public AtomicReferenceArrayAssert hasSizeBetween(int p0, int p1) { return (AtomicReferenceArrayAssert) (Object) null; }2764 public AtomicReferenceArrayAssert hasSameSizeAs(Object p0) { return (AtomicReferenceArrayAssert) (Object) null; }2765 public AtomicReferenceArrayAssert hasSameSizeAs(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2766 public AtomicReferenceArrayAssert contains(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2767 public AtomicReferenceArrayAssert containsOnly(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2768 public AtomicReferenceArrayAssert containsOnlyElementsOf(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2769 public AtomicReferenceArrayAssert containsOnlyNulls() { return (AtomicReferenceArrayAssert) (Object) null; }2770 public AtomicReferenceArrayAssert hasSameElementsAs(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2771 public AtomicReferenceArrayAssert containsOnlyOnce(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2772 public AtomicReferenceArrayAssert containsOnlyOnceElementsOf(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2773 public AtomicReferenceArrayAssert containsExactly(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2774 public AtomicReferenceArrayAssert containsExactlyInAnyOrder(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2775 public AtomicReferenceArrayAssert containsExactlyInAnyOrderElementsOf(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2776 public AtomicReferenceArrayAssert containsExactlyElementsOf(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2777 public AtomicReferenceArrayAssert containsSequence(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2778 public AtomicReferenceArrayAssert containsSequence(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2779 public AtomicReferenceArrayAssert doesNotContainSequence(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2780 public AtomicReferenceArrayAssert doesNotContainSequence(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2781 public AtomicReferenceArrayAssert containsSubsequence(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2782 public AtomicReferenceArrayAssert containsSubsequence(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2783 public AtomicReferenceArrayAssert doesNotContainSubsequence(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2784 public AtomicReferenceArrayAssert doesNotContainSubsequence(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2785 public AtomicReferenceArrayAssert contains(Object p0, org.assertj.core.data.Index p1) { return (AtomicReferenceArrayAssert) (Object) null; }2786 public AtomicReferenceArrayAssert hasOnlyElementsOfTypes(Class[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2787 public AtomicReferenceArrayAssert doesNotContain(Object p0, org.assertj.core.data.Index p1) { return (AtomicReferenceArrayAssert) (Object) null; }2788 public AtomicReferenceArrayAssert doesNotContain(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2789 public AtomicReferenceArrayAssert doesNotContainAnyElementsOf(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2790 public AtomicReferenceArrayAssert doesNotHaveDuplicates() { return (AtomicReferenceArrayAssert) (Object) null; }2791 public AtomicReferenceArrayAssert startsWith(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2792 public AtomicReferenceArrayAssert endsWith(Object p0, Object[] p1) { return (AtomicReferenceArrayAssert) (Object) null; }2793 public AtomicReferenceArrayAssert endsWith(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2794 public AtomicReferenceArrayAssert isSubsetOf(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2795 public AtomicReferenceArrayAssert isSubsetOf(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2796 public AtomicReferenceArrayAssert containsNull() { return (AtomicReferenceArrayAssert) (Object) null; }2797 public AtomicReferenceArrayAssert doesNotContainNull() { return (AtomicReferenceArrayAssert) (Object) null; }2798 public AtomicReferenceArrayAssert are(Condition p0) { return (AtomicReferenceArrayAssert) (Object) null; }2799 public AtomicReferenceArrayAssert areNot(Condition p0) { return (AtomicReferenceArrayAssert) (Object) null; }2800 public AtomicReferenceArrayAssert have(Condition p0) { return (AtomicReferenceArrayAssert) (Object) null; }2801 public AtomicReferenceArrayAssert doNotHave(Condition p0) { return (AtomicReferenceArrayAssert) (Object) null; }2802 public AtomicReferenceArrayAssert areAtLeast(int p0, Condition p1) { return (AtomicReferenceArrayAssert) (Object) null; }2803 public AtomicReferenceArrayAssert areAtLeastOne(Condition p0) { return (AtomicReferenceArrayAssert) (Object) null; }2804 public AtomicReferenceArrayAssert areAtMost(int p0, Condition p1) { return (AtomicReferenceArrayAssert) (Object) null; }2805 public AtomicReferenceArrayAssert areExactly(int p0, Condition p1) { return (AtomicReferenceArrayAssert) (Object) null; }2806 public AtomicReferenceArrayAssert haveAtLeastOne(Condition p0) { return (AtomicReferenceArrayAssert) (Object) null; }2807 public AtomicReferenceArrayAssert haveAtLeast(int p0, Condition p1) { return (AtomicReferenceArrayAssert) (Object) null; }2808 public AtomicReferenceArrayAssert haveAtMost(int p0, Condition p1) { return (AtomicReferenceArrayAssert) (Object) null; }2809 public AtomicReferenceArrayAssert haveExactly(int p0, Condition p1) { return (AtomicReferenceArrayAssert) (Object) null; }2810 public AtomicReferenceArrayAssert hasAtLeastOneElementOfType(Class p0) { return (AtomicReferenceArrayAssert) (Object) null; }2811 public AtomicReferenceArrayAssert hasOnlyElementsOfType(Class p0) { return (AtomicReferenceArrayAssert) (Object) null; }2812 public AtomicReferenceArrayAssert doesNotHaveAnyElementsOfTypes(Class[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2813 public AtomicReferenceArrayAssert isSorted() { return (AtomicReferenceArrayAssert) (Object) null; }2814 public AtomicReferenceArrayAssert isSortedAccordingTo(java.util.Comparator p0) { return (AtomicReferenceArrayAssert) (Object) null; }2815 public AtomicReferenceArrayAssert containsAll(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2816 public AtomicReferenceArrayAssert usingElementComparator(java.util.Comparator p0) { return (AtomicReferenceArrayAssert) (Object) null; }2817 public AtomicReferenceArrayAssert usingDefaultElementComparator() { return (AtomicReferenceArrayAssert) (Object) null; }2818 public AtomicReferenceArrayAssert usingComparatorForElementFieldsWithNames(java.util.Comparator p0, String[] p1) { return (AtomicReferenceArrayAssert) (Object) null; }2819 public AtomicReferenceArrayAssert usingComparatorForElementFieldsWithType(java.util.Comparator p0, Class p1) { return (AtomicReferenceArrayAssert) (Object) null; }2820 public AtomicReferenceArrayAssert usingComparatorForType(java.util.Comparator p0, Class p1) { return (AtomicReferenceArrayAssert) (Object) null; }2821 public AtomicReferenceArrayAssert usingFieldByFieldElementComparator() { return (AtomicReferenceArrayAssert) (Object) null; }2822 public AtomicReferenceArrayAssert usingRecursiveFieldByFieldElementComparator() { return (AtomicReferenceArrayAssert) (Object) null; }2823 public AtomicReferenceArrayAssert usingElementComparatorOnFields(String[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2824 public AtomicReferenceArrayAssert usingElementComparatorIgnoringFields(String[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2825 public ObjectArrayAssert extracting(String p0) { return (ObjectArrayAssert) (Object) null; }2826 public ObjectArrayAssert extracting(String p0, Class p1) { return (ObjectArrayAssert) (Object) null; }2827 public ObjectArrayAssert extracting(String[] p0) { return (ObjectArrayAssert) (Object) null; }2828 public ObjectArrayAssert extracting(java.util.function.Function p0) { return (ObjectArrayAssert) (Object) null; }2829 public ObjectArrayAssert extracting(org.assertj.core.api.iterable.ThrowingExtractor p0) { return (ObjectArrayAssert) (Object) null; }2830 public ObjectArrayAssert flatExtracting(java.util.function.Function p0) { return (ObjectArrayAssert) (Object) null; }2831 public ObjectArrayAssert flatExtracting(org.assertj.core.api.iterable.ThrowingExtractor p0) { return (ObjectArrayAssert) (Object) null; }2832 public ObjectArrayAssert flatExtracting(String p0) { return (ObjectArrayAssert) (Object) null; }2833 public ObjectArrayAssert extractingResultOf(String p0) { return (ObjectArrayAssert) (Object) null; }2834 public ObjectArrayAssert extractingResultOf(String p0, Class p1) { return (ObjectArrayAssert) (Object) null; }2835 public AtomicReferenceArrayAssert inHexadecimal() { return (AtomicReferenceArrayAssert) (Object) null; }2836 public AtomicReferenceArrayAssert inBinary() { return (AtomicReferenceArrayAssert) (Object) null; }2837 public AtomicReferenceArrayAssert filteredOn(String p0, Object p1) { return (AtomicReferenceArrayAssert) (Object) null; }2838 public AtomicReferenceArrayAssert filteredOnNull(String p0) { return (AtomicReferenceArrayAssert) (Object) null; }2839 public AtomicReferenceArrayAssert filteredOn(String p0, org.assertj.core.api.filter.FilterOperator p1) { return (AtomicReferenceArrayAssert) (Object) null; }2840 public AtomicReferenceArrayAssert filteredOn(Condition p0) { return (AtomicReferenceArrayAssert) (Object) null; }2841 public AtomicReferenceArrayAssert filteredOn(java.util.function.Predicate p0) { return (AtomicReferenceArrayAssert) (Object) null; }2842 public AtomicReferenceArrayAssert filteredOn(java.util.function.Function p0, Object p1) { return (AtomicReferenceArrayAssert) (Object) null; }2843 public AtomicReferenceArrayAssert allMatch(java.util.function.Predicate p0) { return (AtomicReferenceArrayAssert) (Object) null; }2844 public AtomicReferenceArrayAssert allMatch(java.util.function.Predicate p0, String p1) { return (AtomicReferenceArrayAssert) (Object) null; }2845 public AtomicReferenceArrayAssert allSatisfy(java.util.function.Consumer p0) { return (AtomicReferenceArrayAssert) (Object) null; }2846 public AtomicReferenceArrayAssert anyMatch(java.util.function.Predicate p0) { return (AtomicReferenceArrayAssert) (Object) null; }2847 public AtomicReferenceArrayAssert anySatisfy(java.util.function.Consumer p0) { return (AtomicReferenceArrayAssert) (Object) null; }2848 public AtomicReferenceArrayAssert noneSatisfy(java.util.function.Consumer p0) { return (AtomicReferenceArrayAssert) (Object) null; }2849 public AtomicReferenceArrayAssert satisfiesExactly(java.util.function.Consumer[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2850 public AtomicReferenceArrayAssert satisfiesExactlyInAnyOrder(java.util.function.Consumer[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2851 public AtomicReferenceArrayAssert containsAnyOf(Object[] p0) { return (AtomicReferenceArrayAssert) (Object) null; }2852 public AtomicReferenceArrayAssert containsAnyElementsOf(Iterable p0) { return (AtomicReferenceArrayAssert) (Object) null; }2853 public AtomicReferenceArrayAssert noneMatch(java.util.function.Predicate p0) { return (AtomicReferenceArrayAssert) (Object) null; }2854}2855---2856package org.assertj.core.api;2857import java.io.*;2858public class AtomicReferenceAssert extends AbstractAssert {2859 public void AtomicReferenceAssert(java.util.concurrent.atomic.AtomicReference p0) {}2860 public AtomicReferenceAssert hasValue(Object p0) { return (AtomicReferenceAssert) (Object) null; }2861 public AtomicReferenceAssert doesNotHaveValue(Object p0) { return (AtomicReferenceAssert) (Object) null; }2862 public AtomicReferenceAssert hasValueMatching(java.util.function.Predicate p0) { return (AtomicReferenceAssert) (Object) null; }2863 public AtomicReferenceAssert hasValueMatching(java.util.function.Predicate p0, String p1) { return (AtomicReferenceAssert) (Object) null; }2864 public AtomicReferenceAssert hasValueSatisfying(java.util.function.Consumer p0) { return (AtomicReferenceAssert) (Object) null; }2865}2866---2867package org.assertj.core.api;...
Source:AtomicReferenceArrayAssert.java
...56import org.assertj.core.util.CheckReturnValue;57import org.assertj.core.util.IterableUtil;58import org.assertj.core.util.VisibleForTesting;59import org.assertj.core.util.introspection.IntrospectionError;60public class AtomicReferenceArrayAssert<T>61 extends AbstractAssert<AtomicReferenceArrayAssert<T>, AtomicReferenceArray<T>>62 implements IndexedObjectEnumerableAssert<AtomicReferenceArrayAssert<T>, T>,63 ArraySortedAssert<AtomicReferenceArrayAssert<T>, T> {64 private T[] array;65 @VisibleForTesting66 ObjectArrays arrays = ObjectArrays.instance();67 private TypeComparators comparatorsByType = defaultTypeComparators();68 private Map<String, Comparator<?>> comparatorsForElementPropertyOrFieldNames = new TreeMap<>();69 private TypeComparators comparatorsForElementPropertyOrFieldTypes = defaultTypeComparators();70 public AtomicReferenceArrayAssert(AtomicReferenceArray<T> actual) {71 super(actual, AtomicReferenceArrayAssert.class);72 array = array(actual);73 }74 @Override75 @CheckReturnValue76 public AtomicReferenceArrayAssert<T> as(Description description) {77 return super.as(description);78 }79 @Override80 @CheckReturnValue81 public AtomicReferenceArrayAssert<T> as(String description, Object... args) {82 return super.as(description, args);83 }84 /**85 * Verifies that the AtomicReferenceArray is {@code null} or empty.86 * <p>87 * Example:88 * <pre><code class='java'> // assertions will pass89 * assertThat(new AtomicReferenceArray<>(new String[0])).isNullOrEmpty();90 * AtomicReferenceArray array = null;91 * assertThat(array).isNullOrEmpty();92 * 93 * // assertion will fail94 * assertThat(new AtomicReferenceArray<>(new String[] {"a", "b", "c"})).isNullOrEmpty();</code></pre>95 *96 * @throws AssertionError if the AtomicReferenceArray is not {@code null} or not empty.97 * @since 2.7.0 / 3.7.098 */99 @Override100 public void isNullOrEmpty() {101 if (actual == null) return;102 isEmpty();103 }104 /**105 * Verifies that the AtomicReferenceArray is empty.106 * <p>107 * Example:108 * <pre><code class='java'> // assertion will pass109 * assertThat(new AtomicReferenceArray<>(new String[0])).isEmpty();110 * 111 * // assertion will fail112 * assertThat(new AtomicReferenceArray<>(new String[]{"a", "b", "c"})).isEmpty();</code></pre>113 *114 * @throws AssertionError if the AtomicReferenceArray is not empty.115 * @since 2.7.0 / 3.7.0116 */117 @Override118 public void isEmpty() {119 arrays.assertEmpty(info, array);120 }121 /**122 * Verifies that the AtomicReferenceArray is not empty.123 * <p>124 * Example:125 * <pre><code class='java'> // assertion will pass126 * assertThat(new AtomicReferenceArray<>(new String[]{"a", "b", "c"})).isNotEmpty();127 * 128 * // assertion will fail129 * assertThat(new AtomicReferenceArray<>(new String[0])).isNotEmpty();</code></pre>130 *131 * @return {@code this} assertion object.132 * @throws AssertionError if the AtomicReferenceArray is empty.133 * @since 2.7.0 / 3.7.0134 */135 @Override136 public AtomicReferenceArrayAssert<T> isNotEmpty() {137 arrays.assertNotEmpty(info, array);138 return myself;139 }140 /**141 * Verifies that the AtomicReferenceArray has the given array.142 * <p>143 * Example:144 * <pre><code class='java'> AtomicReferenceArray<String> atomicArray = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});145 * 146 * // assertion will pass147 * assertThat(atomicArray).hasArray(new String[]{"a", "b", "c"});148 * 149 * // assertion will fail150 * assertThat(atomicArray).hasArray(new String[]{"a", "b", "c", "d"});</code></pre>151 *152 * @param expected the array expected to be in the actual AtomicReferenceArray.153 * @return {@code this} assertion object.154 * @throws AssertionError if the AtomicReferenceArray does not have the given array.155 * @since 2.7.0 / 3.7.0156 */157 public AtomicReferenceArrayAssert<T> hasArray(T[] expected) {158 arrays.assertContainsExactly(info, array, expected);159 return myself;160 }161 162 /**163 * Verifies that the number of values in the AtomicReferenceArray is equal to the given one.164 * <p>165 * Example:166 * <pre><code class='java'> AtomicReferenceArray<String> atomicArray = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});167 * 168 * assertThat(atomicArray).hasSize(3);169 * 170 * // assertion will fail171 * assertThat(atomicArray).hasSize(1);</code></pre>172 *173 * @param expected the expected number of values in the actual AtomicReferenceArray.174 * @return {@code this} assertion object.175 * @throws AssertionError if the number of values of the AtomicReferenceArray is not equal to the given one.176 * @since 2.7.0 / 3.7.0177 */178 @Override179 public AtomicReferenceArrayAssert<T> hasSize(int expected) {180 arrays.assertHasSize(info, array, expected);181 return myself;182 }183 /**184 * Verifies that the actual AtomicReferenceArray has the same size as the given array.185 * <p>186 * Parameter is declared as Object to accept both {@code Object[]} and primitive arrays (e.g. {@code int[]}).187 * <p>188 * Example:189 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});190 * int[] fourFiveSix = {4, 5, 6};191 * int[] sevenEight = {7, 8};192 *193 * // assertion will pass194 * assertThat(abc).hasSameSizeAs(fourFiveSix);195 *196 * // assertion will fail197 * assertThat(abc).hasSameSizeAs(sevenEight);</code></pre>198 *199 * @param other the array to compare size with actual AtomicReferenceArray.200 * @return {@code this} assertion object.201 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.202 * @throws AssertionError if the array parameter is {@code null} or is not a true array.203 * @throws AssertionError if actual AtomicReferenceArray and given array don't have the same size.204 * @since 2.7.0 / 3.7.0205 */206 @Override207 public AtomicReferenceArrayAssert<T> hasSameSizeAs(Object other) {208 arrays.assertHasSameSizeAs(info, array, other);209 return myself;210 }211 /**212 * Verifies that the actual AtomicReferenceArray has the same size as the given {@link Iterable}.213 * <p>214 * Example:215 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});216 * Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);217 *218 * // assertion will pass219 * assertThat(abc).hasSameSizeAs(elvesRings);220 * 221 * // assertion will fail222 * assertThat(abc).hasSameSizeAs(Arrays.asList("a", "b"));</code></pre>223 *224 * @param other the {@code Iterable} to compare size with actual AtomicReferenceArray.225 * @return {@code this} assertion object.226 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.227 * @throws AssertionError if the other {@code Iterable} is {@code null}.228 * @throws AssertionError if actual AtomicReferenceArray and given {@code Iterable} don't have the same size.229 * @since 2.7.0 / 3.7.0230 */231 @Override232 public AtomicReferenceArrayAssert<T> hasSameSizeAs(Iterable<?> other) {233 arrays.assertHasSameSizeAs(info, array, other);234 return myself;235 }236 /**237 * Verifies that the actual AtomicReferenceArray contains the given values, in any order.238 * <p>239 * Example :240 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});241 *242 * // assertions will pass243 * assertThat(abc).contains("b", "a")244 * .contains("b", "a", "b");245 *246 * // assertions will fail247 * assertThat(abc).contains("d");248 * assertThat(abc).contains("c", "d");</code></pre>249 *250 * @param values the given values.251 * @return {@code this} assertion object.252 * @throws NullPointerException if the given argument is {@code null}.253 * @throws IllegalArgumentException if the given argument is an empty array.254 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.255 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given values.256 * @since 2.7.0 / 3.7.0257 */258 @Override259 public AtomicReferenceArrayAssert<T> contains(@SuppressWarnings("unchecked") T... values) {260 arrays.assertContains(info, array, values);261 return myself;262 }263 /**264 * Verifies that the actual AtomicReferenceArray contains only the given values and nothing else, <b>in any order</b>.265 * <p>266 * Example :267 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});268 *269 * // assertions will pass270 * assertThat(abc).containsOnly("c", "b", "a")271 * .containsOnly("a", "a", "b", "c", "c");272 *273 * // assertion will fail because "c" is missing from the given values274 * assertThat(abc).containsOnly("a", "b");275 * // assertion will fail because abc does not contain "d"276 * assertThat(abc).containsOnly("a", "b", "c", "d");</code></pre>277 *278 * @param values the given values.279 * @return {@code this} assertion object.280 * @throws NullPointerException if the given argument is {@code null}.281 * @throws IllegalArgumentException if the given argument is an empty array.282 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.283 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given values, i.e. the actual AtomicReferenceArray contains some284 * or none of the given values, or the actual AtomicReferenceArray contains more values than the given ones.285 * @since 2.7.0 / 3.7.0286 */287 @Override288 public AtomicReferenceArrayAssert<T> containsOnly(@SuppressWarnings("unchecked") T... values) {289 arrays.assertContainsOnly(info, array, values);290 return myself;291 }292 /**293 * Same semantic as {@link #containsOnly(Object[])} : verifies that actual contains all elements of the given294 * {@code Iterable} and nothing else, <b>in any order</b>.295 * <p>296 * Example :297 * <pre><code class='java'> AtomicReferenceArray<Ring> rings = new AtomicReferenceArray<>(new Ring[]{nenya, vilya});298 *299 * // assertions will pass300 * assertThat(rings).containsOnlyElementsOf(newArrayList(nenya, vilya))301 * .containsOnlyElementsOf(newArrayList(nenya, nenya, vilya, vilya));302 *303 * // assertion will fail as actual does not contain narya304 * assertThat(rings).containsOnlyElementsOf(newArrayList(nenya, vilya, narya));305 * // assertion will fail as actual contains nenya306 * assertThat(rings).containsOnlyElementsOf(newArrayList(vilya));</code></pre>307 *308 * @param iterable the given {@code Iterable} we will get elements from.309 * @since 2.7.0 / 3.7.0310 */311 @Override312 public AtomicReferenceArrayAssert<T> containsOnlyElementsOf(Iterable<? extends T> iterable) {313 return containsOnly(toArray(iterable));314 }315 /**316 * Verifies that the actual AtomicReferenceArray contains only null elements and nothing else.317 * <p>318 * Example :319 * <pre><code class='java'> // assertion will pass320 * AtomicReferenceArray<String> items = new AtomicReferenceArray<>(new String[]{null, null, null});321 * assertThat(items).containsOnlyNulls();322 *323 * // assertion will fail because items2 contains not null element324 * AtomicReferenceArray<String> items2 = new AtomicReferenceArray<>(new String[]{null, null, "notNull"});325 * assertThat(items2).containsOnlyNulls();326 * 327 * // assertion will fail since an empty array does not contain any element and therefore no null ones.328 * AtomicReferenceArray<String> empty = new AtomicReferenceArray<>(new String[0]);329 * assertThat(empty).containsOnlyNulls();</code></pre>330 *331 * @return {@code this} assertion object.332 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.333 * @throws AssertionError if the actual AtomicReferenceArray is empty or contains non null elements.334 * @since 2.9.0 / 3.9.0335 */336 @Override337 public AtomicReferenceArrayAssert<T> containsOnlyNulls() {338 arrays.assertContainsOnlyNulls(info, array);339 return myself;340 }341 /**342 * An alias of {@link #containsOnlyElementsOf(Iterable)} : verifies that actual contains all elements of the343 * given {@code Iterable} and nothing else, <b>in any order</b>.344 * <p>345 * Example:346 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});347 *348 * // assertions will pass:349 * assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, narya, vilya))350 * .hasSameElementsAs(newArrayList(nenya, narya, vilya, nenya));351 *352 * // assertions will fail:353 * assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, narya));354 * assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, narya, vilya, oneRing));</code></pre>355 *356 * @param iterable the {@code Iterable} whose elements we expect to be present357 * @return this assertion object358 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}359 * @throws NullPointerException if the given {@code Iterable} is {@code null}360 * @throws AssertionError if the actual {@code Iterable} does not have the same elements, in any order, as the given361 * {@code Iterable}362 * @since 2.7.0 / 3.7.0363 */364 @Override365 public AtomicReferenceArrayAssert<T> hasSameElementsAs(Iterable<? extends T> iterable) {366 return containsOnlyElementsOf(iterable);367 }368 /**369 * Verifies that the actual AtomicReferenceArray contains the given values only once.370 * <p>371 * Examples :372 * <pre><code class='java'> // array is a factory method to create arrays.373 * AtomicReferenceArray<String> got = new AtomicReferenceArray<>(new String[]{"winter", "is", "coming"});374 *375 * // assertions will pass376 * assertThat(got).containsOnlyOnce("winter")377 * .containsOnlyOnce("coming", "winter");378 *379 * // assertions will fail380 * AtomicReferenceArray<String> stark= new AtomicReferenceArray<>(new String[]{"Arya", "Stark", "daughter", "of", "Ned", "Stark")});381 * assertThat(got).containsOnlyOnce("Lannister");382 * assertThat(stark).containsOnlyOnce("Stark");</code></pre>383 *384 * @param values the given values.385 * @return {@code this} assertion object.386 * @throws NullPointerException if the given argument is {@code null}.387 * @throws IllegalArgumentException if the given argument is an empty array.388 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.389 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given values, i.e. the actual AtomicReferenceArray contains some390 * or none of the given values, or the actual AtomicReferenceArray contains more than once these values.391 * @since 2.7.0 / 3.7.0392 */393 @Override394 public AtomicReferenceArrayAssert<T> containsOnlyOnce(@SuppressWarnings("unchecked") T... values) {395 arrays.assertContainsOnlyOnce(info, array, values);396 return myself;397 }398 /**399 * Verifies that the actual AtomicReferenceArray contains only the given values and nothing else, <b>in order</b>.<br>400 * <p>401 * Example :402 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});403 *404 * // assertion will pass405 * assertThat(elvesRings).containsExactly(vilya, nenya, narya);406 *407 * // assertion will fail as actual and expected order differ408 * assertThat(elvesRings).containsExactly(nenya, vilya, narya);</code></pre>409 *410 * @param values the given values.411 * @return {@code this} assertion object.412 * @throws NullPointerException if the given argument is {@code null}.413 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.414 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given values with same order, i.e. the actual AtomicReferenceArray415 * contains some or none of the given values, or the actual AtomicReferenceArray contains more values than the given ones416 * or values are the same but the order is not.417 * @since 2.7.0 / 3.7.0418 */419 @Override420 public AtomicReferenceArrayAssert<T> containsExactly(@SuppressWarnings("unchecked") T... values) {421 arrays.assertContainsExactly(info, array, values);422 return myself;423 }424 /**425 * Verifies that the actual AtomicReferenceArray contains exactly the given values and nothing else, <b>in any order</b>.<br>426 *427 * <p>428 * Example :429 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});430 *431 * // assertion will pass432 * assertThat(elvesRings).containsExactlyInAnyOrder(vilya, vilya, nenya, narya);433 *434 * // assertion will fail as vilya is contained twice in elvesRings.435 * assertThat(elvesRings).containsExactlyInAnyOrder(nenya, vilya, narya);</code></pre>436 *437 * @param values the given values.438 * @return {@code this} assertion object.439 * @throws NullPointerException if the given argument is {@code null}.440 * @throws AssertionError if the actual group is {@code null}.441 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given values, i.e. it442 * contains some or none of the given values, or more values than the given ones.443 */444 @Override445 public AtomicReferenceArrayAssert<T> containsExactlyInAnyOrder(@SuppressWarnings("unchecked") T... values) {446 arrays.assertContainsExactlyInAnyOrder(info, array, values);447 return myself;448 }449 /**450 * Verifies that the actual AtomicReferenceArray contains exactly the given values and nothing else, <b>in any order</b>.<br>451 *452 * <p>453 * Example :454 * <pre><code class='java'>455 * AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray(new Ring[]{vilya, nenya, narya, vilya});456 * AtomicReferenceArray<Ring> elvesRingsSomeMissing = new AtomicReferenceArray(new Ring[]{vilya, nenya, narya});457 * AtomicReferenceArray<Ring> elvesRingsDifferentOrder = new AtomicReferenceArray(new Ring[]{nenya, narya, vilya, vilya});458 *459 * // assertion will pass460 * assertThat(elvesRings).containsExactlyInAnyOrder(elvesRingsDifferentOrder);461 *462 * // assertion will fail as vilya is contained twice in elvesRings.463 * assertThat(elvesRings).containsExactlyInAnyOrder(elvesRingsSomeMissing);</code></pre>464 *465 * @param values the given values.466 * @return {@code this} assertion object.467 * @throws NullPointerException if the given argument is {@code null}.468 * @throws AssertionError if the actual group is {@code null}.469 * @throws AssertionError if the actual group does not contain the given values, i.e. the actual group470 * contains some or none of the given values, or the actual group contains more values than the given ones.471 * @since 2.9.0 / 3.9.0472 */473 @Override474 public AtomicReferenceArrayAssert<T> containsExactlyInAnyOrderElementsOf(Iterable<? extends T> values) {475 return containsExactlyInAnyOrder(toArray(values));476 }477 /**478 * Same as {@link #containsExactly(Object...)} but handles the {@link Iterable} to array conversion : verifies that479 * actual contains all elements of the given {@code Iterable} and nothing else <b>in the same order</b>.480 * <p>481 * Example :482 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});483 *484 * // assertion will pass485 * assertThat(elvesRings).containsExactlyElementsOf(newLinkedList(vilya, nenya, narya));486 *487 * // assertion will fail as actual and expected order differ488 * assertThat(elvesRings).containsExactlyElementsOf(newLinkedList(nenya, vilya, narya));</code></pre>489 *490 * @param iterable the given {@code Iterable} we will get elements from.491 */492 @Override493 public AtomicReferenceArrayAssert<T> containsExactlyElementsOf(Iterable<? extends T> iterable) {494 return containsExactly(toArray(iterable));495 }496 /**497 * Verifies that the actual AtomicReferenceArray contains the given sequence in the correct order and <b>without extra values between the sequence values</b>.498 * <p>499 * Use {@link #containsSubsequence(Object...)} to allow values between the expected sequence values.500 * <p>501 * Example:502 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});503 *504 * // assertion will pass505 * assertThat(elvesRings).containsSequence(vilya, nenya)506 * .containsSequence(nenya, narya);507 *508 * // assertions will fail, the elements order is correct but there is a value between them (nenya)509 * assertThat(elvesRings).containsSequence(vilya, narya);510 * assertThat(elvesRings).containsSequence(nenya, vilya);</code></pre>511 *512 * @param sequence the sequence of objects to look for.513 * @return this assertion object.514 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.515 * @throws AssertionError if the given array is {@code null}.516 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given sequence.517 */518 @Override519 public AtomicReferenceArrayAssert<T> containsSequence(@SuppressWarnings("unchecked") T... sequence) {520 arrays.assertContainsSequence(info, array, sequence);521 return myself;522 }523 /**524 * Verifies that the actual AtomicReferenceArray contains the given sequence in the correct order and <b>without extra values between the sequence values</b>.525 * <p>526 * Use {@link #containsSubsequence(Object...)} to allow values between the expected sequence values.527 * <p>528 * Example:529 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});530 *531 * // assertion will pass532 * assertThat(elvesRings).containsSequence(newArrayList(vilya, nenya))533 * .containsSequence(newArrayList(nenya, narya));534 *535 * // assertions will fail, the elements order is correct but there is a value between them (nenya)536 * assertThat(elvesRings).containsSequence(newArrayList(vilya, narya));537 * assertThat(elvesRings).containsSequence(newArrayList(nenya, vilya));</code></pre>538 *539 * @param sequence the sequence of objects to look for.540 * @return this assertion object.541 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.542 * @throws AssertionError if the given array is {@code null}.543 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given sequence.544 */545 @Override546 public AtomicReferenceArrayAssert<T> containsSequence(Iterable<? extends T> sequence) {547 checkSequenceIsNotNull(sequence);548 arrays.assertContainsSequence(info, array, toArray(sequence));549 return myself;550 }551 /**552 * Verifies that the actual AtomicReferenceArray contains the given sequence in the given order and <b>without extra values between the sequence values</b>.553 * <p>554 * Use {@link #doesNotContainSubsequence(Object...)} to also ensure the sequence does not exist with values between the expected sequence values.555 * <p>556 * Example:557 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});558 *559 * // assertion will pass, the elements order is correct but there is a value between them (nenya)560 * assertThat(elvesRings).containsSequence(vilya, narya);561 * assertThat(elvesRings).containsSequence(nenya, vilya);562 *563 * // assertions will fail564 * assertThat(elvesRings).containsSequence(vilya, nenya);565 * assertThat(elvesRings).containsSequence(nenya, narya);</code></pre>566 *567 * @param sequence the sequence of objects to look for.568 * @return this assertion object.569 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.570 * @throws AssertionError if the given array is {@code null}.571 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given sequence.572 */573 @Override574 public AtomicReferenceArrayAssert<T> doesNotContainSequence(@SuppressWarnings("unchecked") T... sequence) {575 arrays.assertDoesNotContainSequence(info, array, sequence);576 return myself;577 }578 /**579 * Verifies that the actual AtomicReferenceArray contains the given sequence in the given order and <b>without extra values between the sequence values</b>.580 * <p>581 * Use {@link #doesNotContainSubsequence(Iterable)} to also ensure the sequence does not exist with values between the expected sequence values.582 * <p>583 * Example:584 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});585 *586 * // assertion will pass, the elements order is correct but there is a value between them (nenya)587 * assertThat(elvesRings).containsSequence(newArrayList(vilya, narya));588 * assertThat(elvesRings).containsSequence(newArrayList(nenya, vilya));589 *590 * // assertions will fail591 * assertThat(elvesRings).containsSequence(newArrayList(vilya, nenya));592 * assertThat(elvesRings).containsSequence(newArrayList(nenya, narya));</code></pre>593 *594 * @param sequence the sequence of objects to look for.595 * @return this assertion object.596 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.597 * @throws AssertionError if the given array is {@code null}.598 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given sequence.599 */600 @Override601 public AtomicReferenceArrayAssert<T> doesNotContainSequence(Iterable<? extends T> sequence) {602 checkSequenceIsNotNull(sequence);603 arrays.assertDoesNotContainSequence(info, array, toArray(sequence));604 return myself;605 }606 /**607 * Verifies that the actual AtomicReferenceArray contains the given subsequence in the correct order (possibly with other values between them).608 * <p>609 * Example:610 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});611 *612 * // assertions will pass613 * assertThat(elvesRings).containsSubsequence(vilya, nenya)614 * .containsSubsequence(vilya, narya);615 *616 * // assertion will fail617 * assertThat(elvesRings).containsSubsequence(nenya, vilya);</code></pre>618 *619 * @param subsequence the subsequence of objects to look for.620 * @return this assertion object.621 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.622 * @throws AssertionError if the given array is {@code null}.623 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given subsequence.624 */625 @Override626 public AtomicReferenceArrayAssert<T> containsSubsequence(@SuppressWarnings("unchecked") T... subsequence) {627 arrays.assertContainsSubsequence(info, array, subsequence);628 return myself;629 }630 /**631 * Verifies that the actual AtomicReferenceArray contains the given subsequence in the correct order (possibly with other values between them).632 * <p>633 * Example:634 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});635 *636 * // assertions will pass637 * assertThat(elvesRings).containsSubsequence(newArrayList(vilya, nenya))638 * .containsSubsequence(newArrayList(vilya, narya));639 *640 * // assertion will fail641 * assertThat(elvesRings).containsSubsequence(newArrayList(nenya, vilya));</code></pre>642 *643 * @param subsequence the subsequence of objects to look for.644 * @return this assertion object.645 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.646 * @throws AssertionError if the given array is {@code null}.647 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given subsequence.648 */649 @Override650 public AtomicReferenceArrayAssert<T> containsSubsequence(Iterable<? extends T> subsequence) {651 checkSubsequenceIsNotNull(subsequence);652 arrays.assertContainsSubsequence(info, array, toArray(subsequence));653 return myself;654 }655 /**656 * Verifies that the actual AtomicReferenceArray does not contain the given subsequence in the correct order (possibly657 * with other values between them).658 * <p>659 * Example:660 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});661 *662 * // assertions will pass663 * assertThat(elvesRings).doesNotContainSubsequence(nenya, vilya);664 *665 * // assertion will fail666 * assertThat(elvesRings).doesNotContainSubsequence(vilya, nenya);667 * assertThat(elvesRings).doesNotContainSubsequence(vilya, narya);</code></pre>668 *669 * @param subsequence the subsequence of objects to look for.670 * @return this assertion object.671 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.672 * @throws AssertionError if the given array is {@code null}.673 * @throws AssertionError if the actual AtomicReferenceArray contains the given subsequence.674 */675 @Override676 public AtomicReferenceArrayAssert<T> doesNotContainSubsequence(@SuppressWarnings("unchecked") T... subsequence) {677 arrays.assertDoesNotContainSubsequence(info, array, subsequence);678 return myself;679 }680 /**681 * Verifies that the actual AtomicReferenceArray does not contain the given subsequence in the correct order (possibly682 * with other values between them).683 * <p>684 * Example:685 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});686 *687 * // assertions will pass688 * assertThat(elvesRings).doesNotContainSubsequence(newArrayList(nenya, vilya));689 *690 * // assertion will fail691 * assertThat(elvesRings).doesNotContainSubsequence(newArrayList(vilya, nenya));692 * assertThat(elvesRings).doesNotContainSubsequence(newArrayList(vilya, narya));</code></pre>693 *694 * @param subsequence the subsequence of objects to look for.695 * @return this assertion object.696 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.697 * @throws AssertionError if the given array is {@code null}.698 * @throws AssertionError if the actual AtomicReferenceArray contains the given subsequence.699 */700 @Override701 public AtomicReferenceArrayAssert<T> doesNotContainSubsequence(Iterable<? extends T> subsequence) {702 checkSubsequenceIsNotNull(subsequence);703 arrays.assertDoesNotContainSubsequence(info, array, toArray(subsequence));704 return myself;705 }706 /**707 * Verifies that the actual AtomicReferenceArray contains the given object at the given index.708 * <p>709 * Example:710 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});711 *712 * // assertions will pass713 * assertThat(elvesRings).contains(vilya, atIndex(0))714 * .contains(nenya, atIndex(1))715 * .contains(narya, atIndex(2));716 *717 * // assertions will fail718 * assertThat(elvesRings).contains(vilya, atIndex(1));719 * assertThat(elvesRings).contains(nenya, atIndex(2));720 * assertThat(elvesRings).contains(narya, atIndex(0));</code></pre>721 *722 * @param value the object to look for.723 * @param index the index where the object should be stored in the actual AtomicReferenceArray.724 * @return this assertion object.725 * @throws AssertionError if the actual AtomicReferenceArray is {@code null} or empty.726 * @throws NullPointerException if the given {@code Index} is {@code null}.727 * @throws IndexOutOfBoundsException if the value of the given {@code Index} is equal to or greater than the size of the actual728 * AtomicReferenceArray.729 * @throws AssertionError if the actual AtomicReferenceArray does not contain the given object at the given index.730 */731 @Override732 public AtomicReferenceArrayAssert<T> contains(T value, Index index) {733 arrays.assertContains(info, array, value, index);734 return myself;735 }736 /**737 * Verifies that all elements of the actual group are instances of given classes or interfaces.738 * <p>739 * Example :740 * <pre><code class='java'> AtomicReferenceArray<Object> elvesRings = new AtomicReferenceArray<>(new Object[]{"", new StringBuilder()});741 * 742 * // assertions will pass743 * assertThat(objects).hasOnlyElementsOfTypes(CharSequence.class);744 * assertThat(objects).hasOnlyElementsOfTypes(String.class, StringBuilder.class);745 * 746 * // assertions will fail747 * assertThat(objects).hasOnlyElementsOfTypes(Number.class);748 * assertThat(objects).hasOnlyElementsOfTypes(String.class, Number.class);749 * assertThat(objects).hasOnlyElementsOfTypes(String.class);</code></pre>750 * 751 * @param types the expected classes and interfaces752 * @return {@code this} assertion object.753 * @throws NullPointerException if the given argument is {@code null}.754 * @throws AssertionError if the actual group is {@code null}.755 * @throws AssertionError if not all elements of the actual group are instances of one of the given types756 * @since 2.7.0 / 3.7.0757 */758 @Override759 public AtomicReferenceArrayAssert<T> hasOnlyElementsOfTypes(Class<?>... types) {760 arrays.assertHasOnlyElementsOfTypes(info, array, types);761 return myself;762 }763 /**764 * Verifies that the actual AtomicReferenceArray does not contain the given object at the given index.765 * <p>766 * Example:767 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});768 *769 * // assertions will pass770 * assertThat(elvesRings).doesNotContain(vilya, atIndex(1))771 * .doesNotContain(nenya, atIndex(2))772 * .doesNotContain(narya, atIndex(0));773 *774 * // assertions will fail775 * assertThat(elvesRings).doesNotContain(vilya, atIndex(0));776 * assertThat(elvesRings).doesNotContain(nenya, atIndex(1));777 * assertThat(elvesRings).doesNotContain(narya, atIndex(2));</code></pre>778 *779 * @param value the object to look for.780 * @param index the index where the object should not be stored in the actual AtomicReferenceArray.781 * @return this assertion object.782 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.783 * @throws NullPointerException if the given {@code Index} is {@code null}.784 * @throws AssertionError if the actual AtomicReferenceArray contains the given object at the given index.785 */786 @Override787 public AtomicReferenceArrayAssert<T> doesNotContain(T value, Index index) {788 arrays.assertDoesNotContain(info, array, value, index);789 return myself;790 }791 /**792 * Verifies that the actual AtomicReferenceArray does not contain the given values.793 * <p>794 * Example :795 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});796 *797 * // assertion will pass798 * assertThat(abc).doesNotContain("d", "e");799 *800 * // assertions will fail801 * assertThat(abc).doesNotContain("a");802 * assertThat(abc).doesNotContain("a", "b", "c");803 * assertThat(abc).doesNotContain("a", "x");</code></pre>804 *805 * @param values the given values.806 * @return {@code this} assertion object.807 * @throws NullPointerException if the given argument is {@code null}.808 * @throws IllegalArgumentException if the given argument is an empty array.809 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.810 * @throws AssertionError if the actual AtomicReferenceArray contains any of the given values.811 */812 @Override813 public AtomicReferenceArrayAssert<T> doesNotContain(@SuppressWarnings("unchecked") T... values) {814 arrays.assertDoesNotContain(info, array, values);815 return myself;816 }817 /**818 * Verifies that the actual AtomicReferenceArray does not contain any elements of the given {@link Iterable} (i.e. none).819 * <p>820 * Example:821 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});822 *823 * // assertion will pass824 * assertThat(actual).doesNotContainAnyElementsOf(newArrayList("d", "e"));825 *826 * // assertions will fail827 * assertThat(actual).doesNotContainAnyElementsOf(newArrayList("a", "b"));828 * assertThat(actual).doesNotContainAnyElementsOf(newArrayList("d", "e", "a"));</code></pre>829 *830 * @param iterable the {@link Iterable} whose elements must not be in the actual AtomicReferenceArray.831 * @return {@code this} assertion object.832 * @throws NullPointerException if the given argument is {@code null}.833 * @throws IllegalArgumentException if the given argument is an empty iterable.834 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.835 * @throws AssertionError if the actual AtomicReferenceArray contains some elements of the given {@link Iterable}.836 */837 @Override838 public AtomicReferenceArrayAssert<T> doesNotContainAnyElementsOf(Iterable<? extends T> iterable) {839 arrays.assertDoesNotContainAnyElementsOf(info, array, iterable);840 return myself;841 }842 /**843 * Verifies that the actual AtomicReferenceArray does not contain duplicates.844 * <p>845 * Example :846 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});847 * AtomicReferenceArray<String> aaa = new AtomicReferenceArray<>(new String[]{"a", "a", "a"});848 *849 * // assertion will pass850 * assertThat(abc).doesNotHaveDuplicates();851 *852 * // assertion will fail853 * assertThat(aaa).doesNotHaveDuplicates();</code></pre>854 *855 * @return {@code this} assertion object.856 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.857 * @throws AssertionError if the actual AtomicReferenceArray contains duplicates.858 */859 @Override860 public AtomicReferenceArrayAssert<T> doesNotHaveDuplicates() {861 arrays.assertDoesNotHaveDuplicates(info, array);862 return myself;863 }864 /**865 * Verifies that the actual AtomicReferenceArray starts with the given sequence of objects, without any other objects between them.866 * Similar to <code>{@link #containsSequence(Object...)}</code>, but it also verifies that the first element in the867 * sequence is also the first element of the actual AtomicReferenceArray.868 * <p>869 * Example :870 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});871 *872 * // assertion will pass873 * assertThat(abc).startsWith("a", "b");874 *875 * // assertion will fail876 * assertThat(abc).startsWith("c");</code></pre>877 *878 * @param sequence the sequence of objects to look for.879 * @return this assertion object.880 * @throws NullPointerException if the given argument is {@code null}.881 * @throws IllegalArgumentException if the given argument is an empty array.882 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.883 * @throws AssertionError if the actual AtomicReferenceArray does not start with the given sequence of objects.884 */885 @Override886 public AtomicReferenceArrayAssert<T> startsWith(@SuppressWarnings("unchecked") T... sequence) {887 arrays.assertStartsWith(info, array, sequence);888 return myself;889 }890 /**891 * Verifies that the actual AtomicReferenceArray ends with the given sequence of objects, without any other objects between them.892 * Similar to <code>{@link #containsSequence(Object...)}</code>, but it also verifies that the last element in the893 * sequence is also last element of the actual AtomicReferenceArray.894 * <p>895 * Example :896 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});897 *898 * // assertion will pass899 * assertThat(abc).endsWith("b", "c");900 *901 * // assertion will fail902 * assertThat(abc).endsWith("a");</code></pre>903 *904 * @param first the first element of the end sequence of objects to look for.905 * @param sequence the rest of the end sequence of objects to look for.906 * @return this assertion object.907 * @throws NullPointerException if the given argument is {@code null}.908 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.909 * @throws AssertionError if the actual AtomicReferenceArray does not end with the given sequence of objects.910 */911 @Override912 public AtomicReferenceArrayAssert<T> endsWith(T first, @SuppressWarnings("unchecked") T... sequence) {913 arrays.assertEndsWith(info, array, first, sequence);914 return myself;915 }916 /**917 * Verifies that the actual AtomicReferenceArray ends with the given sequence of objects, without any other objects between them.918 * Similar to <code>{@link #containsSequence(Object...)}</code>, but it also verifies that the last element in the919 * sequence is also last element of the actual AtomicReferenceArray.920 * <p>921 * Example :922 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});923 *924 * // assertions will pass925 * assertThat(abc).endsWith(new String[0])926 * .endsWith(new String[] {"b", "c"});927 *928 * // assertion will fail929 * assertThat(abc).endsWith(new String[] {"a"});</code></pre>930 *931 * @param sequence the (possibly empty) sequence of objects to look for.932 * @return this assertion object.933 * @throws NullPointerException if the given argument is {@code null}.934 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.935 * @throws AssertionError if the actual AtomicReferenceArray does not end with the given sequence of objects.936 */937 @Override938 public AtomicReferenceArrayAssert<T> endsWith(T[] sequence) {939 arrays.assertEndsWith(info, array, sequence);940 return myself;941 }942 /**943 * Verifies that all elements of actual are present in the given {@code Iterable}.944 * <p>945 * Example:946 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});947 * List<Ring> ringsOfPower = newArrayList(oneRing, vilya, nenya, narya, dwarfRing, manRing);948 *949 * // assertion will pass:950 * assertThat(elvesRings).isSubsetOf(ringsOfPower);951 *952 * // assertion will fail:953 * assertThat(elvesRings).isSubsetOf(newArrayList(nenya, narya));</code></pre>954 *955 * @param values the {@code Iterable} that should contain all actual elements.956 * @return this assertion object.957 * @throws AssertionError if the actual {@code Iterable} is {@code null}.958 * @throws NullPointerException if the given {@code Iterable} is {@code null}.959 * @throws AssertionError if the actual {@code Iterable} is not subset of set {@code Iterable}.960 */961 @Override962 public AtomicReferenceArrayAssert<T> isSubsetOf(Iterable<? extends T> values) {963 arrays.assertIsSubsetOf(info, array, values);964 return myself;965 }966 /**967 * Verifies that all elements of actual are present in the given values.968 * <p>969 * Example:970 * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya});971 *972 * // assertions will pass:973 * assertThat(elvesRings).isSubsetOf(vilya, nenya, narya)974 * .isSubsetOf(vilya, nenya, narya, dwarfRing);975 *976 * // assertions will fail:977 * assertThat(elvesRings).isSubsetOf(vilya, nenya);978 * assertThat(elvesRings).isSubsetOf(vilya, nenya, dwarfRing);</code></pre>979 *980 * @param values the values that should be used for checking the elements of actual.981 * @return this assertion object.982 * @throws AssertionError if the actual {@code Iterable} is {@code null}.983 * @throws AssertionError if the actual {@code Iterable} is not subset of the given values.984 */985 @Override986 public AtomicReferenceArrayAssert<T> isSubsetOf(@SuppressWarnings("unchecked") T... values) {987 arrays.assertIsSubsetOf(info, array, Arrays.asList(values));988 return myself;989 }990 /**991 * Verifies that the actual AtomicReferenceArray contains at least a null element.992 * <p>993 * Example :994 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});995 * AtomicReferenceArray<String> abNull = new AtomicReferenceArray<>(new String[]{"a", "b", null});996 *997 * // assertion will pass998 * assertThat(abNull).containsNull();999 *1000 * // assertion will fail1001 * assertThat(abc).containsNull();</code></pre>1002 *1003 * @return {@code this} assertion object.1004 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.1005 * @throws AssertionError if the actual AtomicReferenceArray does not contain a null element.1006 */1007 @Override1008 public AtomicReferenceArrayAssert<T> containsNull() {1009 arrays.assertContainsNull(info, array);1010 return myself;1011 }1012 /**1013 * Verifies that the actual AtomicReferenceArray does not contain null elements.1014 * <p>1015 * Example :1016 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});1017 * AtomicReferenceArray<String> abNull = new AtomicReferenceArray<>(new String[]{"a", "b", null});1018 *1019 * // assertion will pass1020 * assertThat(abc).doesNotContainNull();1021 *1022 * // assertion will fail1023 * assertThat(abNull).doesNotContainNull();</code></pre>1024 *1025 * @return {@code this} assertion object.1026 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.1027 * @throws AssertionError if the actual AtomicReferenceArray contains a null element.1028 */1029 @Override1030 public AtomicReferenceArrayAssert<T> doesNotContainNull() {1031 arrays.assertDoesNotContainNull(info, array);1032 return myself;1033 }1034 /**1035 * Verifies that each element value satisfies the given condition1036 * <p>1037 * Example :1038 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});1039 * AtomicReferenceArray<String> abcc = new AtomicReferenceArray<>(new String[]{"a", "b", "cc"});1040 *1041 * Condition<String> singleCharacterString1042 * = new Condition<>(s -> s.length() == 1, "single character String");1043 *1044 * // assertion will pass1045 * assertThat(abc).are(singleCharacterString);1046 *1047 * // assertion will fail1048 * assertThat(abcc).are(singleCharacterString);</code></pre>1049 *1050 * @param condition the given condition.1051 * @return {@code this} object.1052 * @throws NullPointerException if the given condition is {@code null}.1053 * @throws AssertionError if an element cannot be cast to T.1054 * @throws AssertionError if one or more elements don't satisfy the given condition.1055 */1056 @Override1057 public AtomicReferenceArrayAssert<T> are(Condition<? super T> condition) {1058 arrays.assertAre(info, array, condition);1059 return myself;1060 }1061 /**1062 * Verifies that each element value does not satisfy the given condition1063 * <p>1064 * Example :1065 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});1066 * AtomicReferenceArray<String> abcc = new AtomicReferenceArray<>(new String[]{"a", "b", "cc"});1067 *1068 * Condition<String> moreThanOneCharacter =1069 * = new Condition<>(s -> s.length() > 1, "more than one character");1070 *1071 * // assertion will pass1072 * assertThat(abc).areNot(moreThanOneCharacter);1073 *1074 * // assertion will fail1075 * assertThat(abcc).areNot(moreThanOneCharacter);</code></pre>1076 *1077 * @param condition the given condition.1078 * @return {@code this} object.1079 * @throws NullPointerException if the given condition is {@code null}.1080 * @throws AssertionError if an element cannot be cast to T.1081 * @throws AssertionError if one or more elements satisfy the given condition.1082 */1083 @Override1084 public AtomicReferenceArrayAssert<T> areNot(Condition<? super T> condition) {1085 arrays.assertAreNot(info, array, condition);1086 return myself;1087 }1088 /**1089 * Verifies that all elements satisfy the given condition.1090 * <p>1091 * Example :1092 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});1093 * AtomicReferenceArray<String> abcc = new AtomicReferenceArray<>(new String[]{"a", "b", "cc"});1094 *1095 * Condition<String> onlyOneCharacter =1096 * = new Condition<>(s -> s.length() == 1, "only one character");1097 *1098 * // assertion will pass1099 * assertThat(abc).have(onlyOneCharacter);1100 *1101 * // assertion will fail1102 * assertThat(abcc).have(onlyOneCharacter);</code></pre>1103 *1104 * @param condition the given condition.1105 * @return {@code this} object.1106 * @throws NullPointerException if the given condition is {@code null}.1107 * @throws AssertionError if an element cannot be cast to T.1108 * @throws AssertionError if one or more elements do not satisfy the given condition.1109 */1110 @Override1111 public AtomicReferenceArrayAssert<T> have(Condition<? super T> condition) {1112 arrays.assertHave(info, array, condition);1113 return myself;1114 }1115 /**1116 * Verifies that all elements don't satisfy the given condition.1117 * <p>1118 * Example :1119 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});1120 * AtomicReferenceArray<String> abcc = new AtomicReferenceArray<>(new String[]{"a", "b", "cc"});1121 *1122 * Condition<String> moreThanOneCharacter =1123 * = new Condition<>(s -> s.length() > 1, "more than one character");1124 *1125 * // assertion will pass1126 * assertThat(abc).doNotHave(moreThanOneCharacter);1127 *1128 * // assertion will fail1129 * assertThat(abcc).doNotHave(moreThanOneCharacter);</code></pre>1130 *1131 * @param condition the given condition.1132 * @return {@code this} object.1133 * @throws NullPointerException if the given condition is {@code null}.1134 * @throws AssertionError if an element cannot be cast to T.1135 * @throws AssertionError if one or more elements satisfy the given condition.1136 */1137 @Override1138 public AtomicReferenceArrayAssert<T> doNotHave(Condition<? super T> condition) {1139 arrays.assertDoNotHave(info, array, condition);1140 return myself;1141 }1142 /**1143 * Verifies that there are <b>at least</b> <i>n</i> elements in the actual AtomicReferenceArray satisfying the given condition.1144 * <p>1145 * Example :1146 * <pre><code class='java'> AtomicReferenceArray<Integer> oneThwoThree = new AtomicReferenceArray<>(new Integer[]{1, 2, 3});1147 *1148 * Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number");1149 *1150 * // assertion will pass1151 * oneThwoThree.areAtLeast(2, oddNumber);1152 *1153 * // assertion will fail1154 * oneThwoThree.areAtLeast(3, oddNumber);</code></pre>1155 *1156 * @param times the minimum number of times the condition should be verified.1157 * @param condition the given condition.1158 * @return {@code this} object.1159 * @throws NullPointerException if the given condition is {@code null}.1160 * @throws AssertionError if an element can not be cast to T.1161 * @throws AssertionError if the number of elements satisfying the given condition is < n.1162 */1163 @Override1164 public AtomicReferenceArrayAssert<T> areAtLeast(int times, Condition<? super T> condition) {1165 arrays.assertAreAtLeast(info, array, times, condition);1166 return myself;1167 }1168 /**1169 * Verifies that there is <b>at least <i>one</i></b> element in the actual AtomicReferenceArray satisfying the given condition.1170 * <p>1171 * This method is an alias for {@code areAtLeast(1, condition)}.1172 * <p>1173 * Example:1174 * <pre><code class='java'> // jedi is a Condition<String>1175 * AtomicReferenceArray<String> rebels = new AtomicReferenceArray<>(new String[]{"Luke", "Solo", "Leia"});1176 * 1177 * assertThat(rebels).areAtLeastOne(jedi);</code></pre>1178 *1179 * @see #haveAtLeast(int, Condition)1180 */1181 @Override1182 public AtomicReferenceArrayAssert<T> areAtLeastOne(Condition<? super T> condition) {1183 areAtLeast(1, condition);1184 return myself;1185 }1186 /**1187 * Verifies that there are <b>at most</b> <i>n</i> elements in the actual AtomicReferenceArray satisfying the given condition.1188 * <p>1189 * Example :1190 * <pre><code class='java'> AtomicReferenceArray<Integer> oneThwoThree = new AtomicReferenceArray<>(new Integer[]{1, 2, 3});1191 *1192 * Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number");1193 *1194 * // assertions will pass1195 * oneThwoThree.areAtMost(2, oddNumber);1196 * oneThwoThree.areAtMost(3, oddNumber);1197 *1198 * // assertion will fail1199 * oneThwoThree.areAtMost(1, oddNumber);</code></pre>1200 *1201 * @param times the number of times the condition should be at most verified.1202 * @param condition the given condition.1203 * @return {@code this} object.1204 * @throws NullPointerException if the given condition is {@code null}.1205 * @throws AssertionError if an element cannot be cast to T.1206 * @throws AssertionError if the number of elements satisfying the given condition is > n.1207 */1208 @Override1209 public AtomicReferenceArrayAssert<T> areAtMost(int times, Condition<? super T> condition) {1210 arrays.assertAreAtMost(info, array, times, condition);1211 return myself;1212 }1213 /**1214 * Verifies that there are <b>exactly</b> <i>n</i> elements in the actual AtomicReferenceArray satisfying the given condition.1215 * <p>1216 * Example :1217 * <pre><code class='java'> AtomicReferenceArray<Integer> oneThwoThree = new AtomicReferenceArray<>(new Integer[]{1, 2, 3});1218 *1219 * Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number");1220 *1221 * // assertion will pass1222 * oneThwoThree.areExactly(2, oddNumber);1223 *1224 * // assertions will fail1225 * oneThwoThree.areExactly(1, oddNumber);1226 * oneThwoThree.areExactly(3, oddNumber);</code></pre>1227 *1228 * @param times the exact number of times the condition should be verified.1229 * @param condition the given condition.1230 * @return {@code this} object.1231 * @throws NullPointerException if the given condition is {@code null}.1232 * @throws AssertionError if an element cannot be cast to T.1233 * @throws AssertionError if the number of elements satisfying the given condition is ≠ n.1234 */1235 @Override1236 public AtomicReferenceArrayAssert<T> areExactly(int times, Condition<? super T> condition) {1237 arrays.assertAreExactly(info, array, times, condition);1238 return myself;1239 }1240 /**1241 * Verifies that there is <b>at least <i>one</i></b> element in the actual AtomicReferenceArray satisfying the given condition.1242 * <p>1243 * This method is an alias for {@code haveAtLeast(1, condition)}.1244 * <p>1245 * Example:1246 * <pre><code class='java'> AtomicReferenceArray<BasketBallPlayer> bullsPlayers = new AtomicReferenceArray<>(new BasketBallPlayer[]{butler, rose});1247 *1248 * // potentialMvp is a Condition<BasketBallPlayer>1249 * assertThat(bullsPlayers).haveAtLeastOne(potentialMvp);</code></pre>1250 *1251 * @see #haveAtLeast(int, Condition)1252 */1253 @Override1254 public AtomicReferenceArrayAssert<T> haveAtLeastOne(Condition<? super T> condition) {1255 return haveAtLeast(1, condition);1256 }1257 /**1258 * Verifies that there are <b>at least <i>n</i></b> elements in the actual AtomicReferenceArray satisfying the given condition.1259 * <p>1260 * Example :1261 * <pre><code class='java'> AtomicReferenceArray<Integer> oneThwoThree = new AtomicReferenceArray<>(new Integer[]{1, 2, 3});1262 *1263 * Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number");1264 *1265 * // assertion will pass1266 * oneThwoThree.haveAtLeast(2, oddNumber);1267 *1268 * // assertion will fail1269 * oneThwoThree.haveAtLeast(3, oddNumber);</code></pre>1270 *1271 * This method is an alias for {@link #areAtLeast(int, Condition)}.1272 */1273 @Override1274 public AtomicReferenceArrayAssert<T> haveAtLeast(int times, Condition<? super T> condition) {1275 arrays.assertHaveAtLeast(info, array, times, condition);1276 return myself;1277 }1278 /**1279 * Verifies that there are <b>at most</b> <i>n</i> elements in the actual AtomicReferenceArray satisfying the given condition.1280 * <p>1281 * Example :1282 * <pre><code class='java'> AtomicReferenceArray<Integer> oneThwoThree = new AtomicReferenceArray<>(new Integer[]{1, 2, 3});1283 *1284 * Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number");1285 *1286 * // assertions will pass1287 * oneThwoThree.haveAtMost(2, oddNumber);1288 * oneThwoThree.haveAtMost(3, oddNumber);1289 *1290 * // assertion will fail1291 * oneThwoThree.haveAtMost(1, oddNumber);</code></pre>1292 *1293 * This method is an alias {@link #areAtMost(int, Condition)}.1294 */1295 @Override1296 public AtomicReferenceArrayAssert<T> haveAtMost(int times, Condition<? super T> condition) {1297 arrays.assertHaveAtMost(info, array, times, condition);1298 return myself;1299 }1300 /**1301 * Verifies that there are <b>exactly</b> <i>n</i> elements in the actual AtomicReferenceArray satisfying the given condition.1302 * <p>1303 * Example :1304 * <pre><code class='java'> AtomicReferenceArray<Integer> oneThwoThree = new AtomicReferenceArray<>(new Integer[]{1, 2, 3});1305 *1306 * Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number");1307 *1308 * // assertion will pass1309 * oneThwoThree.haveExactly(2, oddNumber);1310 *1311 * // assertions will fail1312 * oneThwoThree.haveExactly(1, oddNumber);1313 * oneThwoThree.haveExactly(3, oddNumber);</code></pre>1314 *1315 * This method is an alias {@link #areExactly(int, Condition)}.1316 */1317 @Override1318 public AtomicReferenceArrayAssert<T> haveExactly(int times, Condition<? super T> condition) {1319 arrays.assertHaveExactly(info, array, times, condition);1320 return myself;1321 }1322 /**1323 * Verifies that at least one element in the actual AtomicReferenceArray has the specified type (matching1324 * includes subclasses of the given type).1325 * <p>1326 * Example:1327 * <pre><code class='java'> AtomicReferenceArray<Number> numbers = new AtomicReferenceArray<>(new Number[]{ 2, 6L, 8.0 });1328 * 1329 * // successful assertion:1330 * assertThat(numbers).hasAtLeastOneElementOfType(Long.class);1331 * 1332 * // assertion failure:1333 * assertThat(numbers).hasAtLeastOneElementOfType(Float.class);</code></pre>1334 *1335 * @param expectedType the expected type.1336 * @return this assertion object.1337 * @throws NullPointerException if the given type is {@code null}.1338 * @throws AssertionError if the actual AtomicReferenceArray does not have any elements of the given type.1339 */1340 @Override1341 public AtomicReferenceArrayAssert<T> hasAtLeastOneElementOfType(Class<?> expectedType) {1342 arrays.assertHasAtLeastOneElementOfType(info, array, expectedType);1343 return myself;1344 }1345 /**1346 * Verifies that all the elements in the actual AtomicReferenceArray belong to the specified type (matching includes1347 * subclasses of the given type).1348 * <p>1349 * Example:1350 * <pre><code class='java'> AtomicReferenceArray<Number> numbers = new AtomicReferenceArray<>(new Number[]{ 2, 6, 8 });1351 * 1352 * // successful assertion:1353 * assertThat(numbers).hasOnlyElementsOfType(Integer.class);1354 * 1355 * // assertion failure:1356 * assertThat(numbers).hasOnlyElementsOfType(Long.class);</code></pre>1357 *1358 * @param expectedType the expected type.1359 * @return this assertion object.1360 * @throws NullPointerException if the given type is {@code null}.1361 * @throws AssertionError if one element is not of the expected type.1362 */1363 @Override1364 public AtomicReferenceArrayAssert<T> hasOnlyElementsOfType(Class<?> expectedType) {1365 arrays.assertHasOnlyElementsOfType(info, array, expectedType);1366 return myself;1367 }1368 /**1369 * Verifies that all the elements in the actual AtomicReferenceArray do not belong to the specified types (including subclasses).1370 * <p>1371 * Example:1372 * <pre><code class='java'> AtomicReferenceArray<Number> numbers = new AtomicReferenceArray<>(new Number[]{ 2, 6, 8.0 });1373 *1374 * // successful assertion:1375 * assertThat(numbers).doesNotHaveAnyElementsOfTypes(Long.class, Float.class);1376 *1377 * // assertion failure:1378 * assertThat(numbers).doesNotHaveAnyElementsOfTypes(Long.class, Integer.class);</code></pre>1379 *1380 * @param unexpectedTypes the not expected types.1381 * @return this assertion object.1382 * @throws NullPointerException if the given types is {@code null}.1383 * @throws AssertionError if one element's type matches the given types.1384 * @since 2.9.0 / 3.9.01385 */1386 @Override1387 public AtomicReferenceArrayAssert<T> doesNotHaveAnyElementsOfTypes(Class<?>... unexpectedTypes) {1388 arrays.assertDoesNotHaveAnyElementsOfTypes(info, array, unexpectedTypes);1389 return myself;1390 }1391 /** {@inheritDoc} */1392 @Override1393 public AtomicReferenceArrayAssert<T> isSorted() {1394 arrays.assertIsSorted(info, array);1395 return myself;1396 }1397 /** {@inheritDoc} */1398 @Override1399 public AtomicReferenceArrayAssert<T> isSortedAccordingTo(Comparator<? super T> comparator) {1400 arrays.assertIsSortedAccordingToComparator(info, array, comparator);1401 return myself;1402 }1403 /**1404 * Verifies that the actual AtomicReferenceArray contains all the elements of given {@code Iterable}, in any order.1405 * <p>1406 * Example :1407 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});1408 *1409 * // assertion will pass1410 * assertThat(abc).containsAll(Arrays.asList("b", "c"));1411 * 1412 * // assertions will fail1413 * assertThat(abc).containsAll(Arrays.asList("d"));1414 * assertThat(abc).containsAll(Arrays.asList("a", "b", "c", "d"));</code></pre>1415 *1416 * @param iterable the given {@code Iterable} we will get elements from.1417 * @return {@code this} assertion object.1418 * @throws NullPointerException if the given argument is {@code null}.1419 * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.1420 * @throws AssertionError if the actual AtomicReferenceArray does not contain all the elements of given {@code Iterable}.1421 */1422 @Override1423 public AtomicReferenceArrayAssert<T> containsAll(Iterable<? extends T> iterable) {1424 arrays.assertContainsAll(info, array, iterable);1425 return myself;1426 }1427 /**1428 * Use given custom comparator instead of relying on actual element type <code>equals</code> method to compare AtomicReferenceArray1429 * elements for incoming assertion checks.1430 * <p>1431 * Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default1432 * comparison strategy.1433 * <p>1434 * Examples :1435 * <pre><code class='java'> // compares invoices by payee1436 * assertThat(invoiceArray).usingComparator(invoicePayeeComparator).isEqualTo(expectedinvoiceArray).1437 *1438 * // compares invoices by date, doesNotHaveDuplicates and contains both use the given invoice date comparator1439 * assertThat(invoiceArray).usingComparator(invoiceDateComparator).doesNotHaveDuplicates().contains(may2010Invoice)1440 *1441 * // as assertThat(invoiceArray) creates a new assertion, it falls back to standard comparison strategy1442 * // based on Invoice's equal method to compare invoiceArray elements to lowestInvoice.1443 * assertThat(invoiceArray).contains(lowestInvoice).1444 *1445 * // standard comparison : the fellowshipOfTheRing includes Gandalf but not Sauron (believe me) ...1446 * assertThat(fellowshipOfTheRing).contains(gandalf)1447 * .doesNotContain(sauron);1448 *1449 * // ... but if we compare only races, Sauron is in fellowshipOfTheRing because he's a Maia like Gandalf.1450 * assertThat(fellowshipOfTheRing).usingElementComparator(raceComparator)1451 * .contains(sauron);</code></pre>1452 *1453 * @param elementComparator the comparator to use for incoming assertion checks.1454 * @throws NullPointerException if the given comparator is {@code null}.1455 * @return {@code this} assertion object.1456 */1457 @Override1458 @CheckReturnValue1459 public AtomicReferenceArrayAssert<T> usingElementComparator(Comparator<? super T> elementComparator) {1460 this.arrays = new ObjectArrays(new ComparatorBasedComparisonStrategy(elementComparator));1461 objects = new Objects(new AtomicReferenceArrayElementComparisonStrategy<>(elementComparator));1462 return myself;1463 }1464 private AtomicReferenceArrayAssert<T> usingExtendedByTypesElementComparator(Comparator<Object> elementComparator) {1465 return usingElementComparator(new ExtendedByTypesComparator(elementComparator, comparatorsByType));1466 }1467 /** {@inheritDoc} */1468 @Override1469 @CheckReturnValue1470 public AtomicReferenceArrayAssert<T> usingDefaultElementComparator() {1471 this.arrays = ObjectArrays.instance();1472 return myself;1473 }1474 /**1475 * Allows to set a comparator to compare properties or fields of elements with the given names.1476 * A typical usage is for comparing fields of numeric type at a given precision.1477 * <p>1478 * To be used, comparators need to be specified by this method <b>before</b> calling any of:1479 * <ul>1480 * <li>{@link #usingFieldByFieldElementComparator}</li>1481 * <li>{@link #usingElementComparatorOnFields}</li>1482 * <li>{@link #usingElementComparatorIgnoringFields}</li>1483 * <li>{@link #usingRecursiveFieldByFieldElementComparator}</li>1484 * </ul>1485 * <p>1486 * Comparators specified by this method have precedence over comparators specified by1487 * {@link #usingComparatorForElementFieldsWithType(Comparator, Class) usingComparatorForElementFieldsWithType}.1488 * <p>1489 * Example:1490 * <p>1491 * <pre><code class='java'> public class TolkienCharacter {1492 * private String name;1493 * private double height;1494 * // constructor omitted1495 * }1496 *1497 * TolkienCharacter frodo = new TolkienCharacter("Frodo", 1.2);1498 * TolkienCharacter tallerFrodo = new TolkienCharacter("Frodo", 1.3);1499 * TolkienCharacter reallyTallFrodo = new TolkienCharacter("Frodo", 1.9);1500 *1501 * Comparator<Double> closeEnough = new Comparator<Double>() {1502 * double precision = 0.5;1503 * public int compare(Double d1, Double d2) {1504 * return Math.abs(d1 - d2) <= precision ? 0 : 1;1505 * }1506 * };1507 *1508 * AtomicReferenceArray<TolkienCharacter> hobbits = new AtomicReferenceArray<>(new TolkienCharacter[]{frodo});1509 *1510 * // assertions will pass1511 * assertThat(hobbits).usingComparatorForElementFieldsWithNames(closeEnough, "height")1512 * .usingFieldByFieldElementComparator()1513 * .contains(tallerFrodo);1514 *1515 * assertThat(hobbits).usingComparatorForElementFieldsWithNames(closeEnough, "height")1516 * .usingElementComparatorOnFields("height")1517 * .contains(tallerFrodo);1518 *1519 * assertThat(hobbits).usingComparatorForElementFieldsWithNames(closeEnough, "height")1520 * .usingElementComparatorIgnoringFields("name")1521 * .contains(tallerFrodo);1522 *1523 * assertThat(hobbits).usingComparatorForElementFieldsWithNames(closeEnough, "height")1524 * .usingRecursiveFieldByFieldElementComparator()1525 * .contains(tallerFrodo);1526 *1527 * // assertion will fail1528 * assertThat(hobbits).usingComparatorForElementFieldsWithNames(closeEnough, "height")1529 * .usingFieldByFieldElementComparator()1530 * .containsExactly(reallyTallFrodo);</code></pre>1531 *1532 * @param comparator the {@link java.util.Comparator} to use1533 * @param elementPropertyOrFieldNames the names of the properties and/or fields of the elements the comparator should be used for1534 * @return {@code this} assertions object1535 * @since 2.7.0 / 3.7.01536 */1537 @CheckReturnValue1538 public <C> AtomicReferenceArrayAssert<T> usingComparatorForElementFieldsWithNames(Comparator<C> comparator,1539 String... elementPropertyOrFieldNames) {1540 for (String elementPropertyOrField : elementPropertyOrFieldNames) {1541 comparatorsForElementPropertyOrFieldNames.put(elementPropertyOrField, comparator);1542 }1543 return myself;1544 }1545 /**1546 * Allows to set a specific comparator to compare properties or fields of elements with the given type.1547 * A typical usage is for comparing fields of numeric type at a given precision.1548 * <p>1549 * To be used, comparators need to be specified by this method <b>before</b> calling any of:1550 * <ul>1551 * <li>{@link #usingFieldByFieldElementComparator}</li>1552 * <li>{@link #usingElementComparatorOnFields}</li>1553 * <li>{@link #usingElementComparatorIgnoringFields}</li>1554 * <li>{@link #usingRecursiveFieldByFieldElementComparator}</li>1555 * </ul>1556 * <p>1557 * Comparators specified by {@link #usingComparatorForElementFieldsWithNames(Comparator, String...) usingComparatorForElementFieldsWithNames}1558 * have precedence over comparators specified by this method.1559 * <p>1560 * Example:1561 * <pre><code class='java'> public class TolkienCharacter {1562 * private String name;1563 * private double height;1564 * // constructor omitted1565 * }1566 * TolkienCharacter frodo = new TolkienCharacter("Frodo", 1.2);1567 * TolkienCharacter tallerFrodo = new TolkienCharacter("Frodo", 1.3);1568 * TolkienCharacter reallyTallFrodo = new TolkienCharacter("Frodo", 1.9);1569 *1570 * Comparator<Double> closeEnough = new Comparator<Double>() {1571 * double precision = 0.5;1572 * public int compare(Double d1, Double d2) {1573 * return Math.abs(d1 - d2) <= precision ? 0 : 1;1574 * }1575 * };1576 *1577 * AtomicReferenceArray<TolkienCharacter> hobbits = new AtomicReferenceArray<>(new TolkienCharacter[]{frodo});1578 *1579 * // assertions will pass1580 * assertThat(hobbits).usingComparatorForElementFieldsWithType(closeEnough, Double.class)1581 * .usingFieldByFieldElementComparator()1582 * .contains(tallerFrodo);1583 *1584 * assertThat(hobbits).usingComparatorForElementFieldsWithType(closeEnough, Double.class)1585 * .usingElementComparatorOnFields("height")1586 * .contains(tallerFrodo);1587 *1588 * assertThat(hobbits).usingComparatorForElementFieldsWithType(closeEnough, Double.class)1589 * .usingElementComparatorIgnoringFields("name")1590 * .contains(tallerFrodo);1591 *1592 * assertThat(hobbits).usingComparatorForElementFieldsWithType(closeEnough, Double.class)1593 * .usingRecursiveFieldByFieldElementComparator()1594 * .contains(tallerFrodo);1595 *1596 * // assertion will fail1597 * assertThat(hobbits).usingComparatorForElementFieldsWithType(closeEnough, Double.class)1598 * .usingFieldByFieldElementComparator()1599 * .contains(reallyTallFrodo);</code></pre>1600 *1601 * If multiple compatible comparators have been registered for a given {@code type}, the closest in the inheritance 1602 * chain to the given {@code type} is chosen in the following order:1603 * <ol>1604 * <li>The comparator for the exact given {@code type}</li>1605 * <li>The comparator of a superclass of the given {@code type}</li>1606 * <li>The comparator of an interface implemented by the given {@code type}</li>1607 * </ol>1608 *1609 * @param comparator the {@link java.util.Comparator} to use1610 * @param type the {@link java.lang.Class} of the type of the element fields the comparator should be used for1611 * @return {@code this} assertions object1612 * @since 2.7.0 / 3.7.01613 */1614 @CheckReturnValue1615 public <C> AtomicReferenceArrayAssert<T> usingComparatorForElementFieldsWithType(Comparator<C> comparator, Class<C> type) {1616 comparatorsForElementPropertyOrFieldTypes.put(type, comparator);1617 return myself;1618 }1619 /**1620 * Allows to set a specific comparator for the given type of elements or their fields.1621 * Extends {@link #usingComparatorForElementFieldsWithType} by applying comparator specified for given type1622 * to elements themselves, not only to their fields.1623 * <p>1624 * Usage of this method affects comparators set by next methods:1625 * <ul>1626 * <li>{@link #usingFieldByFieldElementComparator}</li>1627 * <li>{@link #usingElementComparatorOnFields}</li>1628 * <li>{@link #usingElementComparatorIgnoringFields}</li>1629 * <li>{@link #usingRecursiveFieldByFieldElementComparator}</li>1630 * </ul>1631 * <p>1632 * Example:1633 * <pre><code class='java'> // assertion will pass1634 * assertThat(new AtomicReferenceArray<>(new Object[] { "some", new BigDecimal("4.2") }))1635 * .usingComparatorForType(BIG_DECIMAL_COMPARATOR, BigDecimal.class)1636 * .contains(new BigDecimal("4.20"));1637 * </code></pre>1638 * </p>1639 *1640 * @param comparator the {@link java.util.Comparator} to use1641 * @param type the {@link java.lang.Class} of the type of the element or element fields the comparator should be used for1642 * @return {@code this} assertions object1643 * @since 2.9.0 / 3.9.01644 */1645 @CheckReturnValue1646 public <C> AtomicReferenceArrayAssert<T> usingComparatorForType(Comparator<C> comparator, Class<C> type) {1647 if (arrays.getComparator() == null) {1648 usingElementComparator(new ExtendedByTypesComparator(comparatorsByType));1649 }1650 comparatorsForElementPropertyOrFieldTypes.put(type, comparator);1651 comparatorsByType.put(type, comparator);1652 return myself;1653 }1654 /**1655 * Use field/property by field/property comparison (including inherited fields/properties) instead of relying on1656 * actual type A <code>equals</code> method to compare AtomicReferenceArray elements for incoming assertion checks. Private fields1657 * are included but this can be disabled using {@link Assertions#setAllowExtractingPrivateFields(boolean)}.1658 * <p>1659 * This can be handy if <code>equals</code> method of the objects to compare does not suit you.1660 * <p>1661 * You can specify a custom comparator per name or type of element field with1662 * {@link #usingComparatorForElementFieldsWithNames(Comparator, String...)}1663 * and {@link #usingComparatorForElementFieldsWithType(Comparator, Class)}.1664 * <p>1665 * Note that the comparison is <b>not</b> recursive, if one of the fields/properties is an Object, it will be compared1666 * to the other field/property using its <code>equals</code> method.1667 * </p>1668 * Example:1669 * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);1670 * TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);1671 *1672 * // Fail if equals has not been overridden in TolkienCharacter as equals default implementation only compares references1673 * assertThat(atomicArray(frodo)).contains(frodoClone);1674 *1675 * // frodo and frodoClone are equals when doing a field by field comparison.1676 * assertThat(atomicArray(frodo)).usingFieldByFieldElementComparator().contains(frodoClone);</code></pre>1677 *1678 * @return {@code this} assertion object.1679 * @since 2.7.0 / 3.7.01680 */1681 @CheckReturnValue1682 public AtomicReferenceArrayAssert<T> usingFieldByFieldElementComparator() {1683 return usingExtendedByTypesElementComparator(new FieldByFieldComparator(comparatorsForElementPropertyOrFieldNames,1684 comparatorsForElementPropertyOrFieldTypes));1685 }1686 /**1687 * Use a recursive field/property by field/property comparison (including inherited fields/properties)1688 * instead of relying on actual type A <code>equals</code> method to compare AtomicReferenceArray elements for incoming1689 * assertion checks. This can be useful if actual's {@code equals} implementation does not suit you.1690 * <p>1691 * The recursive property/field comparison is <b>not</b> applied on fields having a custom {@code equals}1692 * implementation, i.e. the overridden {@code equals} method will be used instead of a field/property by field/property comparison.1693 * <p>1694 * You can specify a custom comparator per (nested) name or type of element field with1695 * {@link #usingComparatorForElementFieldsWithNames(Comparator, String...) usingComparatorForElementFieldsWithNames}1696 * and {@link #usingComparatorForElementFieldsWithType(Comparator, Class) usingComparatorForElementFieldsWithType}.1697 * <p>1698 * The recursive comparison handles cycles.1699 * <p>1700 * The objects to compare can be of different types but must have the same properties/fields. For example if actual object has a1701 * {@code name} String field, the other object must also have one.1702 * <p>1703 * If an object has a field and a property with the same name, the property value will be used over the field.1704 * <p>1705 * Example:1706 *1707 * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);1708 * TolkienCharacter pippin = new TolkienCharacter("Pippin", 28, HOBBIT);1709 * frodo.setFriend(pippin);1710 * pippin.setFriend(frodo);1711 *1712 * TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);1713 * TolkienCharacter pippinClone = new TolkienCharacter("Pippin", 28, HOBBIT);1714 * frodoClone.setFriend(pippinClone);1715 * pippinClone.setFriend(frodoClone);1716 *1717 * AtomicReferenceArray<TolkienCharacter> hobbits = new AtomicReferenceArray<>(new TolkienCharacter[] {frodo, pippin});1718 *1719 * // fails if equals has not been overridden in TolkienCharacter as it would compares object references1720 * assertThat(hobbits).contains(frodoClone, pippinClone);1721 *1722 * // frodo/frodoClone and pippin/pippinClone are equals when doing a recursive property/field by property/field comparison1723 * assertThat(hobbits).usingRecursiveFieldByFieldElementComparator()1724 * .contains(frodoClone, pippinClone);</code></pre>1725 *1726 * @return {@code this} assertion object.1727 * @since 2.7.0 / 3.7.01728 */1729 @CheckReturnValue1730 public AtomicReferenceArrayAssert<T> usingRecursiveFieldByFieldElementComparator() {1731 return usingExtendedByTypesElementComparator(new RecursiveFieldByFieldComparator(comparatorsForElementPropertyOrFieldNames,1732 comparatorsForElementPropertyOrFieldTypes));1733 }1734 /**1735 * Use field/property by field/property comparison on the <b>given fields/properties only</b> (including inherited1736 * fields/properties) instead of relying on actual type A <code>equals</code> method to compare AtomicReferenceArray elements for1737 * incoming assertion checks. Private fields are included but this can be disabled using1738 * {@link Assertions#setAllowExtractingPrivateFields(boolean)}.1739 * <p>1740 * This can be handy if <code>equals</code> method of the objects to compare does not suit you.1741 * <p>1742 * You can specify a custom comparator per name or type of element field with1743 * {@link #usingComparatorForElementFieldsWithNames(Comparator, String...)}1744 * and {@link #usingComparatorForElementFieldsWithType(Comparator, Class)}.1745 * <p>1746 * Note that the comparison is <b>not</b> recursive, if one of the fields/properties is an Object, it will be compared1747 * to the other field/property using its <code>equals</code> method.1748 * </p>1749 * Example:1750 * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);1751 * TolkienCharacter sam = new TolkienCharacter("Sam", 38, HOBBIT);1752 *1753 * // frodo and sam both are hobbits, so they are equals when comparing only race1754 * assertThat(atomicArray(frodo)).usingElementComparatorOnFields("race").contains(sam); // OK1755 *1756 * // ... but not when comparing both name and race1757 * assertThat(atomicArray(frodo)).usingElementComparatorOnFields("name", "race").contains(sam); // FAIL</code></pre>1758 *1759 * @return {@code this} assertion object.1760 * @since 2.7.0 / 3.7.01761 */1762 @CheckReturnValue1763 public AtomicReferenceArrayAssert<T> usingElementComparatorOnFields(String... fields) {1764 return usingExtendedByTypesElementComparator(new OnFieldsComparator(comparatorsForElementPropertyOrFieldNames,1765 comparatorsForElementPropertyOrFieldTypes, fields));1766 }1767 /**1768 * Use field/property by field/property on all fields/properties <b>except</b> the given ones (including inherited1769 * fields/properties) instead of relying on actual type A <code>equals</code> method to compare AtomicReferenceArray elements for1770 * incoming assertion checks. Private fields are included but this can be disabled using1771 * {@link Assertions#setAllowExtractingPrivateFields(boolean)}.1772 * <p>1773 * This can be handy if <code>equals</code> method of the objects to compare does not suit you.1774 * <p>1775 * You can specify a custom comparator per name or type of element field with1776 * {@link #usingComparatorForElementFieldsWithNames(Comparator, String...)}1777 * and {@link #usingComparatorForElementFieldsWithType(Comparator, Class)}.1778 * <p>1779 * Note that the comparison is <b>not</b> recursive, if one of the fields/properties is an Object, it will be compared1780 * to the other field/property using its <code>equals</code> method.1781 * </p>1782 * Example:1783 * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);1784 * TolkienCharacter sam = new TolkienCharacter("Sam", 38, HOBBIT);1785 *1786 * // frodo and sam both are hobbits, so they are equals when comparing only race (i.e. ignoring all other fields)1787 * assertThat(atomicArray(frodo)).usingElementComparatorIgnoringFields("name", "age").contains(sam); // OK1788 *1789 * // ... but not when comparing both name and race1790 * assertThat(atomicArray(frodo)).usingElementComparatorIgnoringFields("age").contains(sam); // FAIL</code></pre>1791 *1792 * @param fields the names of the fields/properties to ignore1793 * @return {@code this} assertion object.1794 * @since 2.7.0 / 3.7.01795 */1796 @CheckReturnValue1797 public AtomicReferenceArrayAssert<T> usingElementComparatorIgnoringFields(String... fields) {1798 return usingExtendedByTypesElementComparator(new IgnoringFieldsComparator(comparatorsForElementPropertyOrFieldNames,1799 comparatorsForElementPropertyOrFieldTypes, fields));1800 }1801 /**1802 * Extract the values of given field or property from the array's elements under test into a new array, this new array1803 * becoming the array under test.1804 * <p>1805 * It allows you to test a field/property of the array's elements instead of testing the elements themselves, which can1806 * be much less work !1807 * <p>1808 * Let's take an example to make things clearer :1809 * <pre><code class='java'> // Build a array of TolkienCharacter, a TolkienCharacter has a name (String) and a Race (a class)1810 * // they can be public field or properties, both works when extracting their values.1811 * AtomicReferenceArray<TolkienCharacter> fellowshipOfTheRing = new AtomicReferenceArray<>(new TolkienCharacter[]{1812 * new TolkienCharacter("Frodo", 33, HOBBIT),1813 * new TolkienCharacter("Sam", 38, HOBBIT),1814 * new TolkienCharacter("Gandalf", 2020, MAIA),1815 * new TolkienCharacter("Legolas", 1000, ELF),1816 * new TolkienCharacter("Pippin", 28, HOBBIT),1817 * new TolkienCharacter("Gimli", 139, DWARF),1818 * new TolkienCharacter("Aragorn", 87, MAN,1819 * new TolkienCharacter("Boromir", 37, MAN)1820 * };1821 *1822 * // let's verify the names of TolkienCharacter in fellowshipOfTheRing :1823 *1824 * assertThat(fellowshipOfTheRing).extracting("name")1825 * .contains("Boromir", "Gandalf", "Frodo")1826 * .doesNotContain("Sauron", "Elrond");1827 *1828 * // you can also extract nested field/property like the name of Race :1829 *1830 * assertThat(fellowshipOfTheRing).extracting("race.name")1831 * .contains("Hobbit", "Elf")1832 * .doesNotContain("Orc");</code></pre>1833 *1834 * A property with the given name is looked for first, if it does not exist then a field with the given name1835 * is looked for.1836 * <p>1837 * Note that the order of extracted field/property values is consistent with the array order.1838 *1839 * @param fieldOrProperty the field/property to extract from the array under test1840 * @return a new assertion object whose object under test is the array of extracted field/property values.1841 * @throws IntrospectionError if no field or property exists with the given name1842 * @since 2.7.0 / 3.7.01843 */1844 @CheckReturnValue1845 public ObjectArrayAssert<Object> extracting(String fieldOrProperty) {1846 Object[] values = FieldsOrPropertiesExtractor.extract(array, byName(fieldOrProperty));1847 String extractedDescription = extractedDescriptionOf(fieldOrProperty);1848 String description = mostRelevantDescription(info.description(), extractedDescription);1849 return new ObjectArrayAssert<>(values).as(description);1850 }1851 /**1852 * Extract the values of given field or property from the array's elements under test into a new array, this new array1853 * becoming the array under test with type.1854 * <p>1855 * It allows you to test a field/property of the array's elements instead of testing the elements themselves, which can1856 * be much less work !1857 * <p>1858 * Let's take an example to make things clearer :1859 * <pre><code class='java'> // Build an array of TolkienCharacter, a TolkienCharacter has a name (String) and a Race (a class)1860 * // they can be public field or properties, both works when extracting their values.1861 * AtomicReferenceArray<TolkienCharacter> fellowshipOfTheRing = new AtomicReferenceArray<>(new TolkienCharacter[]{1862 * new TolkienCharacter("Frodo", 33, HOBBIT),1863 * new TolkienCharacter("Sam", 38, HOBBIT),1864 * new TolkienCharacter("Gandalf", 2020, MAIA),1865 * new TolkienCharacter("Legolas", 1000, ELF),1866 * new TolkienCharacter("Pippin", 28, HOBBIT),1867 * new TolkienCharacter("Gimli", 139, DWARF),1868 * new TolkienCharacter("Aragorn", 87, MAN,1869 * new TolkienCharacter("Boromir", 37, MAN)1870 * };1871 *1872 * // let's verify the names of TolkienCharacter in fellowshipOfTheRing :1873 *1874 * assertThat(fellowshipOfTheRing).extracting("name", String.class)1875 * .contains("Boromir", "Gandalf", "Frodo")1876 * .doesNotContain("Sauron", "Elrond");1877 *1878 * // you can also extract nested field/property like the name of Race :1879 *1880 * assertThat(fellowshipOfTheRing).extracting("race.name", String.class)1881 * .contains("Hobbit", "Elf")1882 * .doesNotContain("Orc");</code></pre>1883 *1884 * A property with the given name is looked for first, if it does not exist then a field with the given name1885 * is looked for.1886 * <p>1887 * Note that the order of extracted field/property values is consistent with the order of the array under test.1888 *1889 * @param fieldOrProperty the field/property to extract from the array under test1890 * @param extractingType type to return1891 * @return a new assertion object whose object under test is the array of extracted field/property values.1892 * @throws IntrospectionError if no field or property exists with the given name1893 * @since 2.7.0 / 3.7.01894 */1895 @CheckReturnValue1896 public <P> ObjectArrayAssert<P> extracting(String fieldOrProperty, Class<P> extractingType) {1897 @SuppressWarnings("unchecked")1898 P[] values = (P[]) FieldsOrPropertiesExtractor.extract(array, byName(fieldOrProperty));1899 String extractedDescription = extractedDescriptionOf(fieldOrProperty);1900 String description = mostRelevantDescription(info.description(), extractedDescription);1901 return new ObjectArrayAssert<>(values).as(description);1902 }1903 /**1904 * Extract the values of given fields/properties from the array's elements under test into a new array composed of1905 * Tuple (a simple data structure), this new array becoming the array under test.1906 * <p>1907 * It allows you to test fields/properties of the the array's elements instead of testing the elements themselves, it1908 * can be sometimes much less work !1909 * <p>1910 * The Tuple data corresponds to the extracted values of the given fields/properties, for instance if you ask to1911 * extract "id", "name" and "email" then each Tuple data will be composed of id, name and email extracted from the1912 * element of the initial array (the Tuple's data order is the same as the given fields/properties order).1913 * <p>1914 * Let's take an example to make things clearer :1915 * <pre><code class='java'> // Build an array of TolkienCharacter, a TolkienCharacter has a name (String) and a Race (a class)1916 * // they can be public field or properties, both works when extracting their values.1917 * AtomicReferenceArray<TolkienCharacter> fellowshipOfTheRing = new AtomicReferenceArray<>(new TolkienCharacter[]{1918 * new TolkienCharacter("Frodo", 33, HOBBIT),1919 * new TolkienCharacter("Sam", 38, HOBBIT),1920 * new TolkienCharacter("Gandalf", 2020, MAIA),1921 * new TolkienCharacter("Legolas", 1000, ELF),1922 * new TolkienCharacter("Pippin", 28, HOBBIT),1923 * new TolkienCharacter("Gimli", 139, DWARF),1924 * new TolkienCharacter("Aragorn", 87, MAN,1925 * new TolkienCharacter("Boromir", 37, MAN)1926 * };1927 *1928 * // let's verify 'name' and 'age' of some TolkienCharacter in fellowshipOfTheRing :1929 *1930 * assertThat(fellowshipOfTheRing).extracting("name", "age")1931 * .contains(tuple("Boromir", 37),1932 * tuple("Sam", 38),1933 * tuple("Legolas", 1000));1934 *1935 *1936 * // extract 'name', 'age' and Race name values.1937 *1938 * assertThat(fellowshipOfTheRing).extracting("name", "age", "race.name")1939 * .contains(tuple("Boromir", 37, "Man"),1940 * tuple("Sam", 38, "Hobbit"),1941 * tuple("Legolas", 1000, "Elf"));</code></pre>1942 *1943 * A property with the given name is looked for first, if it does not exist the a field with the given name is1944 * looked for.1945 * <p>1946 * Note that the order of extracted property/field values is consistent with the iteration order of the array under1947 * test.1948 *1949 * @param propertiesOrFields the properties/fields to extract from the initial array under test1950 * @return a new assertion object whose object under test is the list of Tuple with extracted properties/fields values1951 * as data.1952 * @throws IntrospectionError if one of the given name does not match a field or property in one of the initial1953 * Iterable's element.1954 */1955 @CheckReturnValue1956 public ObjectArrayAssert<Tuple> extracting(String... propertiesOrFields) {1957 Object[] values = FieldsOrPropertiesExtractor.extract(array, byName(propertiesOrFields));1958 Tuple[] result = Arrays.copyOf(values, values.length, Tuple[].class);1959 String extractedDescription = extractedDescriptionOf(propertiesOrFields);1960 String description = mostRelevantDescription(info.description(), extractedDescription);1961 return new ObjectArrayAssert<>(result).as(description);1962 }1963 /**1964 * Extract the values from the array's elements by applying an extracting function on them. The returned1965 * array becomes a new object under test.1966 * <p>1967 * It allows to test values from the elements in safer way than by using {@link #extracting(String)}, as it1968 * doesn't utilize introspection.1969 * <p>1970 * Let's take a look an example:1971 * <pre><code class='java'> // Build a list of TolkienCharacter, a TolkienCharacter has a name, and age and a Race (a specific class)1972 * // they can be public field or properties, both can be extracted.1973 * AtomicReferenceArray<TolkienCharacter> fellowshipOfTheRing = new AtomicReferenceArray<>(new TolkienCharacter[]{1974 * new TolkienCharacter("Frodo", 33, HOBBIT),1975 * new TolkienCharacter("Sam", 38, HOBBIT),1976 * new TolkienCharacter("Gandalf", 2020, MAIA),1977 * new TolkienCharacter("Legolas", 1000, ELF),1978 * new TolkienCharacter("Pippin", 28, HOBBIT),1979 * new TolkienCharacter("Gimli", 139, DWARF),1980 * new TolkienCharacter("Aragorn", 87, MAN,1981 * new TolkienCharacter("Boromir", 37, MAN)1982 * };1983 *1984 *1985 * // this extracts the race1986 * Extractor<TolkienCharacter, Race> race = new Extractor<TolkienCharacter, Race>() {1987 * {@literal @}Override1988 * public Race extract(TolkienCharacter input) {1989 * return input.getRace();1990 * }1991 * }1992 *1993 * // fellowship has hobbits, right, my presioussss?1994 * assertThat(fellowshipOfTheRing).extracting(race).contains(HOBBIT);</code></pre>1995 *1996 * Note that the order of extracted property/field values is consistent with the iteration order of the Iterable under1997 * test, for example if it's a {@link HashSet}, you won't be able to make any assumptions on the extracted values1998 * order.1999 *2000 * @param extractor the object transforming input object to desired one2001 * @return a new assertion object whose object under test is the list of values extracted2002 * @since 2.7.0 / 3.7.02003 */2004 @CheckReturnValue2005 public <U> ObjectArrayAssert<U> extracting(Extractor<? super T, U> extractor) {2006 U[] extracted = FieldsOrPropertiesExtractor.extract(array, extractor);2007 return new ObjectArrayAssert<>(extracted);2008 }2009 /**2010 * Extract the Iterable values from the array's elements by applying an Iterable extracting function on them2011 * and concatenating the result lists into an array which becomes the new object under test.2012 * <p>2013 * It allows testing the results of extracting values that are represented by Iterables.2014 * <p>2015 * For example:2016 * <pre><code class='java'> CartoonCharacter bart = new CartoonCharacter("Bart Simpson");2017 * CartoonCharacter lisa = new CartoonCharacter("Lisa Simpson");2018 * CartoonCharacter maggie = new CartoonCharacter("Maggie Simpson");2019 * CartoonCharacter homer = new CartoonCharacter("Homer Simpson");2020 * homer.addChildren(bart, lisa, maggie);2021 *2022 * CartoonCharacter pebbles = new CartoonCharacter("Pebbles Flintstone");2023 * CartoonCharacter fred = new CartoonCharacter("Fred Flintstone");2024 * fred.getChildren().add(pebbles);2025 *2026 * Extractor<CartoonCharacter, List<CartoonCharacter>> childrenOf = new Extractor<CartoonCharacter, List<CartoonCharacter>>() {2027 * {@literal @}Override2028 * public List<CartoonChildren> extract(CartoonCharacter input) {2029 * return input.getChildren();2030 * }2031 * }2032 *2033 * AtomicReferenceArray<CartoonCharacter> parents = new AtomicReferenceArray<>(new CartoonCharacter[]{ homer, fred });2034 * // check children2035 * assertThat(parents).flatExtracting(childrenOf)2036 * .containsOnly(bart, lisa, maggie, pebbles);</code></pre>2037 *2038 * The order of extracted values is consisted with both the order of the collection itself, as well as the extracted2039 * collections.2040 *2041 * @param extractor the object transforming input object to an Iterable of desired ones2042 * @return a new assertion object whose object under test is the list of values extracted2043 * @since 2.7.0 / 3.7.02044 */2045 @CheckReturnValue2046 public <U, C extends Collection<U>> ObjectArrayAssert<U> flatExtracting(Extractor<? super T, C> extractor) {2047 final List<C> extractedValues = FieldsOrPropertiesExtractor.extract(Arrays.asList(array), extractor);2048 final List<U> result = newArrayList();2049 for (C e : extractedValues) {2050 result.addAll(e);2051 }2052 return new ObjectArrayAssert<>(IterableUtil.toArray(result));2053 }2054 /**2055 * Extract from array's elements the Iterable/Array values corresponding to the given property/field name and2056 * concatenate them into a single array becoming the new object under test.2057 * <p>2058 * It allows testing the elements of extracting values that are represented by iterables or arrays.2059 * <p>2060 * For example:2061 * <pre><code class='java'> CartoonCharacter bart = new CartoonCharacter("Bart Simpson");2062 * CartoonCharacter lisa = new CartoonCharacter("Lisa Simpson");2063 * CartoonCharacter maggie = new CartoonCharacter("Maggie Simpson");2064 * CartoonCharacter homer = new CartoonCharacter("Homer Simpson");2065 * homer.addChildren(bart, lisa, maggie);2066 *2067 * CartoonCharacter pebbles = new CartoonCharacter("Pebbles Flintstone");2068 * CartoonCharacter fred = new CartoonCharacter("Fred Flintstone");2069 * fred.getChildren().add(pebbles);2070 *2071 * AtomicReferenceArray<CartoonCharacter> parents = new AtomicReferenceArray<>(new CartoonCharacter[]{ homer, fred });2072 * // check children2073 * assertThat(parents).flatExtracting("children")2074 * .containsOnly(bart, lisa, maggie, pebbles);</code></pre>2075 *2076 * The order of extracted values is consisted with both the order of the collection itself, as well as the extracted2077 * collections.2078 *2079 * @param propertyName the object transforming input object to an Iterable of desired ones2080 * @return a new assertion object whose object under test is the list of values extracted2081 * @throws IllegalArgumentException if one of the extracted property value was not an array or an iterable.2082 * @since 2.7.0 / 3.7.02083 */2084 @CheckReturnValue2085 public ObjectArrayAssert<Object> flatExtracting(String propertyName) {2086 List<Object> extractedValues = newArrayList();2087 List<?> extractedGroups = FieldsOrPropertiesExtractor.extract(Arrays.asList(array), byName(propertyName));2088 for (Object group : extractedGroups) {2089 // expecting AtomicReferenceArray to be an iterable or an array2090 if (isArray(group)) {2091 int size = Array.getLength(group);2092 for (int i = 0; i < size; i++) {2093 extractedValues.add(Array.get(group, i));2094 }2095 } else if (group instanceof Iterable) {2096 Iterable<?> iterable = (Iterable<?>) group;2097 for (Object value : iterable) {2098 extractedValues.add(value);2099 }2100 } else {2101 CommonErrors.wrongElementTypeForFlatExtracting(group);2102 }2103 }2104 return new ObjectArrayAssert<>(extractedValues.toArray());2105 }2106 /**2107 * Extract the result of given method invocation from the array's elements under test into a new array, this new array2108 * becoming the array under test.2109 * <p>2110 * It allows you to test a method results of the array's elements instead of testing the elements themselves, which can be2111 * much less work!2112 * <p>2113 * It is especially useful for classes that does not conform to the Java Bean's getter specification (i.e. public String2114 * toString() or public String status() instead of public String getStatus()).2115 * <p>2116 * Let's take an example to make things clearer :2117 * <pre><code class='java'> // Build a array of WesterosHouse, a WesterosHouse has a method: public String sayTheWords()2118 * AtomicReferenceArray<WesterosHouse> greatHousesOfWesteros = new AtomicReferenceArray<>(new WesterosHouse[]{ 2119 * new WesterosHouse("Stark", "Winter is Coming"),2120 * new WesterosHouse("Lannister", "Hear Me Roar!"), 2121 * new WesterosHouse("Greyjoy", "We Do Not Sow"),2122 * new WesterosHouse("Baratheon", "Our is the Fury"), 2123 * new WesterosHouse("Martell", "Unbowed, Unbent, Unbroken"),2124 * new WesterosHouse("Tyrell", "Growing Strong") });2125 *2126 * // let's verify the words of the great houses of Westeros:2127 * assertThat(greatHousesOfWesteros).extractingResultOf("sayTheWords")2128 * .contains("Winter is Coming", "We Do Not Sow", "Hear Me Roar")2129 * .doesNotContain("Lannisters always pay their debts");</code></pre>2130 *2131 * <p>2132 * Following requirements have to be met to extract method results:2133 * <ul>2134 * <li>method has to be public,</li>2135 * <li>method cannot accept any arguments,</li>2136 * <li>method cannot return void.</li>2137 * </ul>2138 * <p>2139 * Note that the order of extracted values is consistent with the order of the array under test.2140 *2141 * @param method the name of the method which result is to be extracted from the array under test2142 * @return a new assertion object whose object under test is the array of extracted values.2143 * @throws IllegalArgumentException if no method exists with the given name, or method is not public, or method does2144 * return void, or method accepts arguments.2145 * @since 2.7.0 / 3.7.02146 */2147 @CheckReturnValue2148 public ObjectArrayAssert<Object> extractingResultOf(String method) {2149 Object[] values = FieldsOrPropertiesExtractor.extract(array, resultOf(method));2150 String extractedDescription = extractedDescriptionOfMethod(method);2151 String description = mostRelevantDescription(info.description(), extractedDescription);2152 return new ObjectArrayAssert<>(values).as(description);2153 }2154 /**2155 * Extract the result of given method invocation from the array's elements under test into a new array, this new array2156 * becoming the array under test.2157 * <p>2158 * It allows you to test a method results of the array's elements instead of testing the elements themselves, which can be2159 * much less work!2160 * <p>2161 * It is especially useful for classes that do not conform to the Java Bean's getter specification (i.e. public String2162 * toString() or public String status() instead of public String getStatus()).2163 * <p>2164 * Let's take an example to make things clearer :2165 * <pre><code class='java'> // Build a array of WesterosHouse, a WesterosHouse has a method: public String sayTheWords()2166 * AtomicReferenceArray<WesterosHouse> greatHousesOfWesteros = new AtomicReferenceArray<>(new WesterosHouse[]{ 2167 * new WesterosHouse("Stark", "Winter is Coming"),2168 * new WesterosHouse("Lannister", "Hear Me Roar!"), 2169 * new WesterosHouse("Greyjoy", "We Do Not Sow"),2170 * new WesterosHouse("Baratheon", "Our is the Fury"), 2171 * new WesterosHouse("Martell", "Unbowed, Unbent, Unbroken"),2172 * new WesterosHouse("Tyrell", "Growing Strong") });2173 *2174 * // let's verify the words of the great houses of Westeros:2175 * assertThat(greatHousesOfWesteros).extractingResultOf("sayTheWords", String.class)2176 * .contains("Winter is Coming", "We Do Not Sow", "Hear Me Roar")2177 * .doesNotContain("Lannisters always pay their debts");</code></pre>2178 *2179 * <p>2180 * Following requirements have to be met to extract method results:2181 * <ul>2182 * <li>method has to be public,</li>2183 * <li>method can not accept any arguments,</li>2184 * <li>method can not return void.</li>2185 * </ul>2186 * <p>2187 * Note that the order of extracted values is consistent with the order of the array under test.2188 *2189 * @param method the name of the method which result is to be extracted from the array under test2190 * @param extractingType type to return2191 * @return a new assertion object whose object under test is the array of extracted values.2192 * @throws IllegalArgumentException if no method exists with the given name, or method is not public, or method does2193 * return void, or method accepts arguments.2194 * @since 2.7.0 / 3.7.02195 */2196 @CheckReturnValue2197 public <P> ObjectArrayAssert<P> extractingResultOf(String method, Class<P> extractingType) {2198 @SuppressWarnings("unchecked")2199 P[] values = (P[]) FieldsOrPropertiesExtractor.extract(array, resultOf(method));2200 String extractedDescription = extractedDescriptionOfMethod(method);2201 String description = mostRelevantDescription(info.description(), extractedDescription);2202 return new ObjectArrayAssert<>(values).as(description);2203 }2204 /**2205 * Enable hexadecimal object representation of Iterable elements instead of standard java representation in error2206 * messages.2207 * <p>2208 * It can be useful to better understand what the error was with a more meaningful error message.2209 * <p>2210 * Example2211 * <pre><code class='java'> 2212 * AtomicReferenceArray<Byte> bytes = new AtomicReferenceArray<>(new Byte[]{ 0x10, 0x20 });2213 * assertThat(bytes).inHexadecimal().contains(new Byte[] { 0x30 });</code></pre>2214 *2215 * With standard error message:2216 * <pre><code class='java'> Expecting:2217 * <[16, 32]>2218 * to contain:2219 * <[48]>2220 * but could not find:2221 * <[48]></code></pre>2222 *2223 * With Hexadecimal error message:2224 * <pre><code class='java'> Expecting:2225 * <[0x10, 0x20]>2226 * to contain:2227 * <[0x30]>2228 * but could not find:2229 * <[0x30]></code></pre>2230 *2231 * @return {@code this} assertion object.2232 * @since 2.7.0 / 3.7.02233 */2234 @Override2235 @CheckReturnValue2236 public AtomicReferenceArrayAssert<T> inHexadecimal() {2237 return super.inHexadecimal();2238 }2239 @Override2240 @CheckReturnValue2241 public AtomicReferenceArrayAssert<T> inBinary() {2242 return super.inBinary();2243 }2244 /**2245 * Filter the array under test keeping only elements having a property or field equal to {@code expectedValue}, the2246 * property/field is specified by {@code propertyOrFieldName} parameter.2247 * <p>2248 * The filter first tries to get the value from a property (named {@code propertyOrFieldName}), if no such property2249 * exists it tries to read the value from a field. Reading private fields is supported by default, this can be2250 * globally disabled by calling {@link Assertions#setAllowExtractingPrivateFields(boolean)2251 * Assertions.setAllowExtractingPrivateFields(false)}.2252 * <p>2253 * When reading <b>nested</b> property/field, if an intermediate value is null the whole nested property/field is2254 * considered to be null, thus reading "address.street.name" value will return null if "street" value is null.2255 * <p>2256 *2257 * As an example, let's check all employees 800 years old (yes, special employees):2258 * <pre><code class='java'> Employee yoda = new Employee(1L, new Name("Yoda"), 800);2259 * Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);2260 * Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26);2261 * Employee noname = new Employee(4L, null, 50);2262 *2263 * AtomicReferenceArray<Employee> employees = new AtomicReferenceArray<>(new Employee[]{ yoda, luke, obiwan, noname });2264 *2265 * assertThat(employees).filteredOn("age", 800)2266 * .containsOnly(yoda, obiwan);</code></pre>2267 *2268 * Nested properties/fields are supported:2269 * <pre><code class='java'> // Name is bean class with 'first' and 'last' String properties2270 *2271 * // name is null for noname => it does not match the filter on "name.first"2272 * assertThat(employees).filteredOn("name.first", "Luke")2273 * .containsOnly(luke);2274 *2275 * assertThat(employees).filteredOn("name.last", "Vader")2276 * .isEmpty();</code></pre>2277 * <p>2278 * If you want to filter on null value, use {@link #filteredOnNull(String)} as Java will resolve the call to2279 * {@link #filteredOn(String, FilterOperator)} instead of this method.2280 * <p>2281 * An {@link IntrospectionError} is thrown if the given propertyOrFieldName can't be found in one of the array2282 * elements.2283 * <p>2284 * You can chain filters:2285 * <pre><code class='java'> // fellowshipOfTheRing is an array of TolkienCharacter having race and name fields2286 * // 'not' filter is statically imported from Assertions.not2287 *2288 * assertThat(fellowshipOfTheRing).filteredOn("race.name", "Man")2289 * .filteredOn("name", not("Boromir"))2290 * .containsOnly(aragorn);</code></pre>2291 * If you need more complex filter, use {@link #filteredOn(Condition)} and provide a {@link Condition} to specify the2292 * filter to apply.2293 *2294 * @param propertyOrFieldName the name of the property or field to read2295 * @param expectedValue the value to compare element's property or field with2296 * @return a new assertion object with the filtered array under test2297 * @throws IllegalArgumentException if the given propertyOrFieldName is {@code null} or empty.2298 * @throws IntrospectionError if the given propertyOrFieldName can't be found in one of the array elements.2299 * @since 2.7.0 / 3.7.02300 */2301 @CheckReturnValue2302 public AtomicReferenceArrayAssert<T> filteredOn(String propertyOrFieldName, Object expectedValue) {2303 Iterable<? extends T> filteredIterable = filter(array).with(propertyOrFieldName, expectedValue).get();2304 return new AtomicReferenceArrayAssert<>(new AtomicReferenceArray<>(toArray(filteredIterable)));2305 }2306 /**2307 * Filter the array under test keeping only elements whose property or field specified by {@code propertyOrFieldName}2308 * is null.2309 * <p>2310 * exists it tries to read the value from a field. Reading private fields is supported by default, this can be2311 * globally disabled by calling {@link Assertions#setAllowExtractingPrivateFields(boolean)2312 * Assertions.setAllowExtractingPrivateFields(false)}.2313 * <p>2314 * When reading <b>nested</b> property/field, if an intermediate value is null the whole nested property/field is2315 * considered to be null, thus reading "address.street.name" value will return null if "street" value is null.2316 * <p>2317 * As an example, let's check all employees 800 years old (yes, special employees):2318 * <pre><code class='java'> Employee yoda = new Employee(1L, new Name("Yoda"), 800);2319 * Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);2320 * Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26);2321 * Employee noname = new Employee(4L, null, 50);2322 *2323 * AtomicReferenceArray<Employee> employees = new AtomicReferenceArray<>(new Employee[]{ yoda, luke, obiwan, noname });2324 *2325 * assertThat(employees).filteredOnNull("name")2326 * .containsOnly(noname);</code></pre>2327 *2328 * Nested properties/fields are supported:2329 * <pre><code class='java'> // Name is bean class with 'first' and 'last' String properties2330 *2331 * assertThat(employees).filteredOnNull("name.last")2332 * .containsOnly(yoda, obiwan, noname);</code></pre>2333 *2334 * An {@link IntrospectionError} is thrown if the given propertyOrFieldName can't be found in one of the array2335 * elements.2336 * <p>2337 * If you need more complex filter, use {@link #filteredOn(Condition)} and provide a {@link Condition} to specify the2338 * filter to apply.2339 *2340 * @param propertyOrFieldName the name of the property or field to read2341 * @return a new assertion object with the filtered array under test2342 * @throws IntrospectionError if the given propertyOrFieldName can't be found in one of the array elements.2343 * @since 2.7.0 / 3.7.02344 */2345 @CheckReturnValue2346 public AtomicReferenceArrayAssert<T> filteredOnNull(String propertyOrFieldName) {2347 // need to cast nulll to Object otherwise it calls :2348 // filteredOn(String propertyOrFieldName, FilterOperation<?> filterOperation)2349 return filteredOn(propertyOrFieldName, (Object) null);2350 }2351 /**2352 * Filter the array under test keeping only elements having a property or field matching the filter expressed with2353 * the {@link FilterOperator}, the property/field is specified by {@code propertyOrFieldName} parameter.2354 * <p>2355 * The existing filters are :2356 * <ul>2357 * <li> {@link Assertions#not(Object) not(Object)}</li>2358 * <li> {@link Assertions#in(Object...) in(Object...)}</li>2359 * <li> {@link Assertions#notIn(Object...) notIn(Object...)}</li>2360 * </ul>2361 * <p>2362 * Whatever filter is applied, it first tries to get the value from a property (named {@code propertyOrFieldName}), if2363 * no such property exists it tries to read the value from a field. Reading private fields is supported by default,2364 * this can be globally disabled by calling {@link Assertions#setAllowExtractingPrivateFields(boolean)2365 * Assertions.setAllowExtractingPrivateFields(false)}.2366 * <p>2367 * When reading <b>nested</b> property/field, if an intermediate value is null the whole nested property/field is2368 * considered to be null, thus reading "address.street.name" value will return null if "street" value is null.2369 * <p>2370 *2371 * As an example, let's check stuff on some special employees :2372 * <pre><code class='java'> Employee yoda = new Employee(1L, new Name("Yoda"), 800);2373 * Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);2374 * Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26);2375 *2376 * AtomicReferenceArray<Employee> employees = new AtomicReferenceArray<>(new Employee[]{ yoda, luke, obiwan, noname });2377 *2378 * // 'not' filter is statically imported from Assertions.not2379 * assertThat(employees).filteredOn("age", not(800))2380 * .containsOnly(luke);2381 *2382 * // 'in' filter is statically imported from Assertions.in2383 * // Name is bean class with 'first' and 'last' String properties2384 * assertThat(employees).filteredOn("name.first", in("Yoda", "Luke"))2385 * .containsOnly(yoda, luke);2386 *2387 * // 'notIn' filter is statically imported from Assertions.notIn2388 * assertThat(employees).filteredOn("name.first", notIn("Yoda", "Luke"))2389 * .containsOnly(obiwan);</code></pre>2390 *2391 * An {@link IntrospectionError} is thrown if the given propertyOrFieldName can't be found in one of the array2392 * elements.2393 * <p>2394 * Note that combining filter operators is not supported, thus the following code is not correct:2395 * <pre><code class='java'> // Combining filter operators like not(in(800)) is NOT supported2396 * // -> throws UnsupportedOperationException2397 * assertThat(employees).filteredOn("age", not(in(800)))2398 * .contains(luke);</code></pre>2399 * <p>2400 * You can chain filters:2401 * <pre><code class='java'> // fellowshipOfTheRing is an array of TolkienCharacter having race and name fields2402 * // 'not' filter is statically imported from Assertions.not2403 *2404 * assertThat(fellowshipOfTheRing).filteredOn("race.name", "Man")2405 * .filteredOn("name", not("Boromir"))2406 * .containsOnly(aragorn);</code></pre>2407 *2408 * If you need more complex filter, use {@link #filteredOn(Condition)} and provide a {@link Condition} to specify the2409 * filter to apply.2410 *2411 * @param propertyOrFieldName the name of the property or field to read2412 * @param filterOperator the filter operator to apply2413 * @return a new assertion object with the filtered array under test2414 * @throws IllegalArgumentException if the given propertyOrFieldName is {@code null} or empty.2415 * @since 2.7.0 / 3.7.02416 */2417 @CheckReturnValue2418 public AtomicReferenceArrayAssert<T> filteredOn(String propertyOrFieldName, FilterOperator<?> filterOperator) {2419 checkNotNull(filterOperator);2420 Filters<? extends T> filter = filter(array).with(propertyOrFieldName);2421 filterOperator.applyOn(filter);2422 return new AtomicReferenceArrayAssert<>(new AtomicReferenceArray<>(toArray(filter.get())));2423 }2424 /**2425 * Filter the array under test keeping only elements matching the given {@link Condition}.2426 * <p>2427 * Let's check old employees whose age > 100:2428 * <pre><code class='java'> Employee yoda = new Employee(1L, new Name("Yoda"), 800);2429 * Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);2430 * Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26);2431 * Employee noname = new Employee(4L, null, 50);2432 *2433 * AtomicReferenceArray<Employee> employees = new AtomicReferenceArray<>(new Employee[]{ yoda, luke, obiwan, noname });2434 *2435 * // old employee condition, "old employees" describes the condition in error message2436 * // you just have to implement 'matches' method2437 * Condition<Employee> oldEmployees = new Condition<Employee>("old employees") {2438 * {@literal @}Override2439 * public boolean matches(Employee employee) {2440 * return employee.getAge() > 100;2441 * }2442 * };2443 * }2444 * assertThat(employees).filteredOn(oldEmployees)2445 * .containsOnly(yoda, obiwan);</code></pre>2446 *2447 * You can combine {@link Condition} with condition operator like {@link Not}:2448 * <pre><code class='java'> // 'not' filter is statically imported from Assertions.not2449 * assertThat(employees).filteredOn(not(oldEmployees))2450 * .contains(luke, noname);</code></pre>2451 *2452 * @param condition the filter condition / predicate2453 * @return a new assertion object with the filtered array under test2454 * @throws IllegalArgumentException if the given condition is {@code null}.2455 * @since 2.7.0 / 3.7.02456 */2457 @CheckReturnValue2458 public AtomicReferenceArrayAssert<T> filteredOn(Condition<? super T> condition) {2459 Iterable<? extends T> filteredIterable = filter(array).being(condition).get();2460 return new AtomicReferenceArrayAssert<>(new AtomicReferenceArray<>(toArray(filteredIterable)));2461 }2462 /**2463 * Verifies that the actual AtomicReferenceArray contains at least one of the given values.2464 * <p>2465 * Example :2466 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"}); 2467 *2468 * // assertions will pass2469 * assertThat(abc).containsAnyOf("b")2470 * .containsAnyOf("b", "c")2471 * .containsAnyOf("a", "b", "c")2472 * .containsAnyOf("a", "b", "c", "d")2473 * .containsAnyOf("e", "f", "g", "b");2474 *2475 * // assertions will fail2476 * assertThat(abc).containsAnyOf("d");2477 * assertThat(abc).containsAnyOf("d", "e", "f", "g");</code></pre>2478 *2479 * @param values the values whose at least one which is expected to be in the {@code AtomicReferenceArray} under test.2480 * @return {@code this} assertion object.2481 * @throws NullPointerException if the array of values is {@code null}.2482 * @throws IllegalArgumentException if the array of values is empty and the {@code AtomicReferenceArray} under test is not empty.2483 * @throws AssertionError if the {@code AtomicReferenceArray} under test is {@code null}.2484 * @throws AssertionError if the {@code AtomicReferenceArray} under test does not contain any of the given {@code values}.2485 * @since 2.9.0 / 3.9.02486 */2487 @Override2488 public AtomicReferenceArrayAssert<T> containsAnyOf(@SuppressWarnings("unchecked") T... values) {2489 arrays.assertContainsAnyOf(info, array, values);2490 return myself;2491 }2492 /**2493 * Verifies that the actual AtomicReferenceArray contains at least one of the given {@link Iterable} elements.2494 * <p>2495 * Example :2496 * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"}); 2497 *2498 * // assertions will pass2499 * assertThat(abc).containsAnyElementsOf(Arrays.asList("b"))2500 * .containsAnyElementsOf(Arrays.asList("b", "c"))2501 * .containsAnyElementsOf(Arrays.asList("a", "b", "c"))2502 * .containsAnyElementsOf(Arrays.asList("a", "b", "c", "d"))2503 * .containsAnyElementsOf(Arrays.asList("e", "f", "g", "b"));2504 *2505 * // assertions will fail2506 * assertThat(abc).containsAnyElementsOf(Arrays.asList("d"));2507 * assertThat(abc).containsAnyElementsOf(Arrays.asList("d", "e", "f", "g"));</code></pre>2508 *2509 * @param iterable the iterable whose at least one element is expected to be in the {@code AtomicReferenceArray} under test.2510 * @return {@code this} assertion object.2511 * @throws NullPointerException if the iterable of expected values is {@code null}.2512 * @throws IllegalArgumentException if the iterable of expected values is empty and the {@code AtomicReferenceArray} under test is not empty.2513 * @throws AssertionError if the {@code AtomicReferenceArray} under test is {@code null}.2514 * @throws AssertionError if the {@code AtomicReferenceArray} under test does not contain any of elements from the given {@code Iterable}.2515 * @since 2.9.0 / 3.9.02516 */2517 @Override2518 public AtomicReferenceArrayAssert<T> containsAnyElementsOf(Iterable<T> iterable) {2519 return containsAnyOf(toArray(iterable));2520 }2521}...
AtomicReferenceArrayAssert
Using AI Code Generation
1import org.assertj.core.api.AtomicReferenceArrayAssert;2import java.util.concurrent.atomic.AtomicReferenceArray;3public class AtomicReferenceArrayAssertDemo {4 public static void main(String[] args) {5 AtomicReferenceArray<String> array = new AtomicReferenceArray<>(new String[]{"one", "two", "three"});6 AtomicReferenceArrayAssert<String> atomicReferenceArrayAssert = new AtomicReferenceArrayAssert<>(array);7 System.out.println("AtomicReferenceArrayAssertDemo");8 atomicReferenceArrayAssert.containsExactly("one", "two", "three");9 }10}11AtomicIntegerAssert hasValueSatisfying()12AtomicIntegerAssert hasValueMatching()13AtomicIntegerAssert hasValueGreaterThan()14AtomicIntegerAssert hasValueLessThan()15AtomicIntegerAssert hasValueGreaterThanOrEqualTo()16AtomicIntegerAssert hasValueLessThanOrEqualTo()17AtomicIntegerAssert hasValueBetween()18AtomicIntegerAssert hasValueNotBetween()19AtomicIntegerAssert hasValueNotEqualTo()20AtomicIntegerAssert hasValueEqualTo()21AtomicIntegerAssert hasValueNotIn()22AtomicIntegerAssert hasValueIn()23AtomicIntegerAssert hasValueNotZero()24AtomicIntegerAssert hasValueZero()25AtomicIntegerAssert hasValueNotNegative()26AtomicIntegerAssert hasValueNegative()27AtomicIntegerAssert hasValuePositive()28AtomicIntegerAssert hasValueNotPositive()29AtomicIntegerAssert hasValueNotNegative()30AtomicIntegerAssert hasValueNotPositive()31AtomicIntegerAssert hasValueNegative()32AtomicIntegerAssert hasValuePositive()33AtomicIntegerAssert hasValueNotNegative()34AtomicIntegerAssert hasValueNotPositive()35AtomicIntegerAssert hasValueNegative()
AtomicReferenceArrayAssert
Using AI Code Generation
1package org.example;2import java.util.concurrent.atomic.AtomicReferenceArray;3import org.assertj.core.api.Assertions;4import org.assertj.core.api.AtomicReferenceArrayAssert;5{6 public static void main( String[] args )7 {8 AtomicReferenceArray<Integer> arr = new AtomicReferenceArray<Integer>(5);9 arr.set(0, 10);10 arr.set(1, 20);11 arr.set(2, 30);12 arr.set(3, 40);13 arr.set(4, 50);14 AtomicReferenceArrayAssert<Integer> assertRef = Assertions.assertThat(arr);15 assertRef.containsExactly(10, 20, 30, 40, 50);16 }17}18package org.example;19import java.util.concurrent.atomic.AtomicReferenceArray;20import org.assertj.core.api.Assertions;21import org.assertj.core.api.AtomicReferenceArrayAssert;22{23 public static void main( String[] args )24 {25 AtomicReferenceArray<Integer> arr = new AtomicReferenceArray<Integer>(5);26 arr.set(0, 10);27 arr.set(1, 20);28 arr.set(2, 30);29 arr.set(3, 40);30 arr.set(4, 50);31 AtomicReferenceArrayAssert<Integer> assertRef = Assertions.assertThat(arr);32 assertRef.containsExactly(10, 20, 30, 40, 50, 60);33 }34}35package org.example;36import java.util.concurrent.atomic.AtomicReferenceArray;37import org.assertj.core.api.Assertions;38import org.assertj.core.api.AtomicReferenceArrayAssert;39{40 public static void main( String[] args )41 {42 AtomicReferenceArray<Integer> arr = new AtomicReferenceArray<Integer>(5);43 arr.set(0, 10);44 arr.set(1, 20);45 arr.set(2, 30);46 arr.set(3, 40);47 arr.set(4, 50);
AtomicReferenceArrayAssert
Using AI Code Generation
1import org.assertj.core.api.AtomicReferenceArrayAssert;2import org.assertj.core.api.Assertions;3import java.util.concurrent.atomic.AtomicReferenceArray;4public class AssertJAtomicReferenceArrayAssert {5 public static void main(String[] args) {6 AtomicReferenceArray<String> array = new AtomicReferenceArray<>(new String[] {"a", "b", "c"});7 AtomicReferenceArrayAssert<String> assertArray = Assertions.assertThat(array);8 assertArray.containsExactly("a", "b", "c");9 }10}
AtomicReferenceArrayAssert
Using AI Code Generation
1package org.assertj.core.api;2import java.util.concurrent.atomic.AtomicReferenceArray;3public class AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> extends AbstractAssert<AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT>, ATOMIC_REFERENCE_ARRAY> {4 public AtomicReferenceArrayAssert(ATOMIC_REFERENCE_ARRAY actual) {5 super(actual, AtomicReferenceArrayAssert.class);6 }7 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactly(ELEMENT... elements) {8 return this;9 }10 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrder(ELEMENT... elements) {11 return this;12 }13 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrderElementsOf(Iterable<? extends ELEMENT> iterable) {14 return this;15 }16 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrderElementsOf(AtomicReferenceArray<? extends ELEMENT> other) {17 return this;18 }19 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrderElementsOf(ELEMENT[] elements) {20 return this;21 }22 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrderElementsOf(ELEMENT[] elements, ComparisonStrategy comparisonStrategy) {23 return this;24 }25 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrderElementsOf(Iterable<? extends ELEMENT> iterable, ComparisonStrategy comparisonStrategy) {26 return this;27 }28 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrderElementsOf(AtomicReferenceArray<? extends ELEMENT> other, ComparisonStrategy comparisonStrategy) {29 return this;30 }31 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrderNullsAndEmpty() {32 return this;33 }34 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrderNullsAndEmpty(ComparisonStrategy comparisonStrategy) {35 return this;36 }37 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrderNullsAndEmpty(AtomicReferenceArray<? extends ELEMENT> other) {38 return this;39 }40 public AtomicReferenceArrayAssert<ATOMIC_REFERENCE_ARRAY, ELEMENT> containsExactlyInAnyOrderNullsAndEmpty(AtomicReferenceArray
AtomicReferenceArrayAssert
Using AI Code Generation
1import org.assertj.core.api.AtomicReferenceArrayAssert;2import java.util.concurrent.atomic.AtomicReferenceArray;3public class AssertJAtomicReferenceArrayAssert {4 public static void main(String[] args) {5 AtomicReferenceArray<String> atomicReferenceArray = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});6 AtomicReferenceArrayAssert<String> atomicReferenceArrayAssert = new AtomicReferenceArrayAssert<>(atomicReferenceArray);7 atomicReferenceArrayAssert.contains("a");8 atomicReferenceArrayAssert.containsExactly("a", "b", "c");9 atomicReferenceArrayAssert.containsExactlyInAnyOrder("c", "b", "a");10 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray);11 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.toArray());12 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2));13 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2).toArray());14 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2).toArray(new String[0]));15 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2).toArray(new String[1]));16 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2).toArray(new String[2]));17 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2).toArray(new String[3]));18 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2).toArray(new String[4]));19 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2).toArray(new String[5]));20 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2).toArray(new String[6]));21 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2).toArray(new String[7]));22 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(atomicReferenceArray.subList(0, 2).toArray(new String[8]));23 atomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf(
AtomicReferenceArrayAssert
Using AI Code Generation
1import org.assertj.core.api.AtomicReferenceArrayAssert;2import java.util.concurrent.atomic.AtomicReferenceArray;3public class AtomicReferenceArrayAssertExample {4 public static void main(String[] args) {5 AtomicReferenceArray<String> array = new AtomicReferenceArray<String>(5);6 array.set(0, "A");7 array.set(1, "B");8 array.set(2, "C");9 array.set(3, "D");10 array.set(4, "E");11 AtomicReferenceArrayAssert<String> arrayAssert = new AtomicReferenceArrayAssert<String>(array);12 arrayAssert.isNotEmpty();13 arrayAssert.isEmpty();14 arrayAssert.isSorted();15 arrayAssert.isSortedAccordingTo((s1, s2) -> s1.compareTo(s2));16 arrayAssert.containsSequence("B", "C");17 arrayAssert.containsSubsequence("C", "D");18 arrayAssert.containsExactly("A", "B", "C", "D", "E");19 arrayAssert.containsExactlyInAnyOrder("E", "D", "C", "B", "A");20 arrayAssert.containsExactlyInAnyOrder("E", "D", "C", "B", "A");21 arrayAssert.containsExactlyInAnyOrder("E", "D", "C", "B", "A");22 arrayAssert.containsExactlyInAnyOrder("E", "D", "C", "B", "A");23 arrayAssert.containsExactlyInAnyOrder("
AtomicReferenceArrayAssert
Using AI Code Generation
1import org.assertj.core.api.AtomicReferenceArrayAssert;2import org.assertj.core.api.Assertions;3import java.util.concurrent.atomic.AtomicReferenceArray;4public class AtomicReferenceArrayAssert {5 public static void main(String[] args) {6 AtomicReferenceArray<String> atomicReferenceArray = new AtomicReferenceArray<>(new String[] {"JAVA", "J2EE", "J2SE", "JSP", "JDBC"});7 AtomicReferenceArrayAssert<String> assertAtomicReferenceArray = Assertions.assertThat(atomicReferenceArray);8 assertAtomicReferenceArray.contains("J2EE", "JDBC");9 }10}
AtomicReferenceArrayAssert
Using AI Code Generation
1import org.assertj.core.api.AtomicReferenceArrayAssert;2public class AtomicReferenceArrayAssertExample {3 public static void main(String[] args) {4 AtomicReferenceArray<String> atomicReferenceArray = new AtomicReferenceArray<>(10);5 atomicReferenceArray.set(0, "a");6 atomicReferenceArray.set(1, "b");7 atomicReferenceArray.set(2, "c");8 atomicReferenceArray.set(3, "d");9 atomicReferenceArray.set(4, "e");10 AtomicReferenceArrayAssert<String> arrayAssert = new AtomicReferenceArrayAssert<>(atomicReferenceArray);11 arrayAssert.isEqualTo(new AtomicReferenceArray<>(new String[]{"a", "b", "c", "d", "e"}));12 arrayAssert.isNotEqualTo(new AtomicReferenceArray<>(new String[]{"a", "b", "c", "d", "f"}));13 arrayAssert.isEmpty();14 arrayAssert.isNotEmpty();15 arrayAssert.isSorted();16 arrayAssert.isSortedAccordingTo(Comparator.comparing(String::length));17 arrayAssert.isSortedAccordingTo(Comparator.comparing(String::length), "length");18 arrayAssert.isSortedAccordingTo(Comparator.comparing(String::length), String::length);19 arrayAssert.isSortedAccordingTo(Comparator.comparing(String::length), String::length, "length");20 arrayAssert.isSortedAccordingTo(Comparator.comparing(String::length), String::length, "length", "%s length");
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.
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Get 100 minutes of automation test minutes FREE!!