t.Fatalf("CreateInBatches failed: %v", err)
	}

	results, err := gorm.G[User](DB).Where("name like ?", "GenericsDistinct%").Distinct("name").Find(ctx)
	if err != nil {
		t.Fatalf("Distinct Find failed: %v", err)
	}

	if len(results) != 2 {
		t.Errorf("expected 2 distinct names, got %d", len(results))
	}

	var names []string
	for _, u := range results {
		names = append(names, u.Name)
	}

    stream.defaultWriteObject();
    stream.writeObject(type);
    Serialization.writeMultiset(this, stream);
  }

  /**
   * @serialData the {@code Class<E>} for the enum type, the number of distinct elements, the first
   *     element, its count, the second element, its count, and so on
   */
  @GwtIncompatible // java.io.ObjectInputStream

        return node.elemCount;
      }

      @Override
      long treeAggregate(@Nullable AvlNode<?> root) {
        return (root == null) ? 0 : root.totalCount;
      }
    },
    DISTINCT {
      @Override
      int nodeAggregate(AvlNode<?> node) {
        return 1;
      }

      @Override
      long treeAggregate(@Nullable AvlNode<?> root) {

                .filter(StringUtil::isNotBlank)
                .distinct()
                .toArray(n -> new String[n]));
    }

    default String getSearchDefaultDisplayPermission() {
        return split(getRoleSearchDefaultDisplayPermissions(), ",")
                .get(stream -> stream.filter(StringUtil::isNotBlank).distinct().collect(Collectors.joining("\n")));
    }

    String getQueryGeoFields();

        final List<String> pagingQueryList = new ArrayList<>();
        if (form.ex_q != null) {
            stream(form.ex_q).of(stream -> stream.filter(StringUtil::isNotBlank)
                    .distinct()
                    .forEach(q -> pagingQueryList.add("ex_q=" + LaFunctions.u(q))));
        }
        if (StringUtil.isNotBlank(form.sort)) {
            pagingQueryList.add("sort=" + LaFunctions.u(form.sort));

    assertThat(new AtomicDoubleArray(0).toString()).isEqualTo("[]");
    assertThat(new AtomicDoubleArray(new double[0]).toString()).isEqualTo("[]");
  }

  /** compareAndSet treats +0.0 and -0.0 as distinct values */
  public void testDistinctZeros() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i : new int[] {0, SIZE - 1}) {
      assertFalse(aa.compareAndSet(i, -0.0, 7.0));

        void testSigningFlagsNoOverlap() {
            assertNotEquals(Smb2Constants.SMB2_NEGOTIATE_SIGNING_ENABLED, Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED,
                    "Signing flags must be distinct");

            // Verify they can be combined with bitwise OR
            int combined = Smb2Constants.SMB2_NEGOTIATE_SIGNING_ENABLED | Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED;

	// works, but only when running one binary at a time.
	// Use a file lock to make sure only one wrapper is running at a time.
	//
	// The lock file is never deleted, to avoid concurrent locks on distinct
	// files with the same path.
	lockName := filepath.Join(os.TempDir(), "go_ios_exec-"+deviceID+".lock")
	lock, err = os.OpenFile(lockName, os.O_CREATE|os.O_RDONLY, 0666)
	if err != nil {
		return 1, err
	}

			t.Fatalf("%d: %v", i, err)
		}

		// repr.Println(s, repr.Indent("  "), repr.OmitEmpty(true))
	}
}

func TestSqlLexerArithOps(t *testing.T) {
	s := bytes.NewBuffer([]byte("year from select month hour distinct"))
	lex, err := sqlLexer.Lex(s)
	if err != nil {
		t.Fatal(err)
	}
	tokens, err := lexer.ConsumeAll(lex)
	if err != nil {
		t.Fatal(err)
	}
	if len(tokens) != 7 {

    assertThat(new AtomicDoubleArray(0).toString()).isEqualTo("[]");
    assertThat(new AtomicDoubleArray(new double[0]).toString()).isEqualTo("[]");
  }

  /** compareAndSet treats +0.0 and -0.0 as distinct values */
  public void testDistinctZeros() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i : new int[] {0, SIZE - 1}) {
      assertFalse(aa.compareAndSet(i, -0.0, 7.0));