Exemple #1
0
  @Test
  @SkipForDialect(
      value = {SybaseASE15Dialect.class, Sybase11Dialect.class},
      comment = "Sybase does not support @Lob")
  public void testCreateIndexSearchEntityWithLobField() {
    // create and index
    Session session = openSession();
    Transaction tx = session.beginTransaction();

    LobHolder lobHolder = new LobHolder();
    lobHolder.setVeryLongText("this text is very long ...");
    session.persist(lobHolder);

    tx.commit();
    session.close();

    // search
    session = openSession();
    tx = session.beginTransaction();
    FullTextSession fullTextSession = Search.getFullTextSession(session);

    QueryBuilder qb =
        fullTextSession.getSearchFactory().buildQueryBuilder().forEntity(LobHolder.class).get();
    Query query = qb.keyword().onField("veryLongText").matching("text").createQuery();

    FullTextQuery hibernateQuery = fullTextSession.createFullTextQuery(query);
    List<LobHolder> result = hibernateQuery.list();
    assertEquals("We should have a match for the single LobHolder", 1, result.size());

    tx.commit();
    session.close();
  }
  @Test
  public void testUpdateOnImplicitJoinFails() {
    Session s = openSession();
    Transaction t = s.beginTransaction();

    Human human = new Human();
    human.setName(new Name("Steve", 'E', null));

    Human mother = new Human();
    mother.setName(new Name("Jane", 'E', null));
    human.setMother(mother);

    s.save(human);
    s.save(mother);
    s.flush();

    t.commit();

    t = s.beginTransaction();
    try {
      s.createQuery("update Human set mother.name.initial = :initial")
          .setString("initial", "F")
          .executeUpdate();
      fail("update allowed across implicit join");
    } catch (QueryException e) {
    }

    s.createQuery("delete Human where mother is not null").executeUpdate();
    s.createQuery("delete Human").executeUpdate();
    t.commit();
    s.close();
  }
  /**
   * Tests that the document id must be unique
   *
   * @throws Exception in case the test fails.
   */
  @Test
  public void testDocumentIdMustBeUnique() throws Exception {
    Article hello = new Article();
    hello.setDocumentId(1);
    hello.setText("Hello World");

    Article goodbye = new Article();
    goodbye.setDocumentId(1);
    goodbye.setText("Goodbye World");

    Session s = openSession();
    Transaction tx = s.beginTransaction();
    s.save(hello);
    s.save(goodbye);
    tx.commit();
    s.clear();

    tx = s.beginTransaction();
    try {
      Search.getFullTextSession(s)
          .createFullTextQuery(new TermQuery(new Term("text", "world")))
          .list();
      fail("Test should fail, because document id is not unique.");
    } catch (SearchException e) {
      assertEquals(
          "Loading entity of type org.hibernate.search.test.id.Article using 'documentId' as document id and '1' as value was not unique",
          e.getMessage());
    }
    tx.commit();
    s.close();
  }
  @Test
  public void testInsertIntoSuperclassPropertiesFails() {
    TestData data = new TestData();
    data.prepare();

    Session s = openSession();
    Transaction t = s.beginTransaction();

    try {
      s.createQuery("insert into Human (id, bodyWeight) select id, bodyWeight from Lizard")
          .executeUpdate();
      fail("superclass prop insertion did not error");
    } catch (QueryException e) {
      // expected result
    }

    t.commit();
    t = s.beginTransaction();

    s.createQuery("delete Animal where mother is not null").executeUpdate();
    s.createQuery("delete Animal where father is not null").executeUpdate();
    s.createQuery("delete Animal").executeUpdate();

    t.commit();
    s.close();

    data.cleanup();
  }
  @Test
  public void testIncrementCounterVersion() {
    Session s = openSession();
    Transaction t = s.beginTransaction();

    IntegerVersioned entity = new IntegerVersioned("int-vers");
    s.save(entity);
    t.commit();
    s.close();

    int initialVersion = entity.getVersion();

    s = openSession();
    t = s.beginTransaction();
    int count = s.createQuery("update versioned IntegerVersioned set name = name").executeUpdate();
    assertEquals("incorrect exec count", 1, count);
    t.commit();

    t = s.beginTransaction();
    entity = (IntegerVersioned) s.load(IntegerVersioned.class, entity.getId());
    assertEquals("version not incremented", initialVersion + 1, entity.getVersion());

    s.delete(entity);
    t.commit();
    s.close();
  }
 @Test
 public void testSaveLoad() {
   Long id = null;
   Session session = SessionUtil.getSession();
   Transaction tx = session.beginTransaction();
   SimpleObject obj = new SimpleObject();
   obj.setKey("sl");
   obj.setValue(10L);
   session.save(obj);
   assertNotNull(obj.getId());
   id = obj.getId();
   tx.commit();
   session.close();
   session = SessionUtil.getSession();
   tx = session.beginTransaction();
   SimpleObject o2 = (SimpleObject) session.load(SimpleObject.class, id);
   assertEquals(o2.getKey(), "sl");
   assertNotNull(o2.getValue());
   assertEquals(o2.getValue().longValue(), 10L);
   SimpleObject o3 = (SimpleObject) session.load(SimpleObject.class, id);
   // Since o2 and o3 were loaded in the same session, they are not only
   // equivalent - as shown by equals() - but equal, as shown by ==
   // since obj was loaded from a different session, it is equivalent but not ==
   assertEquals(o2, o3);
   assertEquals(obj, o2);
   assertTrue(o2 == o3);
   assertFalse(obj == o2);
   tx.commit();
   session.close();
 }
  public void testSummarize() throws Exception {
    // Create Transaction to be summarized
    Transaction tx = gls.beginTransaction();
    gls.post(tj, createTransaction("Txn 1"));
    gls.post(tj, createTransaction("Txn 2"));
    tx.commit();

    // Fetch the balances
    A_0 = gls.getBalance(tj, A);
    A_858 = gls.getBalance(tj, A, (short) 858);
    B_0 = gls.getBalance(tj, B);
    B_858 = gls.getBalance(tj, B, (short) 858);
    System.out.println("--- pre-balances --- ");
    System.out.println("  A(0): " + A_0);
    System.out.println("A(858): " + A_858);
    System.out.println("  B(0): " + B_0);
    System.out.println("B(858): " + B_858);

    // Summarize
    tx = gls.beginTransaction();
    gls.summarize(tj, POSTDATE, POSTDATE, "Summarized Txn", new short[] {0, 858});
    tx.commit();

    // Test post summarize balances
    System.out.println("--- post-balances ---");
    System.out.println("  A(0): " + gls.getBalance(tj, A));
    System.out.println("A(858): " + gls.getBalance(tj, A, (short) 858));
    System.out.println("  B(0): " + gls.getBalance(tj, B));
    System.out.println("B(858): " + gls.getBalance(tj, B, (short) 858));

    assertEquals(A_0, gls.getBalance(tj, A));
    assertEquals(A_858, gls.getBalance(tj, A, (short) 858));
    assertEquals(B_0, gls.getBalance(tj, B));
    assertEquals(B_858, gls.getBalance(tj, B, (short) 858));
  }
 public void testBlob() throws Exception {
   Session s;
   Transaction tx;
   s = openSession();
   tx = s.beginTransaction();
   CompiledCode cc = new CompiledCode();
   Byte[] header = new Byte[2];
   header[0] = new Byte((byte) 3);
   header[1] = new Byte((byte) 0);
   cc.setHeader(header);
   int codeSize = 5;
   byte[] full = new byte[codeSize];
   for (int i = 0; i < codeSize; i++) {
     full[i] = (byte) (1 + i);
   }
   cc.setFullCode(full);
   s.persist(cc);
   tx.commit();
   s.close();
   s = openSession();
   tx = s.beginTransaction();
   CompiledCode recompiled = (CompiledCode) s.get(CompiledCode.class, cc.getId());
   assertEquals(recompiled.getHeader()[1], cc.getHeader()[1]);
   assertEquals(recompiled.getFullCode()[codeSize - 1], cc.getFullCode()[codeSize - 1]);
   tx.commit();
   s.close();
 }
 public void testSerializableToBlob() throws Exception {
   Book book = new Book();
   Editor editor = new Editor();
   editor.setName("O'Reilly");
   book.setEditor(editor);
   book.setCode2(new char[] {'r'});
   Session s;
   Transaction tx;
   s = openSession();
   tx = s.beginTransaction();
   s.persist(book);
   tx.commit();
   s.close();
   s = openSession();
   tx = s.beginTransaction();
   Book loadedBook = (Book) s.get(Book.class, book.getId());
   assertNotNull(loadedBook.getEditor());
   assertEquals(book.getEditor().getName(), loadedBook.getEditor().getName());
   loadedBook.setEditor(null);
   tx.commit();
   s.close();
   s = openSession();
   tx = s.beginTransaction();
   loadedBook = (Book) s.get(Book.class, book.getId());
   assertNull(loadedBook.getEditor());
   tx.commit();
   s.close();
 }
  public void testBroken() throws Exception {
    if (getDialect() instanceof Oracle9Dialect) return;
    Session s = openSession();
    Transaction t = s.beginTransaction();
    Broken b = new Fixed();
    b.setId(new Long(123));
    b.setOtherId("foobar");
    s.save(b);
    s.flush();
    b.setTimestamp(new Date());
    t.commit();
    s.close();

    s = openSession();
    t = s.beginTransaction();
    s.update(b);
    t.commit();
    s.close();

    s = openSession();
    t = s.beginTransaction();
    b = (Broken) s.load(Broken.class, b);
    t.commit();
    s.close();

    s = openSession();
    t = s.beginTransaction();
    s.delete(b);
    t.commit();
    s.close();
  }
  public void testSqlFunctionAsAlias() throws Exception {
    String functionName = locateAppropriateDialectFunctionNameForAliasTest();
    if (functionName == null) {
      log.info("Dialect does not list any no-arg functions");
      return;
    }

    log.info("Using function named [" + functionName + "] for 'function as alias' test");
    String query =
        "select "
            + functionName
            + " from Simple as "
            + functionName
            + " where "
            + functionName
            + ".id = 10";

    Session s = openSession();
    Transaction t = s.beginTransaction();
    Simple simple = new Simple();
    simple.setName("Simple 1");
    s.save(simple, new Long(10));
    t.commit();
    s.close();

    s = openSession();
    t = s.beginTransaction();
    List result = s.find(query);
    assertTrue(result.size() == 1);
    assertTrue(result.get(0) instanceof Simple);
    s.delete(result.get(0));
    t.commit();
    s.close();
  }
  @Test
  public void testSpecificQueryRegionEviction() {
    int entityCount = 10;
    insertDummyEntities(entityCount, 0);
    // miss 1 query list entities
    Session session = sf.openSession();
    Transaction txn = session.beginTransaction();
    Query query = session.createQuery("from " + DummyEntity.class.getName());
    query.setCacheable(true).setCacheRegion("newregionname");
    query.list();
    txn.commit();
    session.close();
    // query is cached

    // query is invalidated
    sf.getCache().evictQueryRegion("newregionname");

    // miss 1 query
    session = sf.openSession();
    txn = session.beginTransaction();
    query = session.createQuery("from " + DummyEntity.class.getName());
    query.setCacheable(true);
    query.list();
    txn.commit();
    session.close();

    assertEquals(0, sf.getStatistics().getQueryCacheHitCount());
    assertEquals(2, sf.getStatistics().getQueryCacheMissCount());
  }
  public void testGetLoad() {
    clearCounts();

    Session s = openSession();
    Transaction tx = s.beginTransaction();
    Employer emp = new Employer();
    s.persist(emp);
    Node node = new Node("foo");
    Node parent = new Node("bar");
    parent.addChild(node);
    s.persist(parent);
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    emp = (Employer) s.get(Employer.class, emp.getId());
    assertTrue(Hibernate.isInitialized(emp));
    assertFalse(Hibernate.isInitialized(emp.getEmployees()));
    node = (Node) s.get(Node.class, node.getName());
    assertTrue(Hibernate.isInitialized(node));
    assertFalse(Hibernate.isInitialized(node.getChildren()));
    assertFalse(Hibernate.isInitialized(node.getParent()));
    assertNull(s.get(Node.class, "xyz"));
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    emp = (Employer) s.load(Employer.class, emp.getId());
    emp.getId();
    assertFalse(Hibernate.isInitialized(emp));
    node = (Node) s.load(Node.class, node.getName());
    assertEquals(node.getName(), "foo");
    assertFalse(Hibernate.isInitialized(node));
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    emp = (Employer) s.get("org.hibernate.ejb.test.ops.Employer", emp.getId());
    assertTrue(Hibernate.isInitialized(emp));
    node = (Node) s.get("org.hibernate.ejb.test.ops.Node", node.getName());
    assertTrue(Hibernate.isInitialized(node));
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    emp = (Employer) s.load("org.hibernate.ejb.test.ops.Employer", emp.getId());
    emp.getId();
    assertFalse(Hibernate.isInitialized(emp));
    node = (Node) s.load("org.hibernate.ejb.test.ops.Node", node.getName());
    assertEquals(node.getName(), "foo");
    assertFalse(Hibernate.isInitialized(node));
    tx.commit();
    s.close();

    assertFetchCount(0);
  }
  @Test
  public void testProjectedValueGetsConvertedToNull() throws Exception {
    ProgrammaticConfiguredValue nullValue = new ProgrammaticConfiguredValue(null);

    FullTextSession fullTextSession = Search.getFullTextSession(openSession());
    Transaction tx = fullTextSession.beginTransaction();
    getSession().save(nullValue);
    tx.commit();

    fullTextSession.clear();
    tx = fullTextSession.beginTransaction();

    Query query = new MatchAllDocsQuery();
    FullTextQuery fullTextQuery =
        fullTextSession.createFullTextQuery(query, ProgrammaticConfiguredValue.class);
    fullTextQuery.setProjection("id", "value");
    fullTextQuery.setResultTransformer(new ProjectionToMapResultTransformer());
    List<?> mappedResults = fullTextQuery.list();
    assertTrue("Wrong result size", mappedResults.size() == 1);

    Map<?, ?> map = (Map<?, ?>) mappedResults.get(0);
    Integer id = (Integer) map.get("id");
    assertNotNull(id);

    String value = (String) map.get("value");
    assertEquals("The null token should be converted back to null", null, value);

    tx.commit();
    fullTextSession.close();
  }
Exemple #15
0
  @Test
  public void testOrderedListAndCompositeId() throws Exception {
    Session session = openSession();
    Transaction transaction = session.beginTransaction();
    Race race = new Race();
    race.setRaceId(new Race.RaceId(23, 75));
    Runner runner = new Runner();
    runner.setAge(37);
    runner.setRunnerId(new Runner.RunnerId("Emmanuel", "Bernard"));
    Runner runner2 = new Runner();
    runner2.setAge(105);
    runner2.setRunnerId(new Runner.RunnerId("Pere", "Noel"));
    race.getRunnersByArrival().add(runner);
    race.getRunnersByArrival().add(runner2);
    session.persist(race);
    session.persist(runner);
    session.persist(runner2);
    transaction.commit();

    session.clear();

    transaction = session.beginTransaction();
    race = (Race) session.get(Race.class, race.getRaceId());
    assertThat(race.getRunnersByArrival()).hasSize(2);
    assertThat(race.getRunnersByArrival().get(0).getRunnerId().getFirstname())
        .isEqualTo("Emmanuel");
    session.delete(race.getRunnersByArrival().get(0));
    session.delete(race.getRunnersByArrival().get(1));
    session.delete(race);
    transaction.commit();

    session.close();
    checkCleanCache();
  }
  public void testUnconstrained() {
    Session session = openSession();
    Transaction tx = session.beginTransaction();
    Person p = new Person("gavin");
    p.setEmployeeId("123456");
    session.persist(p);
    tx.commit();
    session.close();

    session = openSession();
    tx = session.beginTransaction();
    p = (Person) session.get(Person.class, "gavin");
    assertNull(p.getEmployee());
    p.setEmployee(new Employee("123456"));
    tx.commit();
    session.close();

    session = openSession();
    tx = session.beginTransaction();
    p = (Person) session.get(Person.class, "gavin");
    assertTrue(Hibernate.isInitialized(p.getEmployee()));
    assertNotNull(p.getEmployee());
    session.delete(p);
    tx.commit();
    session.close();
  }
  public void testSQLQueryInterface() {
    Session s = openSession();
    Transaction t = s.beginTransaction();
    Organization ifa = new Organization("IFA");
    Organization jboss = new Organization("JBoss");
    Person gavin = new Person("Gavin");
    Employment emp = new Employment(gavin, jboss, "AU");

    s.persist(ifa);
    s.persist(jboss);
    s.persist(gavin);
    s.persist(emp);

    List l =
        s.createSQLQuery(getOrgEmpRegionSQL())
            .addEntity("org", Organization.class)
            .addJoin("emp", "org.employments")
            .addScalar("regionCode", Hibernate.STRING)
            .list();
    assertEquals(2, l.size());

    l =
        s.createSQLQuery(getOrgEmpPersonSQL())
            .addEntity("org", Organization.class)
            .addJoin("emp", "org.employments")
            .addJoin("pers", "emp.employee")
            .list();
    assertEquals(l.size(), 1);

    t.commit();
    s.close();

    s = openSession();
    t = s.beginTransaction();

    l =
        s.createSQLQuery(
                "select {org.*}, {emp.*} "
                    + "from ORGANIZATION org "
                    + "     left outer join EMPLOYMENT emp on org.ORGID = emp.EMPLOYER, ORGANIZATION org2")
            .addEntity("org", Organization.class)
            .addJoin("emp", "org.employments")
            .setResultTransformer(DistinctRootEntityResultTransformer.INSTANCE)
            .list();
    assertEquals(l.size(), 2);

    t.commit();
    s.close();

    s = openSession();
    t = s.beginTransaction();

    s.delete(emp);
    s.delete(gavin);
    s.delete(ifa);
    s.delete(jboss);

    t.commit();
    s.close();
  }
  @Test
  public void testDeclaredValues() {
    Session s;
    Transaction tx;
    s = openSession();
    tx = s.beginTransaction();
    Country c = new Country();
    c.setName("France");
    AmericaCupClass f = new AmericaCupClass();
    f.setSize(2);
    f.setCountry(c);
    s.persist(c);
    s.persist(f);
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    f = (AmericaCupClass) s.get(AmericaCupClass.class, f.getId());
    assertNotNull(f);
    assertEquals(c, f.getCountry());
    assertEquals(2, f.getSize());
    s.delete(f);
    s.delete(f.getCountry());
    tx.commit();
    s.close();
  }
  /** The ejb3 find() method maps to the Hibernate get() method */
  public void testGetSemantics() {
    Long nonExistentId = new Long(-1);
    Session s = openSession();
    Transaction txn = s.beginTransaction();
    Item item = (Item) s.get(Item.class, nonExistentId);
    assertNull("get() of non-existent entity did not return null", item);
    txn.commit();
    s.close();

    s = openSession();
    txn = s.beginTransaction();
    // first load() it to generate a proxy...
    item = (Item) s.load(Item.class, nonExistentId);
    assertFalse(Hibernate.isInitialized(item));
    // then try to get() it to make sure we get an exception
    try {
      s.get(Item.class, nonExistentId);
      fail("force load did not fail on non-existent entity");
    } catch (EntityNotFoundException e) {
      // expected behavior
    } catch (AssertionFailedError e) {
      throw e;
    } catch (Throwable t) {
      fail("unexpected exception type on non-existent entity force load : " + t);
    }
    txn.commit();
    s.close();
  }
  @Test
  public void testCompositePk() throws Exception {
    Session s;
    Transaction tx;
    s = openSession();
    tx = s.beginTransaction();
    Carrot c = new Carrot();
    VegetablePk pk = new VegetablePk();
    pk.setFarmer("Bill");
    pk.setHarvestDate("2004-08-15");
    c.setId(pk);
    c.setLength(23);
    s.persist(c);
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    Vegetable v = (Vegetable) s.createCriteria(Vegetable.class).uniqueResult();
    assertTrue(v instanceof Carrot);
    Carrot result = (Carrot) v;
    assertEquals(23, result.getLength());
    tx.commit();
    s.close();
  }
  @Test
  public void testInsertWithMismatchedTypes() {
    TestData data = new TestData();
    data.prepare();

    Session s = openSession();
    Transaction t = s.beginTransaction();
    try {
      s.createQuery("insert into Pickup (owner, vin, id) select id, vin, owner from Car")
          .executeUpdate();
      fail("mismatched types did not error");
    } catch (QueryException e) {
      // expected result
    }

    t.commit();
    t = s.beginTransaction();

    s.createQuery("delete Vehicle").executeUpdate();

    t.commit();
    s.close();

    data.cleanup();
  }
  @Test
  public void testAnalyzerDef() throws Exception {
    Address address = new Address();
    address.setStreet1("3340 Peachtree Rd NE");
    address.setStreet2("JBoss");

    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();
    s.persist(address);
    tx.commit();

    s.clear();

    tx = s.beginTransaction();

    QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer);
    org.apache.lucene.search.Query luceneQuery = parser.parse("street1_ngram:pea");

    final FullTextQuery query = s.createFullTextQuery(luceneQuery);
    assertEquals("Analyzer inoperant", 1, query.getResultSize());

    s.delete(query.list().get(0));
    tx.commit();
    s.close();
  }
  @Test
  public void testInsertAcrossMappedJoinFails() {
    TestData data = new TestData();
    data.prepare();

    Session s = openSession();
    Transaction t = s.beginTransaction();

    try {
      s.createQuery("insert into Joiner (name, joinedName) select vin, owner from Car")
          .executeUpdate();
      fail("mapped-join insertion did not error");
    } catch (QueryException e) {
      // expected result
    }

    t.commit();
    t = s.beginTransaction();

    s.createQuery("delete Joiner").executeUpdate();
    s.createQuery("delete Vehicle").executeUpdate();

    t.commit();
    s.close();

    data.cleanup();
  }
  @Test
  public void testBridgeMapping() throws Exception {
    Address address = new Address();
    address.setStreet1("Peachtree Rd NE");
    address.setStreet2("JBoss");

    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();
    s.persist(address);
    tx.commit();

    s.clear();

    tx = s.beginTransaction();

    QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer);
    org.apache.lucene.search.Query luceneQuery = parser.parse("street1:peac");
    FullTextQuery query = s.createFullTextQuery(luceneQuery);
    assertEquals("PrefixQuery should not be on", 0, query.getResultSize());

    luceneQuery = parser.parse("street1_abridged:peac");
    query = s.createFullTextQuery(luceneQuery);
    assertEquals("Bridge not used", 1, query.getResultSize());

    s.delete(query.list().get(0));
    tx.commit();
    s.close();
  }
  @Test
  public void testIncrementTimestampVersion() {
    Session s = openSession();
    Transaction t = s.beginTransaction();

    TimestampVersioned entity = new TimestampVersioned("ts-vers");
    s.save(entity);
    t.commit();
    s.close();

    Date initialVersion = entity.getVersion();

    synchronized (this) {
      try {
        wait(1500);
      } catch (InterruptedException ie) {
      }
    }

    s = openSession();
    t = s.beginTransaction();
    int count =
        s.createQuery("update versioned TimestampVersioned set name = name").executeUpdate();
    assertEquals("incorrect exec count", 1, count);
    t.commit();

    t = s.beginTransaction();
    entity = (TimestampVersioned) s.load(TimestampVersioned.class, entity.getId());
    assertTrue("version not incremented", entity.getVersion().after(initialVersion));

    s.delete(entity);
    t.commit();
    s.close();
  }
  @Test
  public void testMapping() throws Exception {
    Address address = new Address();
    address.setStreet1("3340 Peachtree Rd NE");
    address.setStreet2("JBoss");

    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();
    s.persist(address);
    tx.commit();

    s.clear();

    tx = s.beginTransaction();

    QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer);
    org.apache.lucene.search.Query luceneQuery = parser.parse("" + address.getAddressId());
    FullTextQuery query = s.createFullTextQuery(luceneQuery);
    assertEquals("documentId does not work properly", 1, query.getResultSize());

    luceneQuery = parser.parse("street1:peachtree");
    query = s.createFullTextQuery(luceneQuery).setProjection("idx_street2", FullTextQuery.THIS);
    assertEquals("Not properly indexed", 1, query.getResultSize());
    Object[] firstResult = (Object[]) query.list().get(0);
    assertEquals("@Field.store not respected", "JBoss", firstResult[0]);

    // Verify that AddressClassBridge was applied as well:
    luceneQuery = parser.parse("AddressClassBridge:Applied\\!");
    assertEquals(1, s.createFullTextQuery(luceneQuery).getResultSize());

    s.delete(firstResult[1]);
    tx.commit();
    s.close();
  }
  /**
   * Tests that @DocumentId can be specified on a field other than the @Id annotated one. See
   * HSEARCH-574.
   *
   * @throws Exception in case the test fails.
   */
  @Test
  public void testExplicitDocumentIdMultipleResults() throws Exception {
    Article hello = new Article();
    hello.setDocumentId(1);
    hello.setText("Hello World");

    Article goodbye = new Article();
    goodbye.setDocumentId(2);
    goodbye.setText("Goodbye World");

    Session s = openSession();
    Transaction tx = s.beginTransaction();
    s.save(hello);
    s.save(goodbye);
    tx.commit();
    s.clear();

    tx = s.beginTransaction();
    List results =
        Search.getFullTextSession(s)
            .createFullTextQuery(new TermQuery(new Term("text", "world")))
            .list();
    assertEquals(2, results.size());
    tx.commit();
    s.close();
  }
  @Test
  public void testClassBridgeInstanceMapping() throws Exception {
    OrderLine orderLine = new OrderLine();
    orderLine.setName("Sequoia");

    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();
    s.persist(orderLine);
    tx.commit();

    s.clear();

    tx = s.beginTransaction();

    QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer);
    org.apache.lucene.search.Query luceneQuery = parser.parse("orderLineName:Sequoia");
    FullTextQuery query = s.createFullTextQuery(luceneQuery);
    assertEquals("Bridge not used", 1, query.getResultSize());

    luceneQuery = parser.parse("orderLineName_ngram:quo");
    query = s.createFullTextQuery(luceneQuery);
    assertEquals("Analyzer configuration not applied", 1, query.getResultSize());

    luceneQuery = parser.parse("orderLineNameViaParam:Sequoia");
    query = s.createFullTextQuery(luceneQuery);
    assertEquals("Parameter configuration not applied", 1, query.getResultSize());

    s.delete(query.list().get(0));
    tx.commit();
    s.close();
  }
  public void testDefaultConfigurationModeIsInherited() throws Exception {
    User john = new User();
    john.setFirstname("John");
    john.setLastname("Doe");
    List<User> friends = new ArrayList<User>();
    User friend = new User();
    friend.setFirstname("Jane");
    friend.setLastname("Doe");
    friends.add(friend);
    john.setFriends(friends);

    Session s = openSession();
    s.persist(john);
    Transaction tx = s.beginTransaction();
    tx.commit();
    s.clear();
    tx = s.beginTransaction();
    john = (User) s.get(User.class, john.getId());
    assertEquals("Wrong number of friends", 1, john.getFriends().size());
    assertNull(john.firstname);

    s.delete(john);
    tx.commit();
    s.close();
  }
  @Test(groups = "ch04")
  public void testEmbedded() throws Exception {
    Session session = factory.openSession();
    Item item = new Item();
    item.setDescription("Great DVD");
    item.setEan("123456789012");
    item.setTitle("Great DVD");
    item.setRating(new Rating());
    item.getRating().setOverall(5);
    item.getRating().setPicture(4);
    item.getRating().setScenario(5);
    item.getRating().setSoundtrack(3);
    Transaction tx = session.beginTransaction();
    session.save(item);
    tx.commit();

    session.clear();

    tx = session.beginTransaction();
    FullTextSession fts = Search.getFullTextSession(session);
    List results =
        fts.createFullTextQuery(new TermQuery(new Term("rating.overall", "5")), Item.class).list();
    assert results.size() == 1;
    fts.delete(results.get(0));
    tx.commit();
    fts.close();
  }