getSessions().getStatistics().clear(); Session s = openSession(); Transaction t = s.beginTransaction(); Item i1 = new Item("foo"); Item i2 = new Item("bar"); s.persist("Item", i1); s.persist("Item", i2); t.commit(); s.close(); s = openSession(); t = s.beginTransaction(); Iterator iter = s.getNamedQuery("Item.nameDesc").iterate(); i1 = (Item) iter.next(); i2 = (Item) iter.next(); assertFalse( Hibernate.isInitialized(i1) ); assertFalse( Hibernate.isInitialized(i2) ); i1.getName(); i2.getName(); assertFalse( Hibernate.isInitialized(i1) ); assertFalse( Hibernate.isInitialized(i2) ); assertEquals( i1.getName(), "foo" ); assertEquals( i2.getName(), "bar" ); Hibernate.initialize(i1); assertFalse( iter.hasNext() ); s.delete(i1); s.delete(i2); t.commit(); s.close(); assertEquals( getSessions().getStatistics().getEntityFetchCount(), 2 );
Session s = openSession(); Transaction tx = s.beginTransaction(); NumberedNode root = new NumberedNode( "root" ); root.addChild( new NumberedNode( "child" ) ); s.persist(root); tx.commit(); s.close(); clearCounts(); NumberedNode newRoot = new NumberedNode( "root" ); newRoot.setId( root.getId() ); s = openSession(); tx = s.beginTransaction(); root = ( NumberedNode ) s.get( NumberedNode.class, root.getId() ); Set managedChildren = root.getChildren(); Hibernate.initialize( managedChildren ); assertTrue( Hibernate.isInitialized( managedChildren ) ); newRoot.setChildren( managedChildren ); assertSame( root, s.merge( newRoot ) ); assertSame( managedChildren, root.getChildren() ); assertTrue( Hibernate.isInitialized( managedChildren ) ); tx.commit(); assertInsertCount(0); assertUpdateCount(0); assertDeleteCount(0); tx = s.beginTransaction(); assertEquals( s.createCriteria(NumberedNode.class) .setProjection( Projections.rowCount() ) .uniqueResult(), new Integer(2) ); tx.commit(); s.close(); cleanup();
Clone fragments detected by clone detection tool
File path: /hibernate-distribution-3.3.2.GA/project/testsuite/src/test/java/org/hibernate/test/iterate/IterateTest.java File path: /hibernate-distribution-3.3.2.GA/project/testsuite/src/test/java/org/hibernate/test/ops/MergeTest.java
Method name: void testIterate() Method name: void testMergeManagedInitializedCollection()
Number of AST nodes: 29 Number of AST nodes: 29
1
getSessions().getStatistics().clear();
2
		Session s = openSession();
1
Session s = openSession();
3
		Transaction t = s.beginTransaction();
2
		Transaction tx = s.beginTransaction();
4
		Item i1 = new Item("foo");
3
		
5
		Item i2 = new Item("bar");
6
		s.persist("Item", i1
4
NumberedNode root = new NumberedNode( "root" );
7
);
5
		root.addChild( new NumberedNode( "child" ) );
8
		s.persist("Item", i2);
6
		s.persist(root);
9
		t.commit();
7
		tx.commit();
10
		s.close();
8
		s.close();
9
		clearCounts();
10
		NumberedNode newRoot = new NumberedNode( "root" );
11
		newRoot.setId( root.getId() );
11
		s = openSession();
12
		s = openSession();
12
		t = s.beginTransaction();
13
		tx = s.beginTransaction();
13
		Iterator iter = s.getNamedQuery("Item.nameDesc").iterate();
14
		
14
		i1 = (Item) iter.next();
15
		i2 = (Item) iter.next();
16
		assertFalse( 
15
root = ( NumberedNode ) s.get( NumberedNode.class, root.getId() );
16
		Set managedChildren = root.getChildren();
17
Hibernate.isInitialized(i1) );
17
		Hibernate.initialize( managedChildren );
18
		assertFalse( Hibernate.isInitialized(i2) );
18
		assertTrue( Hibernate.isInitialized(
19
		i1.getName();
20
		i2.getName();
21
		assertFalse( Hibernate.isInitialized(i1
19
 managedChildren ) );
20
		newRoot.setChildren( managedChildren );
21
		assertSame( root, s.merge( newRoot ) );
22
) );
22
		assertSame( managedChildren, root.getChildren() );
23
		assertFalse( Hibernate.isInitialized(i2) );
23
		assertTrue( Hibernate.isInitialized(
24
		assertEquals( i1.getName(), "foo" );
25
		assertEquals( i2.getName(), "bar" 
24
 managedChildren ) );
25
		tx.commit();
26
		assertInsertCount(0);
27
		assertUpdateCount(0);
26
);
28
		assertDeleteCount(0);
27
		Hibernate.initialize(i1);
29
		tx = s.beginTransaction();
28
		assertFalse( iter.hasNex
30
		assertEquals(
31
			s.createCriteria(NumberedNode.class)
29
t() );
32
				.setProjection( Projections.rowCount() )
30
		s.delete(i1);
31
		s.delete(i2
33
				.uniqueResult(),
34
			new Integer(2)
32
);
35
		);
33
		t.commit();
36
		tx.commit();
34
		s.close();
37
		s.close();
35
		assertEquals( getSessions().getStatistics().getEntityFetchCount(), 2 );
38
		cleanup();
Summary
Number of common nesting structure subtrees1
Number of refactorable cases0
Number of non-refactorable cases1
Time elapsed for finding largest common nesting structure subtrees (ms)0.0
Clones locationClones are in different classes having the same super class
Number of node comparisons604
  1. {Non-refactorable}
    Mapping Summary
    Number of mapped statements15
    Number of unmapped statements in the first code fragment14
    Number of unmapped statements in the second code fragment14
    Time elapsed for statement mapping (ms)0.0
    Clone typeType 2
    Mapped Statements
    ID Statement ID Statement
    1
    getSessions().getStatistics().clear();
    1
    getSessions().getStatistics().clear();
    29
    cleanup();
    Differences
    Expression1Expression2Difference
    clearcleanupMETHOD_INVOCATION_NAME_MISMATCH
    getSessions().getStatistics()MISSING_METHOD_INVOCATION_EXPRESSION
    Preondition Violations
    Expression getSessions().getStatistics().clear() is a void method call, and thus it cannot be parameterized
    Expression cleanup() is a void method call, and thus it cannot be parameterized
    Expression getSessions().getStatistics().clear() is a void method call, and thus it cannot be parameterized
    Expression cleanup() is a void method call, and thus it cannot be parameterized
    29
    cleanup();
    2
    Session s = openSession();
    1
    Session s = openSession();
    3
    Transaction t = s.beginTransaction();
    3
    Transaction t = s.beginTransaction();
    2
    Transaction tx = s.beginTransaction();
    Differences
    Expression1Expression2Difference
    ttxVARIABLE_NAME_MISMATCH
    2
    Transaction tx = s.beginTransaction();
                                                                                                
    3
    NumberedNode root = new NumberedNode("root");
    Preondition Violations
    Unmatched statement NumberedNode root=new NumberedNode("root"); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    3
    NumberedNode root = new NumberedNode("root");
                                                                                            
    4
    root.addChild(new NumberedNode("child"));
    4
    Item i1 = new Item("foo");
    4
    Item i1 = new Item("foo");
    Preondition Violations
    Unmatched statement Item i1=new Item("foo"); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
                                                          
    5
    Item i2 = new Item("bar");
    5
    Item i2 = new Item("bar");
    Preondition Violations
    Unmatched statement Item i2=new Item("bar"); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
                                                          
    6
    s.persist("Item", i1);
    6
    s.persist("Item", i1);
    5
    s.persist(root);
    Differences
    Expression1Expression2Difference
    s.persist("Item",i1)s.persist(root)ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression s.persist("Item",i1) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression s.persist(root) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression s.persist("Item",i1) is a void method call, and thus it cannot be parameterized
    Expression s.persist(root) is a void method call, and thus it cannot be parameterized
    5
    s.persist(root);
    7
    s.persist("Item", i2);
    7
    s.persist("Item", i2);
    Preondition Violations
    Unmatched statement s.persist("Item",i2); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                    
    8
    t.commit();
    8
    t.commit();
    6
    tx.commit();
    Differences
    Expression1Expression2Difference
    ttxVARIABLE_NAME_MISMATCH
    6
    tx.commit();
    9
    s.close();
    7
    s.close();
                                                                                                      
    9
    NumberedNode newRoot = new NumberedNode("root");
    Preondition Violations
    Unmatched statement NumberedNode newRoot=new NumberedNode("root"); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    9
    NumberedNode newRoot = new NumberedNode("root");
                                                                    
    10
    newRoot.setId(root.getId());
    Preondition Violations
    Unmatched statement newRoot.setId(root.getId()); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    10
    newRoot.setId(root.getId());
    10
    s = openSession();
    11
    s = openSession();
    11
    t = s.beginTransaction();
    11
    t = s.beginTransaction();
    12
    tx = s.beginTransaction();
    Differences
    Expression1Expression2Difference
    ttxVARIABLE_NAME_MISMATCH
    12
    tx = s.beginTransaction();
    12
    Iterator iter = s.getNamedQuery("Item.nameDesc").iterate();
    12
    Iterator iter = s.getNamedQuery("Item.nameDesc").iterate();
    Preondition Violations
    Unmatched statement Iterator iter=s.getNamedQuery("Item.nameDesc").iterate(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                                                                                              
                                                                                                                                
    13
    root = (NumberedNode)s.get(NumberedNode.class, root.getId());
    Preondition Violations
    Unmatched statement root=(NumberedNode)s.get(NumberedNode.class,root.getId()); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    13
    root = (NumberedNode)s.get(NumberedNode.class, root.getId());
    13
    i1 = (Item)iter.next();
    13
    i1 = (Item)iter.next();
    Preondition Violations
    Unmatched statement i1=(Item)iter.next(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                      
                                                                                          
    14
    Set managedChildren = root.getChildren();
    14
    i2 = (Item)iter.next();
                                                      
                                                                                      
    17
    newRoot.setChildren(managedChildren);
    Preondition Violations
    Unmatched statement newRoot.setChildren(managedChildren); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    17
    newRoot.setChildren(managedChildren);
                                                                                
    18
    assertSame(root, s.merge(newRoot));
    Preondition Violations
    Unmatched statement assertSame(root,s.merge(newRoot)); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    18
    assertSame(root, s.merge(newRoot));
    15
    assertFalse(Hibernate.isInitialized(i1));
    15
    assertFalse(Hibernate.isInitialized(i1));
    19
    assertSame(managedChildren, root.getChildren());
    Differences
    Expression1Expression2Difference
    assertFalseassertSameMETHOD_INVOCATION_NAME_MISMATCH
    assertFalse(Hibernate.isInitialized(i1))assertSame(managedChildren,root.getChildren())ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression assertFalse(Hibernate.isInitialized(i1)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertSame(managedChildren,root.getChildren()) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertFalse(Hibernate.isInitialized(i1)) is a void method call, and thus it cannot be parameterized
    Expression assertSame(managedChildren,root.getChildren()) is a void method call, and thus it cannot be parameterized
    Expression assertFalse(Hibernate.isInitialized(i1)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertSame(managedChildren,root.getChildren()) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertFalse(Hibernate.isInitialized(i1)) is a void method call, and thus it cannot be parameterized
    Expression assertSame(managedChildren,root.getChildren()) is a void method call, and thus it cannot be parameterized
    19
    assertSame(managedChildren, root.getChildren());
    16
    assertFalse(Hibernate.isInitialized(i2));
                                                                                              
    17
    i1.getName();
                                      
    18
    i2.getName();
                                      
    19
    assertFalse(Hibernate.isInitialized(i1));
                                                                                              
    20
    assertFalse(Hibernate.isInitialized(i2));
                                                                                              
    21
    assertEquals(i1.getName(), "foo");
    21
    assertEquals(i1.getName(), "foo");
    20
    assertTrue(Hibernate.isInitialized(managedChildren));
    Differences
    Expression1Expression2Difference
    assertEqualsassertTrueMETHOD_INVOCATION_NAME_MISMATCH
    assertEquals(i1.getName(),"foo")assertTrue(Hibernate.isInitialized(managedChildren))ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression assertEquals(i1.getName(),"foo") cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertTrue(Hibernate.isInitialized(managedChildren)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertEquals(i1.getName(),"foo") is a void method call, and thus it cannot be parameterized
    Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    Expression assertEquals(i1.getName(),"foo") cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertTrue(Hibernate.isInitialized(managedChildren)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertEquals(i1.getName(),"foo") is a void method call, and thus it cannot be parameterized
    Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    20
    assertTrue(Hibernate.isInitialized(managedChildren));
    22
    assertEquals(i2.getName(), "bar");
    22
    assertEquals(i2.getName(), "bar");
    16
    assertTrue(Hibernate.isInitialized(managedChildren));
    Differences
    Expression1Expression2Difference
    assertEqualsassertTrueMETHOD_INVOCATION_NAME_MISMATCH
    assertEquals(i2.getName(),"bar")assertTrue(Hibernate.isInitialized(managedChildren))ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression assertEquals(i2.getName(),"bar") cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertTrue(Hibernate.isInitialized(managedChildren)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertEquals(i2.getName(),"bar") is a void method call, and thus it cannot be parameterized
    Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    Expression assertEquals(i2.getName(),"bar") cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertTrue(Hibernate.isInitialized(managedChildren)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertEquals(i2.getName(),"bar") is a void method call, and thus it cannot be parameterized
    Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    16
    assertTrue(Hibernate.isInitialized(managedChildren));
    23
    Hibernate.initialize(i1);
    23
    Hibernate.initialize(i1);
    15
    Hibernate.initialize(managedChildren);
    Differences
    Expression1Expression2Difference
    i1managedChildrenVARIABLE_NAME_MISMATCH
    org.hibernate.test.iterate.Itemjava.util.SetVARIABLE_TYPE_MISMATCH
    Preondition Violations
    Type org.hibernate.test.iterate.Item of variable i1 does not match with type java.util.Set of variable managedChildren
    • Make classes org.hibernate.test.iterate.Item and java.util.Set extend a common superclass
    15
    Hibernate.initialize(managedChildren);
    24
    assertFalse(iter.hasNext());
                                                                    
    25
    s.delete(i1);
    25
    s.delete(i1);
    Preondition Violations
    Unmatched statement s.delete(i1); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                      
    26
    s.delete(i2);
    26
    s.delete(i2);
    Preondition Violations
    Unmatched statement s.delete(i2); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                      
    27
    t.commit();
    27
    t.commit();
    21
    tx.commit();
    Differences
    Expression1Expression2Difference
    ttxVARIABLE_NAME_MISMATCH
    21
    tx.commit();
                                                      
    22
    assertInsertCount(0);
                                                      
    23
    assertUpdateCount(0);
                                                      
    24
    assertDeleteCount(0);
                                                            
    25
    tx = s.beginTransaction();
    Preondition Violations
    Unmatched statement tx=s.beginTransaction(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    25
    tx = s.beginTransaction();
                                                                                                                                                                                                                                                          
    26
    assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(), new Integer(2));
    Preondition Violations
    Unmatched statement assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2)); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    26
    assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(), new Integer(2));
                                    
    27
    tx.commit();
    Preondition Violations
    Unmatched statement tx.commit(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    27
    tx.commit();
    28
    s.close();
    28
    s.close();
    29
    assertEquals(getSessions().getStatistics().getEntityFetchCount(), 2);
    29
    assertEquals(getSessions().getStatistics().getEntityFetchCount(), 2);
    8
    clearCounts();
    Differences
    Expression1Expression2Difference
    assertEqualsclearCountsMETHOD_INVOCATION_NAME_MISMATCH
    assertEquals(getSessions().getStatistics().getEntityFetchCount(),2)clearCounts()TYPE_COMPATIBLE_REPLACEMENT
    assertEquals(getSessions().getStatistics().getEntityFetchCount(),2)clearCounts()ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression assertEquals(getSessions().getStatistics().getEntityFetchCount(),2) is a void method call, and thus it cannot be parameterized
    Expression clearCounts() is a void method call, and thus it cannot be parameterized
    Expression assertEquals(getSessions().getStatistics().getEntityFetchCount(),2) is a void method call, and thus it cannot be parameterized
    Expression clearCounts() is a void method call, and thus it cannot be parameterized
    8
    clearCounts();
    Precondition Violations (53)
    Row Violation
    1Expression getSessions().getStatistics().clear() is a void method call, and thus it cannot be parameterized
    2Expression cleanup() is a void method call, and thus it cannot be parameterized
    3Expression getSessions().getStatistics().clear() is a void method call, and thus it cannot be parameterized
    4Expression cleanup() is a void method call, and thus it cannot be parameterized
    5Unmatched statement NumberedNode root=new NumberedNode("root"); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    6Unmatched statement Item i1=new Item("foo"); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    7Unmatched statement Item i2=new Item("bar"); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    8Expression s.persist("Item",i1) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    9Expression s.persist(root) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    10Expression s.persist("Item",i1) is a void method call, and thus it cannot be parameterized
    11Expression s.persist(root) is a void method call, and thus it cannot be parameterized
    12Unmatched statement s.persist("Item",i2); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    13Unmatched statement NumberedNode newRoot=new NumberedNode("root"); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    14Unmatched statement newRoot.setId(root.getId()); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    15Unmatched statement Iterator iter=s.getNamedQuery("Item.nameDesc").iterate(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    16Unmatched statement root=(NumberedNode)s.get(NumberedNode.class,root.getId()); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    17Unmatched statement i1=(Item)iter.next(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    18Unmatched statement newRoot.setChildren(managedChildren); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    19Unmatched statement assertSame(root,s.merge(newRoot)); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    20Expression assertFalse(Hibernate.isInitialized(i1)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    21Expression assertSame(managedChildren,root.getChildren()) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    22Expression assertFalse(Hibernate.isInitialized(i1)) is a void method call, and thus it cannot be parameterized
    23Expression assertSame(managedChildren,root.getChildren()) is a void method call, and thus it cannot be parameterized
    24Expression assertFalse(Hibernate.isInitialized(i1)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    25Expression assertSame(managedChildren,root.getChildren()) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    26Expression assertFalse(Hibernate.isInitialized(i1)) is a void method call, and thus it cannot be parameterized
    27Expression assertSame(managedChildren,root.getChildren()) is a void method call, and thus it cannot be parameterized
    28Expression assertEquals(i1.getName(),"foo") cannot be parameterized, because it has dependencies to/from statements that will be extracted
    29Expression assertTrue(Hibernate.isInitialized(managedChildren)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    30Expression assertEquals(i1.getName(),"foo") is a void method call, and thus it cannot be parameterized
    31Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    32Expression assertEquals(i1.getName(),"foo") cannot be parameterized, because it has dependencies to/from statements that will be extracted
    33Expression assertTrue(Hibernate.isInitialized(managedChildren)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    34Expression assertEquals(i1.getName(),"foo") is a void method call, and thus it cannot be parameterized
    35Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    36Expression assertEquals(i2.getName(),"bar") cannot be parameterized, because it has dependencies to/from statements that will be extracted
    37Expression assertTrue(Hibernate.isInitialized(managedChildren)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    38Expression assertEquals(i2.getName(),"bar") is a void method call, and thus it cannot be parameterized
    39Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    40Expression assertEquals(i2.getName(),"bar") cannot be parameterized, because it has dependencies to/from statements that will be extracted
    41Expression assertTrue(Hibernate.isInitialized(managedChildren)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    42Expression assertEquals(i2.getName(),"bar") is a void method call, and thus it cannot be parameterized
    43Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    44Type org.hibernate.test.iterate.Item of variable i1 does not match with type java.util.Set of variable managedChildren
    45Unmatched statement s.delete(i1); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    46Unmatched statement s.delete(i2); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    47Unmatched statement tx=s.beginTransaction(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    48Unmatched statement assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2)); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    49Unmatched statement tx.commit(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    50Expression assertEquals(getSessions().getStatistics().getEntityFetchCount(),2) is a void method call, and thus it cannot be parameterized
    51Expression clearCounts() is a void method call, and thus it cannot be parameterized
    52Expression assertEquals(getSessions().getStatistics().getEntityFetchCount(),2) is a void method call, and thus it cannot be parameterized
    53Expression clearCounts() is a void method call, and thus it cannot be parameterized