func TestPreparedStmtConcurrentReset(t *testing.T) {
	name := "prepared_stmt_concurrent_reset"
	user := *GetUser(name, Config{})
	createTx := DB.Session(&gorm.Session{}).Create(&user)
	if createTx.Error != nil {
		t.Fatalf("failed to prepare record due to %s, test cannot be continue", createTx.Error)
	}

	// create a new connection to keep away from other tests
	tx, err := OpenTestConnection(&gorm.Config{PrepareStmt: true})
	if err != nil {

		Account:   true,
		Pets:      2,
		Toys:      3,
		Company:   true,
		Manager:   true,
		Team:      4,
		Languages: 3,
		Friends:   1,
	})

	if err := DB.Create(&user).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	}

	CheckUser(t, user, user)

	var user2 User
	DB.Preload(clause.Associations).Find(&user2, "id = ?", user.ID)
	CheckUser(t, user2, user)

    return emptySet();
  }

  public Test testsForEmptyList() {
    return ListTestSuiteBuilder.using(
            new TestStringListGenerator() {
              @Override
              public List<String> create(String[] elements) {
                return emptyList();
              }
            })
        .named("emptyList")
        .withFeatures(CollectionFeature.SERIALIZABLE, CollectionSize.ZERO)

      }
    },
    PRIORITY_QUEUE {
      @Override
      public Queue<Integer> create(Comparator<Integer> comparator) {
        return new PriorityQueue<>(11, comparator);
      }
    },
    INVERTED_MIN_MAX {
      @Override
      public Queue<Integer> create(Comparator<Integer> comparator) {
        return new InvertedMinMaxPriorityQueue<>(comparator);
      }
    };

    return new TestStringMultisetGenerator() {
      @Override
      protected Multiset<String> create(String[] elements) {
        return HashMultiset.create(asList(elements));
      }
    };
  }

  public void testCreate() {
    Multiset<String> multiset = HashMultiset.create();
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());

  public void testOrderingDoesntAffectEqualsComparisons() {
    SetMultimap<K, V> multimap1 =
        getSubjectGenerator()
            .create(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k0(), v4()));
    SetMultimap<K, V> multimap2 =
        getSubjectGenerator()
            .create(mapEntry(k0(), v1()), mapEntry(k0(), v0()), mapEntry(k0(), v4()));
    new EqualsTester().addEqualityGroup(multimap1, multimap2).testEquals();
  }

    suite.addTest(
        QueueTestSuiteBuilder.using(
                new TestStringQueueGenerator() {
                  @Override
                  protected Queue<String> create(String[] elements) {
                    return MinMaxPriorityQueue.create(asList(elements));
                  }
                })
            .named("MinMaxPriorityQueue")
            .withFeatures(CollectionSize.ANY, CollectionFeature.GENERAL_PURPOSE)

      implements TestListGenerator<Entry<String, Integer>> {
    @Override
    public List<Entry<String, Integer>> create(Object... elements) {
      return (List<Entry<String, Integer>>) super.create(elements);
    }
  }

  public static Test suite() {
    TestSuite suite = new TestSuite();

    suite.addTest(transformSuite());
    suite.addTest(filterSuite());

    assertThrows(IllegalArgumentException.class, () -> HashMultimap.create(-20, 15));

    assertThrows(IllegalArgumentException.class, () -> HashMultimap.create(20, -15));
  }

  public void testEmptyMultimapsEqual() {
    Multimap<String, Integer> setMultimap = HashMultimap.create();
    Multimap<String, Integer> listMultimap = ArrayListMultimap.create();
    assertTrue(setMultimap.equals(listMultimap));

    assertThrows(IllegalArgumentException.class, () -> HashMultimap.create(-20, 15));

    assertThrows(IllegalArgumentException.class, () -> HashMultimap.create(20, -15));
  }

  public void testEmptyMultimapsEqual() {
    Multimap<String, Integer> setMultimap = HashMultimap.create();
    Multimap<String, Integer> listMultimap = ArrayListMultimap.create();
    assertTrue(setMultimap.equals(listMultimap));