// We need to test that our method behaves like the JDK method.
  @SuppressWarnings("InlineMeInliner")
  public void testCompare() {
    for (int x : VALUES) {
      for (int y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage(x + ", " + y).that(Ints.compare(x, y)).isEqualTo(Integer.compare(x, y));
      }
    }
  }

  public void testContains() {

    public ListIterator<E> listIterator(int index) {
      return realDelegate.listIterator(index);
    }

    @Override
    protected List<E> delegate() {
      throw new UnsupportedOperationException("This list only supports ListIterator");
    }
  }

  private static void assertTransformIterator(List<String> list) {
    Iterator<String> iterator = list.iterator();
    assertTrue(iterator.hasNext());

  // We need to test that our method behaves like the JDK method.
  @SuppressWarnings("InlineMeInliner")
  public void testCompare() {
    for (float x : VALUES) {
      for (float y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage(x + ", " + y).that(Floats.compare(x, y)).isEqualTo(Float.compare(x, y));
      }
    }
  }

  public void testContains() {

        QueryResponseList qrList = new QueryResponseList(null, 95, 10, 0) {
            @Override
            public int size() {
                return 5; // Only 5 records returned
            }
        };
        qrList.allRecordCount = 100; // Total 100 records
        qrList.calculatePageInfo();

        assertEquals(96, qrList.getCurrentStartRecordNumber()); // start + 1

  @GwtIncompatible // SerializableTester
  @SuppressWarnings("unchecked")
  public void ignore_testSerializationNoDuplication_regularImmutableMap() throws Exception {
    // Tests that serializing a map, its keySet, and values only writes the underlying data once.

    Object[] entries = new Object[2000];
    for (int i = 0; i < entries.length; i++) {
      entries[i] = i;
    }

		return nil // skip primary key
	}
	// By default, ColumnType's Unique is not affected by UniqueIndex, so we don't care about UniqueIndex.
	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
		// We're currently only receiving boolean values on `Unique` tag,
		// so the UniqueConstraint name is fixed
		constraint := m.DB.NamingStrategy.UniqueName(stmt.Table, field.DBName)
		if unique && !field.Unique {

    for (int i = 0; i < originalCount; i++) {
      Object key = new Object();
      Object value = new Object();
      int hash = map.hash(key);
      // chain all entries together as we only have a single bucket
      entry = map.newEntry(key, hash, entry);
      ValueReference<Object, Object> valueRef = map.newValueReference(entry, value, 1);
      entry.setValueReference(valueRef);
    }

        public int length;
        /** Security impersonation level. */
        public short impersonation_level;
        /** Context tracking mode. */
        public byte context_mode;
        /** Indicates if only effective privileges should be used. */
        public byte effective_only;

        @Override
        public void encode(final NdrBuffer _dst) throws NdrException {
            _dst.align(4);

      assertEquals("Started with " + startedWith, expected, actual);
    }
  }

  // J2kt cannot translate the Comparable rawtype in a usable way (it becomes Comparable<Object>
  // but types are typically only Comparable to themselves).
  @SuppressWarnings({"rawtypes", "unchecked"})
  private static MinMaxPriorityQueue.Builder<Comparable<?>> rawtypeToWildcard(
      MinMaxPriorityQueue.Builder<Comparable> builder) {

		t.Skip("skip sqlite, sqlserver due to it doesn't support multiple primary keys with auto increment")
	}

	if name := DB.Dialector.Name(); name == "mysql" {
		t.Skip("skip mysql due to it only allow unique constraint matching given keys")
	}

	type (
		Level1 struct {
			ID           uint   `gorm:"primary_key;"`
			LanguageCode string `gorm:"primary_key"`
			Value        string
		}