} catch (AssertionFailedError expected) {
      assertThat(expected)
          .hasMessageThat()
          .contains(
              "TestObject{group=1, item=2} [group 1, item 2] must be equivalent to "
                  + "TestObject{group=1, item=1} [group 1, item 1]");
      return;
    }
    fail();
  }

  public void testTest_transitive() {
    Object group1Item1 = new TestObject(1, 1);

    } catch (AssertionFailedError expected) {
      assertThat(expected)
          .hasMessageThat()
          .contains(
              "TestObject{group=1, item=2} [group 1, item 2] must be equivalent to "
                  + "TestObject{group=1, item=1} [group 1, item 1]");
      return;
    }
    fail();
  }

  public void testTest_transitive() {
    Object group1Item1 = new TestObject(1, 1);

  /**
   * Determines if the given iterable contains no elements.
   *
   * <p>There is no precise {@link Iterator} equivalent to this method, since one can only ask an
   * iterator whether it has any elements <i>remaining</i> (which one does using {@link
   * Iterator#hasNext}).
   *
   * <p><b>{@code Stream} equivalent:</b> {@code !stream.findAny().isPresent()}
   *
   * @return {@code true} if the iterable contains no elements

          || (a = as[(n - 1) & hc[0]]) == null
          || !(uncontended = a.cas(v = a.value, v + x))) retryUpdate(x, hc, uncontended);
    }
  }

  /** Equivalent to {@code add(1)}. */
  @Override
  public void increment() {
    add(1L);
  }

  /** Equivalent to {@code add(-1)}. */
  public void decrement() {
    add(-1L);
  }

  /**

    return array;
  }

  protected void initCollectionWithNullElement() {
    E[] array = createArrayWithNullElement();
    resetContainer(getSubjectGenerator().create(array));
  }

  /**
   * Equivalent to {@link #expectMissing(Object[]) expectMissing}{@code (null)} except that the call
   * to {@code contains(null)} is permitted to throw a {@code NullPointerException}.
   *

    return array;
  }

  protected void initCollectionWithNullElement() {
    E[] array = createArrayWithNullElement();
    resetContainer(getSubjectGenerator().create(array));
  }

  /**
   * Equivalent to {@link #expectMissing(Object[]) expectMissing}{@code (null)} except that the call
   * to {@code contains(null)} is permitted to throw a {@code NullPointerException}.
   *

        NdrSmall ndrSmall = new NdrSmall(-1); // -1 & 0xFF = 255
        assertEquals(255, ndrSmall.value, "Negative value should be masked to its unsigned byte equivalent.");
    }

    @Test
    void testConstructor_overflowValue() {
        // Test with a value exceeding byte range, expecting it to be masked
        NdrSmall ndrSmall = new NdrSmall(256); // 256 & 0xFF = 0

// any pointer.
type uintptr uintptr

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
type byte = uint8

// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.
type rune = int32

     * This is a convenience method equivalent to {@code get().instant()}.
     *
     * @return the current instant using monotonic timing
     */
    public static Instant now() {
        return get().instant();
    }

    /**
     * Returns the initialization time of this monotonic clock.
     * This is a convenience method equivalent to {@code get().start()}.
     *

@GwtCompatible
final class PairwiseEquivalence<E, T extends @Nullable E> extends Equivalence<Iterable<T>>
    implements Serializable {
  final Equivalence<E> elementEquivalence;

  PairwiseEquivalence(Equivalence<E> elementEquivalence) {
    this.elementEquivalence = Preconditions.checkNotNull(elementEquivalence);
  }

  @Override
  protected boolean doEquivalent(Iterable<T> iterableA, Iterable<T> iterableB) {