public String toString() {
      return "BY_TO_STRING";
    }

    private Object readResolve() {
      return INSTANCE;
    }
  }

  // Always equal is a valid total ordering. And it works for any Object.
  private static final class AlwaysEqual extends Ordering<@Nullable Object>
      implements Serializable {
    private static final AlwaysEqual INSTANCE = new AlwaysEqual();

    @Override

        // Test with different class
        assertFalse(item1.equals("string"));
    }

    @Test
    public void test_equals_withUnsortedInputs() {
        // Test that equals works correctly even when inputs are initially unsorted
        String[] inputs1 = { "z", "a", "m" };
        String[] inputs2 = { "m", "z", "a" };

        CharMappingItem item1 = new CharMappingItem(1L, inputs1, "output");

    StringBuilder sb1FromIterator = new StringBuilder().append('x');
    joiner.appendTo(sb1FromIterator, parts.iterator());
    assertThat(sb1FromIterator.toString()).isEqualTo("x" + expected);

    // The use of iterator() works around J2KT b/381065164.
    @Nullable Integer[] partsArray =
        newArrayList(parts.iterator()).toArray(new @Nullable Integer[0]);
    assertThat(joiner.join(partsArray)).isEqualTo(expected);

    }

    @Test
    @DisplayName("Context should handle resource creation consistently")
    void testResourceCreationConsistency() throws CIFSException {
        // Test that resource creation works consistently
        String[] validUrls = { "smb://server1/share1/", "smb://server2/share2/file.txt" };

        for (String validUrl : validUrls) {
            // When

     * This verifies that the ThreadLocal implementation doesn't cause issues
     */
    @Test
    public void test_threadLocalKryo() {
        // Perform multiple serializations to ensure ThreadLocal works
        for (int i = 0; i < 10; i++) {
            String original = "Test " + i;
            byte[] serialized = serializer.fromObjectToBinary(original);

    sort(insertionOrder, entryComparator(keyComparator));
    return insertionOrder;
  }

  /**
   * Compares strings in natural order except that null comes immediately before a given value. This
   * works better than Ordering.natural().nullsFirst() because, if null comes before all other
   * values, it lies outside the submap/submultiset ranges we test, and the variety of tests that

    return Collectors.collectingAndThen(
        Collectors.toMap(keyFunction, valueFunction, mergeFunction, LinkedHashMap::new),
        ImmutableMap::copyOf);
  }

  @SuppressWarnings("unchecked") // An empty map works for all types.
  public static <K, V> ImmutableMap<K, V> of() {
    return (ImmutableMap<K, V>) RegularImmutableMap.EMPTY;
  }

  public static <K, V> ImmutableMap<K, V> of(K k1, V v1) {

/**
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullUnmarked
public class ImmutableDoubleArrayTest extends TestCase {
  // Test all creation paths very lazily: by assuming asList() works

  public void testOf0() {
    assertThat(ImmutableDoubleArray.of().asList()).isEmpty();
  }

  public void testOf1() {
    assertThat(ImmutableDoubleArray.of(0).asList()).containsExactly(0.0);
  }

// are equal. The signatures are expected to be HEX encoded strings
// according to the AWS S3 signature V4 spec.
func compareSignatureV4(sig1, sig2 string) bool {
	// The CTC using []byte(str) works because the hex encoding
	// is unique for a sequence of bytes. See also compareSignatureV2.
	return subtle.ConstantTimeCompare([]byte(sig1), []byte(sig2)) == 1
}

/**
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullUnmarked
public class ImmutableLongArrayTest extends TestCase {
  // Test all creation paths very lazily: by assuming asList() works

  public void testOf0() {
    assertThat(ImmutableLongArray.of().asList()).isEmpty();
  }

  public void testOf1() {
    assertThat(ImmutableLongArray.of(0).asList()).containsExactly(0L);
  }