* Test for query conditions (filtering). Exercises the whole query DSL on the sample domain model.

*

* @author anistor@redhat.com

* @author rvansa@redhat.com

* @since 6.0

*/

   @BeforeClass(alwaysRun = true)

   protected void populateCache() throws Exception {

      // create the test objects

      User user1 = getModelFactory().makeUser();

      user1.setId(1);

      user1.setName("John");

      user1.setSurname("Doe");

      user1.setGender(User.Gender.MALE);

      user1.setAge(22);

      user1.setAccountIds(new HashSet<Integer>(Arrays.asList(1, 2)));

      Address address1 = getModelFactory().makeAddress();

      address1.setStreet("Main Street");

      address1.setPostCode("X1234");

      user1.setAddresses(Collections.singletonList(address1));

      User user2 = getModelFactory().makeUser();

      user2.setId(2);

      user2.setName("Spider");

      user2.setSurname("Man");

      user2.setGender(User.Gender.MALE);

      user2.setAccountIds(Collections.singleton(3));

      Address address2 = getModelFactory().makeAddress();

      address2.setStreet("Old Street");

      address2.setPostCode("Y12");

      Address address3 = getModelFactory().makeAddress();

      address3.setStreet("Bond Street");

      address3.setPostCode("ZZ");

      user2.setAddresses(Arrays.asList(address2, address3));

      User user3 = getModelFactory().makeUser();

      user3.setId(3);

      user3.setName("Spider");

      user3.setSurname("Woman");

      user3.setGender(User.Gender.FEMALE);

      user3.setAccountIds(Collections.<Integer>emptySet());

      Account account1 = getModelFactory().makeAccount();

      account1.setId(1);

      account1.setDescription("John Doe's first bank account");

      account1.setCreationDate(makeDate("2013-01-03"));

      Account account2 = getModelFactory().makeAccount();

      account2.setId(2);

      account2.setDescription("John Doe's second bank account");

      account2.setCreationDate(makeDate("2013-01-04"));

      Account account3 = getModelFactory().makeAccount();

      account3.setId(3);

      account3.setCreationDate(makeDate("2013-01-20"));

      Transaction transaction0 = getModelFactory().makeTransaction();

      transaction0.setId(0);

      transaction0.setDescription("Birthday present");

      transaction0.setAccountId(1);

      transaction0.setAmount(1800);

      transaction0.setDate(makeDate("2012-09-07"));

      transaction0.setDebit(false);

      Transaction transaction1 = getModelFactory().makeTransaction();

      transaction1.setId(1);

      transaction1.setDescription("Feb. rent payment");

      transaction1.setAccountId(1);

      transaction1.setAmount(1500);

      transaction1.setDate(makeDate("2013-01-05"));

      transaction1.setDebit(true);

      Transaction transaction2 = getModelFactory().makeTransaction();

      transaction2.setId(2);

      transaction2.setDescription("Starbucks");

      transaction2.setAccountId(1);

      transaction2.setAmount(23);

      transaction2.setDate(makeDate("2013-01-09"));

      transaction2.setDebit(true);

      Transaction transaction3 = getModelFactory().makeTransaction();

      transaction3.setId(3);

      transaction3.setDescription("Hotel");

      transaction3.setAccountId(2);

      transaction3.setAmount(45);

      transaction3.setDate(makeDate("2013-02-27"));

      transaction3.setDebit(true);

      Transaction transaction4 = getModelFactory().makeTransaction();

      transaction4.setId(4);

      transaction4.setDescription("Last january");

      transaction4.setAccountId(2);

      transaction4.setAmount(95);

      transaction4.setDate(makeDate("2013-01-31"));

      transaction4.setDebit(true);

      Transaction transaction5 = getModelFactory().makeTransaction();

      transaction5.setId(5);

      transaction5.setDescription("Popcorn");

      transaction5.setAccountId(2);

      transaction5.setAmount(5);

      transaction5.setDate(makeDate("2013-01-01"));

      transaction5.setDebit(true);

      // persist and index the test objects

      // we put all of them in the same cache for the sake of simplicity

      getCacheForWrite().put("user_" + user1.getId(), user1);

      getCacheForWrite().put("user_" + user2.getId(), user2);

      getCacheForWrite().put("user_" + user3.getId(), user3);

      getCacheForWrite().put("account_" + account1.getId(), account1);

      getCacheForWrite().put("account_" + account2.getId(), account2);

      getCacheForWrite().put("account_" + account3.getId(), account3);

      getCacheForWrite().put("transaction_" + transaction0.getId(), transaction0);

      getCacheForWrite().put("transaction_" + transaction1.getId(), transaction1);

      getCacheForWrite().put("transaction_" + transaction2.getId(), transaction2);

      getCacheForWrite().put("transaction_" + transaction3.getId(), transaction3);

      getCacheForWrite().put("transaction_" + transaction4.getId(), transaction4);

      getCacheForWrite().put("transaction_" + transaction5.getId(), transaction5);

      for (int i = 0; i < 50; i++) {

         Transaction transaction = getModelFactory().makeTransaction();

         transaction.setId(50 + i);

         transaction.setDescription("Expensive shoes " + i);

         transaction.setAccountId(2);

         transaction.setAmount(100 + i);

         transaction.setDate(makeDate("2013-08-20"));

         transaction.setDebit(true);

         getCacheForWrite().put("transaction_" + transaction.getId(), transaction);

      }

   }

   public void testIndexPresence() {

      SearchFactoryImplementor searchFactory = (SearchFactoryImplementor) Search.getSearchManager((Cache) getCacheForQuery()).getSearchFactory();

      IndexManagerHolder indexManagerHolder = searchFactory.getIndexManagerHolder();

      assertTrue(searchFactory.getIndexedTypes().contains(getModelFactory().getUserImplClass()));

      assertNotNull(indexManagerHolder.getIndexManager(getModelFactory().getUserImplClass().getName()));

      assertTrue(searchFactory.getIndexedTypes().contains(getModelFactory().getAccountImplClass()));

      assertNotNull(indexManagerHolder.getIndexManager(getModelFactory().getAccountImplClass().getName()));

      assertTrue(searchFactory.getIndexedTypes().contains(getModelFactory().getTransactionImplClass()));

      assertNotNull(indexManagerHolder.getIndexManager(getModelFactory().getTransactionImplClass().getName()));

      assertFalse(searchFactory.getIndexedTypes().contains(getModelFactory().getAddressImplClass()));

      assertNull(indexManagerHolder.getIndexManager(getModelFactory().getAddressImplClass().getName()));

   }

   public void testQueryFactoryType() {

      assertEquals(EmbeddedLuceneQueryFactory.class, getQueryFactory().getClass());

   }

   public void testEq1() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("name").eq("John")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals("John", list.get(0).getName());

      assertEquals("Doe", list.get(0).getSurname());

   }

   public void testEq() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("name").eq("Jacob")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(0, list.size());

   }

   public void testEqInNested1() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all users in a given post code

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("addresses.postCode").eq("X1234")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals("X1234", list.get(0).getAddresses().get(0).getPostCode());

   }

   public void testEqInNested2() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("addresses.postCode").eq("Y12")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals(2, list.get(0).getAddresses().size());

   }

   public void testLike() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all rent payments made from a given account

      Query q = qf.from(getModelFactory().getTransactionImplClass())

            .having("description").like("%rent%")

            .toBuilder().build();

      List<Transaction> list = q.list();

      assertEquals(1, list.size());

      assertEquals(1, list.get(0).getAccountId());

      assertEquals(1500, list.get(0).getAmount(), 0);

   }

   public void testBetween1() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all the transactions that happened in January 2013

      Query q = qf.from(getModelFactory().getTransactionImplClass())

            .having("date").between(makeDate("2013-01-01"), makeDate("2013-01-31"))

            .toBuilder().build();

      List<Transaction> list = q.list();

      assertEquals(4, list.size());

      for (Transaction t : list) {

         assertTrue(t.getDate().compareTo(makeDate("2013-01-31")) <= 0);

         assertTrue(t.getDate().compareTo(makeDate("2013-01-01")) >= 0);

      }

   }

   public void testBetween2() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all the transactions that happened in January 2013

      Query q = qf.from(getModelFactory().getTransactionImplClass())

            .having("date").between(makeDate("2013-01-01"), makeDate("2013-01-31")).includeUpper(false)

            .toBuilder().build();

      List<Transaction> list = q.list();

      assertEquals(3, list.size());

      for (Transaction t : list) {

         assertTrue(t.getDate().compareTo(makeDate("2013-01-31")) < 0);

         assertTrue(t.getDate().compareTo(makeDate("2013-01-01")) >= 0);

      }

   }

   public void testBetween3() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all the transactions that happened in January 2013

      Query q = qf.from(getModelFactory().getTransactionImplClass())

            .having("date").between(makeDate("2013-01-01"), makeDate("2013-01-31")).includeLower(false)

            .toBuilder().build();

      List<Transaction> list = q.list();

      assertEquals(3, list.size());

      for (Transaction t : list) {

         assertTrue(t.getDate().compareTo(makeDate("2013-01-31")) <= 0);

         assertTrue(t.getDate().compareTo(makeDate("2013-01-01")) > 0);

      }

   }

   public void testGt() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all the transactions greater than a given amount

      Query q = qf.from(getModelFactory().getTransactionImplClass())

            .having("amount").gt(1500)

            .toBuilder().build();

      List<Transaction> list = q.list();

      assertEquals(1, list.size());

      assertTrue(list.get(0).getAmount() > 1500);

   }

   public void testGte() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getTransactionImplClass())

            .having("amount").gte(1500)

            .toBuilder().build();

      List<Transaction> list = q.list();

      assertEquals(2, list.size());

      for (Transaction t : list) {

         assertTrue(t.getAmount() >= 1500);

      }

   }

   public void testLt() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getTransactionImplClass())

            .having("amount").lt(1500)

            .toBuilder().build();

      List<Transaction> list = q.list();

      assertEquals(54, list.size());

      for (Transaction t : list) {

         assertTrue(t.getAmount() < 1500);

      }

   }

   public void testLte() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getTransactionImplClass())

            .having("amount").lte(1500)

            .toBuilder().build();

      List<Transaction> list = q.list();

      assertEquals(55, list.size());

      for (Transaction t : list) {

         assertTrue(t.getAmount() <= 1500);

      }

   }

   public void testAnd1() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("name").eq("Spider")

            .and().having("surname").eq("Man")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals(2, list.get(0).getId());

   }

   public void testAnd2() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("name").eq("Spider")

            .and(qf.having("surname").eq("Man"))

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals(2, list.get(0).getId());

   }

   public void testAnd3() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("gender").eq(User.Gender.MALE)

            .and().having("gender").eq(User.Gender.FEMALE)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(0, list.size());

   }

   public void testAnd4() throws Exception {

      QueryFactory qf = getQueryFactory();

      //test for parenthesis, "and" should have higher priority

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("name").eq("Spider")

            .or(qf.having("name").eq("John"))

            .and(qf.having("surname").eq("Man"))

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(2, list.size());

   }

   public void testOr1() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("surname").eq("Man")

            .or().having("surname").eq("Woman")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      for (User u : list) {

         assertEquals("Spider", u.getName());

      }

   }

   public void testOr2() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("surname").eq("Man")

            .or(qf.having("surname").eq("Woman"))

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      for (User u : list) {

         assertEquals("Spider", u.getName());

      }

   }

   public void testOr3() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("gender").eq(User.Gender.MALE)

            .or().having("gender").eq(User.Gender.FEMALE)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(3, list.size());

   }

   public void testOr4() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .orderBy("surname", SortOrder.DESC)

            .having("gender").eq(User.Gender.MALE)

            .or().having("name").eq("Spider")

            .and().having("gender").eq(User.Gender.FEMALE)

            .or().having("surname").like("%oe%")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      assertEquals("Woman", list.get(0).getSurname());

      assertEquals("Doe", list.get(1).getSurname());

   }

   public void testOr5() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("gender").eq(User.Gender.MALE)

            .or().having("name").eq("Spider")

            .or().having("gender").eq(User.Gender.FEMALE)

            .and().having("surname").like("%oe%")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals("John", list.get(0).getName());

   }

   public void testNot1() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .not().having("name").eq("Spider")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals("John", list.get(0).getName());

   }

   public void testNot2() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .not().not().having("surname").eq("Doe")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals("John", list.get(0).getName());

   }

   public void testNot3() throws Exception {

      QueryFactory qf = getQueryFactory();

      // NOT should have higher priority than AND

      Query q = qf.from(getModelFactory().getUserImplClass())

            .not().having("name").eq("John")

            .and().having("surname").eq("Man")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals("Spider", list.get(0).getName());

   }

   public void testNot4() throws Exception {

      QueryFactory qf = getQueryFactory();

      // NOT should have higher priority than AND

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("surname").eq("Man")

            .and().not().having("name").eq("John")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals("Spider", list.get(0).getName());

   }

   public void testNot5() throws Exception {

      QueryFactory qf = getQueryFactory();

      // NOT should have higher priority than OR

      Query q = qf.from(getModelFactory().getUserImplClass())

            .not().having("name").eq("Spider")

            .or().having("surname").eq("Man")

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      for (User u : list) {

         assertFalse("Woman".equals(u.getSurname()));

      }

   }

   public void testNot6() throws Exception {

      QueryFactory qf = getQueryFactory();

      // QueryFactory.not() test

      Query q = qf.from(getModelFactory().getUserImplClass())

            .not(qf.not(qf.having("gender").eq(User.Gender.FEMALE)))

            .toBuilder()

            .build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertTrue(list.get(0).getSurname().equals("Woman"));

   }

   public void testNot7() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("gender").eq(User.Gender.FEMALE)

            .and().not(qf.having("name").eq("Spider"))

            .toBuilder().build();

      List<User> list = q.list();

      assertTrue(list.isEmpty());

   }

   public void testNot8() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .not(

                  qf.having("name").eq("John")

                        .or(qf.having("surname").eq("Man")))

            .toBuilder()

            .build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals("Spider", list.get(0).getName());

      assertEquals("Woman", list.get(0).getSurname());

   }

   public void testNot9() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .not(

                  qf.having("name").eq("John")

                        .and(qf.having("surname").eq("Doe")))

            .toBuilder()

            .orderBy("id", SortOrder.ASC)

            .build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      assertEquals("Spider", list.get(0).getName());

      assertEquals("Man", list.get(0).getSurname());

      assertEquals("Spider", list.get(1).getName());

      assertEquals("Woman", list.get(1).getSurname());

   }

   public void testNot10() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .not().not(

                  qf.having("name").eq("John")

                        .or(qf.having("surname").eq("Man")))

            .toBuilder()

            .build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      assertNotEquals("Woman", list.get(0).getSurname());

   }

   public void testNot11() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .not(qf.not(

                  qf.having("name").eq("John")

                        .or(qf.having("surname").eq("Man"))))

            .toBuilder()

            .build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      assertNotEquals("Woman", list.get(0).getSurname());

   }

   public void testEmptyQuery() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass()).build();

      List<User> list = q.list();

      assertEquals(3, list.size());

   }

   @Test(expectedExceptions = ParsingException.class, expectedExceptionsMessageRegExp = "HQLLUCN000005:.*")

   public void testInvalidEmbeddedAttributeQuery() throws Exception {

      QueryFactory qf = getQueryFactory();

      QueryBuilder queryBuilder = qf.from(getModelFactory().getUserImplClass())

            .setProjection("addresses");

      queryBuilder.build();  // exception expected

   }

   public void testIsNull() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("addresses").isNull()

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals(3, list.get(0).getId());

   }

   public void testContains1() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("accountIds").contains(2)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals(1, list.get(0).getId());

   }

   public void testContains2() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("accountIds").contains(42)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(0, list.size());

   }

   public void testContainsAll1() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("accountIds").containsAll(1, 2)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals(1, list.get(0).getId());

   }

   public void testContainsAll2() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("accountIds").containsAll(Collections.singleton(1))

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(1, list.size());

      assertEquals(1, list.get(0).getId());

   }

   public void testContainsAll3() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("accountIds").containsAll(1, 2, 3)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(0, list.size());

   }

   public void testContainsAll4() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("accountIds").containsAll(Collections.emptySet())

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(3, list.size());

   }

   public void testContainsAny1() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .orderBy("id", SortOrder.ASC)

            .having("accountIds").containsAny(2, 3)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      assertEquals(1, list.get(0).getId());

      assertEquals(2, list.get(1).getId());

   }

   public void testContainsAny2() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("accountIds").containsAny(4, 5)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(0, list.size());

   }

   public void testContainsAny3() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("accountIds").containsAny(Collections.emptySet())

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(3, list.size());

   }

   public void testIn1() throws Exception {

      QueryFactory qf = getQueryFactory();

      List<Integer> ids = Arrays.asList(1, 3);

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("id").in(ids)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      for (User u : list) {

         assertTrue(ids.contains(u.getId()));

      }

   }

   public void testIn2() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getUserImplClass())

            .having("id").in(4)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(0, list.size());

   }

   @Test(expectedExceptions = IllegalArgumentException.class)

   public void testIn3() throws Exception {

      QueryFactory qf = getQueryFactory();

      qf.from(getModelFactory().getUserImplClass()).having("id").in(Collections.emptySet());

   }

   @Test(expectedExceptions = IllegalArgumentException.class)

   public void testIn4() throws Exception {

      QueryFactory qf = getQueryFactory();

      Collection collection = null;

      qf.from(getModelFactory().getUserImplClass()).having("id").in(collection);

   }

   @Test(expectedExceptions = IllegalArgumentException.class)

   public void testIn5() throws Exception {

      QueryFactory qf = getQueryFactory();

      Object[] array = null;

      qf.from(getModelFactory().getUserImplClass()).having("id").in(array);

   }

   @Test(expectedExceptions = IllegalArgumentException.class)

   public void testIn6() throws Exception {

      QueryFactory qf = getQueryFactory();

      Object[] array = new Object[0];

      qf.from(getModelFactory().getUserImplClass()).having("id").in(array);

   }

   public void testSampleDomainQuery1() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all male users

      Query q = qf.from(getModelFactory().getUserImplClass())

            .orderBy("name", SortOrder.ASC)

            .having("gender").eq(User.Gender.MALE)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      assertEquals("John", list.get(0).getName());

      assertEquals("Spider", list.get(1).getName());

   }

   public void testSampleDomainQuery2() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all male users, but this time retrieved in a twisted manner

      Query q = qf.from(getModelFactory().getUserImplClass())

            .orderBy("name", SortOrder.ASC)

            .not(qf.having("gender").eq(User.Gender.FEMALE))

            .and(qf.not().not(qf.having("gender").eq(User.Gender.MALE)))

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      assertEquals("John", list.get(0).getName());

      assertEquals("Spider", list.get(1).getName());

   }

   public void testStringLiteralEscape() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all transactions that have a given description. the description contains characters that need to be escaped.

      Query q = qf.from(getModelFactory().getAccountImplClass())

            .having("description").eq("John Doe's first bank account")

            .toBuilder().build();

      List<Account> list = q.list();

      assertEquals(1, list.size());

      assertEquals(1, list.get(0).getId());

   }

   public void testSortByDate() throws Exception {

      QueryFactory qf = getQueryFactory();

      Query q = qf.from(getModelFactory().getAccountImplClass())

            .orderBy("creationDate", SortOrder.DESC)

            .build();

      List<Account> list = q.list();

      assertEquals(3, list.size());

      assertEquals(3, list.get(0).getId());

      assertEquals(2, list.get(1).getId());

      assertEquals(1, list.get(2).getId());

   }

   public void testSampleDomainQuery3() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all male users

      Query q = qf.from(getModelFactory().getUserImplClass())

            .orderBy("name", SortOrder.ASC)

            .having("gender").eq(User.Gender.MALE)

            .toBuilder().build();

      List<User> list = q.list();

      assertEquals(2, list.size());

      assertEquals("John", list.get(0).getName());

      assertEquals("Spider", list.get(1).getName());

   }

   public void testSampleDomainQuery4() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all users ordered descendingly by name

      Query q = qf.from(getModelFactory().getUserImplClass())

            .orderBy("name", SortOrder.DESC)

            .build();

      List<User> list = q.list();

      assertEquals(3, list.size());

      assertEquals("Spider", list.get(0).getName());

      assertEquals("Spider", list.get(1).getName());

      assertEquals("John", list.get(2).getName());

   }

   public void testSampleDomainQuery4With2SortingOptions() throws Exception {

      QueryFactory qf = getQueryFactory();

      // all users ordered descendingly by name

      Query q = qf.from(getModelFactory().getUserImplClass())

            .orderBy("name", SortOrder.DESC)

            .orderBy("surname", SortOrder.ASC)

            .build();

      List<User> list = q.list();

      assertEquals(3, list.size());

      assertEquals("Spider", list.get(0).getName());

      assertEquals("Spider", list.get(1).getName());

      assertEquals("John", list.get(2).getName());

      assertEquals("Man", list.get(0).getSurname());

      assertEquals("Woman", list.get(1).getSurname());