}
            });
  }

  public void testEquals() {
    Set<String> set1 = ImmutableSet.of("one");
    Set<String> set2 = ImmutableSet.of("two");
    new EqualsTester()
        .addEqualityGroup(set1, wrap(set1), wrap(set1))
        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> Set<T> wrap(Set<T> delegate) {
    return new ForwardingSet<T>() {
      @Override

			children, parent.Children)
	}
}

func TestAssociationError(t *testing.T) {
	user := *GetUser("TestAssociationError", Config{Pets: 2, Company: true, Account: true, Languages: 2})
	DB.Create(&user)

	var user1 User
	DB.Preload("Company").Preload("Pets").Preload("Account").Preload("Languages").First(&user1)

	var emptyUser User
	var err error
	// belongs to

  }

  public void testEquals() {
    SortedMultiset<String> set1 = ImmutableSortedMultiset.of("one");
    SortedMultiset<String> set2 = ImmutableSortedMultiset.of("two");
    new EqualsTester()
        .addEqualityGroup(set1, wrap(set1), wrap(set1))
        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> SortedMultiset<T> wrap(SortedMultiset<T> delegate) {

    BiPredicate<ImmutableSortedSet<String>, ImmutableSortedSet<String>> equivalence =
        (set1, set2) ->
            set1.equals(set2)
                && set1.asList().equals(set2.asList())
                && set1.comparator().equals(set2.comparator());
    ImmutableSortedSet<String> expected =
        ImmutableSortedSet.orderedBy(String.CASE_INSENSITIVE_ORDER).add("a", "B", "c", "d").build();

	DB.Save(GetUser("joins-args-db", Config{Pets: 2}))

	if err := DB.Migrator().CreateView("invalid_users_pets",
		gorm.ViewOption{Query: nil}); err != gorm.ErrSubQueryRequired {
		t.Fatalf("no view should be created, got %v", err)
	}

	query := DB.Model(&User{}).
		Select("users.id as users_id, users.name as users_name, pets.id as pets_id, pets.name as pets_name").

    BiPredicate<ImmutableSet<TypeWithDuplicates>, ImmutableSet<TypeWithDuplicates>> equivalence =
        (set1, set2) -> {
          if (!set1.equals(set2)) {
            return false;
          }
          for (int i = 0; i < set1.size(); i++) {
            if (!set1.asList().get(i).fullEquals(set2.asList().get(i))) {
              return false;
            }
          }
          return true;
        };

   * @deprecated Use {@link com.google.common.collect.Sets#intersection(Set, Set)} instead.
   */
  @Deprecated
  public static <T> Set<T> intersection(Set<? extends T> set1, Set<? extends T> set2) {
    Set<T> result = copyToSet(set1);
    result.retainAll(set2);
    return result;
  }

  private FeatureUtil() {}

  - family-names: Vasudevan
    given-names: Vijay
  - family-names: Viégas
    given-names: Fernanda
  - family-names: Vinyals
    given-names: Oriol
  - family-names: Warden
    given-names: Pete
  - family-names: Wattenberg
    given-names: Martin
  - family-names: Wicke
    given-names: Martin
  - family-names: Yu
    given-names: Yuan
  - family-names: Zheng
    given-names: Xiaoqiang
identifiers:

   * @deprecated Use {@link com.google.common.collect.Sets#intersection(Set, Set)} instead.
   */
  @Deprecated
  public static <T> Set<T> intersection(Set<? extends T> set1, Set<? extends T> set2) {
    Set<T> result = copyToSet(set1);
    result.retainAll(set2);
    return result;
  }

  private FeatureUtil() {}

import static org.junit.Assert.assertThrows;

import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@link LinearTransformation}.
 *
 * @author Pete Gillin
 */
@NullUnmarked
public class LinearTransformationTest extends TestCase {

  private static final double ALLOWED_ERROR = 1e-10;

  public void testMappingAnd_regular() {
    double x1 = 1.2;