class AbstractLongAdderAssert<SELF extends AbstractLongAdderAssert<SELF>> extends AbstractAssert<SELF, LongAdder>
    implements NumberAssert<SELF, Long>, ComparableAssert<SELF, Long> {

  @VisibleForTesting
  Longs longs = Longs.instance();

  protected AbstractLongAdderAssert(LongAdder longAdder, Class<?> selfType) {
    super(longAdder, selfType);
  }

  /**
   * Verifies that the actual sum has the given value.
   * <p>
   * Example:
   * <pre><code class='java'> // assertion will pass
   * LongAdder actual = new LongAdder();
   * actual.add(42);
   * assertThat(actual).hasValue(42);
   *
   * // assertion will fail
   * assertThat(actual).hasValue(0);</code></pre>
   *
   * @param expected the expected value.
   * @return {@code this} assertion object.
   * @throws AssertionError if the actual adder is {@code null}.
   */
  public SELF hasValue(long expected) {
    isNotNull();
    long actualValue = actual.sum();
    if (!objects.getComparisonStrategy().areEqual(actualValue, expected)) {
      throwAssertionError(shouldHaveValue(actual, expected));
    }
    return myself;
  }

  /**
   * Verifies that the actual sum has not the given value.
   * <p>
   * Example:
   * <pre><code class='java'> // assertion will pass
   * LongAdder actual = new LongAdder();
   * actual.add(42);
   * assertThat(actual).doesNotHaveValue(0);
   *
   * // assertion will fail
   * assertThat(actual).doesNotHaveValue(42);</code></pre>
   *
   * @param unexpected the unexpected value.
   * @return {@code this} assertion object.
   * @throws AssertionError if the actual adder is {@code null}.
   * @throws AssertionError if the actual sum is not the given value.
   */
  public SELF doesNotHaveValue(long unexpected) {<FILL_FUNCTION_BODY>}

  @Override
  @CheckReturnValue
  public SELF usingComparator(Comparator<? super LongAdder> customComparator) {
    return usingComparator(customComparator, null);
  }

  @Override
  @CheckReturnValue
  public SELF usingComparator(Comparator<? super LongAdder> customComparator, String customComparatorDescription) {
    longs = new Longs(new ComparatorBasedComparisonStrategy(customComparator, customComparatorDescription));
    return super.usingComparator(customComparator, customComparatorDescription);
  }

  @Override
  @CheckReturnValue
  public SELF usingDefaultComparator() {
    longs = Longs.instance();
    return super.usingDefaultComparator();
  }

  @Override
  public SELF isZero() {
    longs.assertIsZero(info, actual.longValue());
    return myself;
  }

  @Override
  public SELF isNotZero() {
    longs.assertIsNotZero(info, actual.longValue());
    return myself;
  }

  @Override
  public SELF isOne() {
    longs.assertIsOne(info, actual.longValue());
    return myself;
  }

  @Override
  public SELF isPositive() {
    longs.assertIsPositive(info, actual.longValue());
    return myself;
  }

  @Override
  public SELF isNegative() {
    longs.assertIsNegative(info, actual.longValue());
    return myself;
  }

  @Override
  public SELF isNotNegative() {
    longs.assertIsNotNegative(info, actual.longValue());
    return myself;
  }

  @Override
  public SELF isNotPositive() {
    longs.assertIsNotPositive(info, actual.longValue());
    return myself;
  }

  @Override
  public SELF isEqualByComparingTo(Long other) {
    longs.assertEqualByComparison(info, actual.longValue(), other);
    return myself;
  }

  @Override
  public SELF isNotEqualByComparingTo(Long other) {
    longs.assertNotEqualByComparison(info, actual.longValue(), other);
    return myself;
  }

  @Override
  public SELF isLessThan(Long other) {
    longs.assertLessThan(info, actual.longValue(), other);
    return myself;
  }

  @Override
  public SELF isLessThanOrEqualTo(Long other) {
    longs.assertLessThanOrEqualTo(info, actual.longValue(), other);
    return myself;
  }

  @Override
  public SELF isGreaterThan(Long other) {
    longs.assertGreaterThan(info, actual.longValue(), other);
    return myself;
  }

  @Override
  public SELF isGreaterThanOrEqualTo(Long other) {
    longs.assertGreaterThanOrEqualTo(info, actual.longValue(), other);
    return myself;
  }

  @Override
  public SELF isBetween(Long start, Long end) {
    longs.assertIsBetween(info, actual.longValue(), start, end);
    return myself;
  }

  @Override
  public SELF isStrictlyBetween(Long start, Long end) {
    longs.assertIsStrictlyBetween(info, actual.longValue(), start, end);
    return myself;
  }

  @Override
  public SELF isCloseTo(Long expected, Offset<Long> offset) {
    longs.assertIsCloseTo(info, actual.longValue(), expected, offset);
    return myself;
  }

  @Override
  public SELF isNotCloseTo(Long expected, Offset<Long> offset) {
    longs.assertIsNotCloseTo(info, actual.longValue(), expected, offset);
    return myself;
  }

  @Override
  public SELF isCloseTo(Long expected, Percentage percentage) {
    longs.assertIsCloseToPercentage(info, actual.longValue(), expected, percentage);
    return myself;
  }

  @Override
  public SELF isNotCloseTo(Long expected, Percentage percentage) {
    longs.assertIsNotCloseToPercentage(info, actual.longValue(), expected, percentage);
    return myself;
  }

}

    isNotNull();
    long actualValue = actual.sum();
    if (objects.getComparisonStrategy().areEqual(actualValue, unexpected)) {
      throwAssertionError(shouldNotContainValue(actual, unexpected));
    }
    return myself;
  
<methods>public ASSERT asInstanceOf(InstanceOfAssertFactory<?,ASSERT>) ,public AbstractListAssert<?,List<?>,java.lang.Object,ObjectAssert<java.lang.Object>> asList() ,public AbstractStringAssert<?> asString() ,public SELF describedAs(org.assertj.core.description.Description) ,public java.lang.String descriptionText() ,public SELF doesNotHave(Condition<? super java.util.concurrent.atomic.LongAdder>) ,public SELF doesNotHaveSameClassAs(java.lang.Object) ,public SELF doesNotHaveSameHashCodeAs(java.lang.Object) ,public SELF doesNotHaveToString(java.lang.String) ,public transient SELF doesNotHaveToString(java.lang.String, java.lang.Object[]) ,public boolean equals(java.lang.Object) ,public org.assertj.core.api.WritableAssertionInfo getWritableAssertionInfo() ,public SELF has(Condition<? super java.util.concurrent.atomic.LongAdder>) ,public SELF hasSameClassAs(java.lang.Object) ,public SELF hasSameHashCodeAs(java.lang.Object) ,public SELF hasToString(java.lang.String) ,public transient SELF hasToString(java.lang.String, java.lang.Object[]) ,public int hashCode() ,public SELF is(Condition<? super java.util.concurrent.atomic.LongAdder>) ,public SELF isEqualTo(java.lang.Object) ,public SELF isExactlyInstanceOf(Class<?>) ,public transient SELF isIn(java.lang.Object[]) ,public SELF isIn(Iterable<?>) ,public SELF isInstanceOf(Class<?>) ,public transient SELF isInstanceOfAny(Class<?>[]) ,public SELF isInstanceOfSatisfying(Class<T>, Consumer<T>) ,public SELF isNot(Condition<? super java.util.concurrent.atomic.LongAdder>) ,public SELF isNotEqualTo(java.lang.Object) ,public SELF isNotExactlyInstanceOf(Class<?>) ,public transient SELF isNotIn(java.lang.Object[]) ,public SELF isNotIn(Iterable<?>) ,public SELF isNotInstanceOf(Class<?>) ,public transient SELF isNotInstanceOfAny(Class<?>[]) ,public SELF isNotNull() ,public transient SELF isNotOfAnyClassIn(Class<?>[]) ,public SELF isNotSameAs(java.lang.Object) ,public void isNull() ,public transient SELF isOfAnyClassIn(Class<?>[]) ,public SELF isSameAs(java.lang.Object) ,public SELF matches(Predicate<? super java.util.concurrent.atomic.LongAdder>) ,public SELF matches(Predicate<? super java.util.concurrent.atomic.LongAdder>, java.lang.String) ,public transient SELF overridingErrorMessage(java.lang.String, java.lang.Object[]) ,public SELF overridingErrorMessage(Supplier<java.lang.String>) ,public SELF satisfies(Condition<? super java.util.concurrent.atomic.LongAdder>) ,public final transient SELF satisfies(Consumer<? super java.util.concurrent.atomic.LongAdder>[]) ,public final transient SELF satisfies(ThrowingConsumer<? super java.util.concurrent.atomic.LongAdder>[]) ,public final transient SELF satisfiesAnyOf(Consumer<? super java.util.concurrent.atomic.LongAdder>[]) ,public final transient SELF satisfiesAnyOf(ThrowingConsumer<? super java.util.concurrent.atomic.LongAdder>[]) ,public static void setCustomRepresentation(org.assertj.core.presentation.Representation) ,public static void setDescriptionConsumer(Consumer<org.assertj.core.description.Description>) ,public static void setPrintAssertionsDescription(boolean) ,public SELF usingComparator(Comparator<? super java.util.concurrent.atomic.LongAdder>) ,public SELF usingComparator(Comparator<? super java.util.concurrent.atomic.LongAdder>, java.lang.String) ,public SELF usingDefaultComparator() ,public transient SELF withFailMessage(java.lang.String, java.lang.Object[]) ,public SELF withFailMessage(Supplier<java.lang.String>) ,public SELF withRepresentation(org.assertj.core.presentation.Representation) ,public SELF withThreadDumpOnError() <variables>private static final java.lang.String ORG_ASSERTJ,protected final non-sealed java.util.concurrent.atomic.LongAdder actual,org.assertj.core.error.AssertionErrorCreator assertionErrorCreator,org.assertj.core.internal.Conditions conditions,static org.assertj.core.presentation.Representation customRepresentation,private static Consumer<org.assertj.core.description.Description> descriptionConsumer,public org.assertj.core.api.WritableAssertionInfo info,protected final non-sealed SELF myself,protected org.assertj.core.internal.Objects objects,static boolean printAssertionsDescription,public static boolean throwUnsupportedExceptionOnEquals