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 statements20
    Number of unmapped statements in the first code fragment9
    Number of unmapped statements in the second code fragment9
    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();
    8
    clearCounts();
    Differences
    Expression1Expression2Difference
    clearclearCountsMETHOD_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 clearCounts() 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 clearCounts() is a void method call, and thus it cannot be parameterized
    8
    clearCounts();
    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");
                                                                                            
    4
    root.addChild(new NumberedNode("child"));
    4
    Item i1 = new Item("foo");
                                                          
    5
    Item i2 = new Item("bar");
                                                          
    6
    s.persist("Item", i1);
    6
    s.persist("Item", i1);
    22
    assertInsertCount(0);
    Differences
    Expression1Expression2Difference
    persistassertInsertCountMETHOD_INVOCATION_NAME_MISMATCH
    s.persist("Item",i1)assertInsertCount(0)ARGUMENT_NUMBER_MISMATCH
    sMISSING_METHOD_INVOCATION_EXPRESSION
    Preondition Violations
    Expression s.persist("Item",i1) 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 assertInsertCount(0) is a void method call, and thus it cannot be parameterized
    Expression s.persist("Item",i1) 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 assertInsertCount(0) is a void method call, and thus it cannot be parameterized
    22
    assertInsertCount(0);
    7
    s.persist("Item", i2);
    7
    s.persist("Item", i2);
    5
    s.persist(root);
    Differences
    Expression1Expression2Difference
    s.persist("Item",i2)s.persist(root)ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression s.persist("Item",i2) 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",i2) 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);
    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");
                                                                    
    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();
    14
    i2 = (Item)iter.next();
    Preondition Violations
    Unmatched statement i2=(Item)iter.next(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                      
                                                                                      
    17
    newRoot.setChildren(managedChildren);
    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)) 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)) 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));
    16
    assertFalse(Hibernate.isInitialized(i2));
    18
    assertSame(root, s.merge(newRoot));
    Differences
    Expression1Expression2Difference
    assertFalseassertSameMETHOD_INVOCATION_NAME_MISMATCH
    assertFalse(Hibernate.isInitialized(i2))assertSame(root,s.merge(newRoot))ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression assertSame(root,s.merge(newRoot)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertFalse(Hibernate.isInitialized(i2)) is a void method call, and thus it cannot be parameterized
    Expression assertSame(root,s.merge(newRoot)) is a void method call, and thus it cannot be parameterized
    Expression assertSame(root,s.merge(newRoot)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertFalse(Hibernate.isInitialized(i2)) is a void method call, and thus it cannot be parameterized
    Expression assertSame(root,s.merge(newRoot)) is a void method call, and thus it cannot be parameterized
    18
    assertSame(root, s.merge(newRoot));
    17
    i1.getName();
                                      
    18
    i2.getName();
                                      
    19
    assertFalse(Hibernate.isInitialized(i1));
    19
    assertFalse(Hibernate.isInitialized(i1));
    29
    cleanup();
    Differences
    Expression1Expression2Difference
    assertFalsecleanupMETHOD_INVOCATION_NAME_MISMATCH
    assertFalse(Hibernate.isInitialized(i1))cleanup()ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression assertFalse(Hibernate.isInitialized(i1)) 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 assertFalse(Hibernate.isInitialized(i1)) 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();
    20
    assertFalse(Hibernate.isInitialized(i2));
    20
    assertFalse(Hibernate.isInitialized(i2));
    26
    assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(), new Integer(2));
    Differences
    Expression1Expression2Difference
    assertFalseassertEqualsMETHOD_INVOCATION_NAME_MISMATCH
    assertFalse(Hibernate.isInitialized(i2))assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2))ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertFalse(Hibernate.isInitialized(i2)) is a void method call, and thus it cannot be parameterized
    Expression assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2)) is a void method call, and thus it cannot be parameterized
    Expression assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertFalse(Hibernate.isInitialized(i2)) is a void method call, and thus it cannot be parameterized
    Expression assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2)) is a void method call, and thus it cannot be parameterized
    26
    assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(), new Integer(2));
    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") 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") 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") 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") 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());
    24
    assertFalse(iter.hasNext());
    27
    tx.commit();
    Differences
    Expression1Expression2Difference
    assertFalsecommitMETHOD_INVOCATION_NAME_MISMATCH
    assertFalse(iter.hasNext())tx.commit()ARGUMENT_NUMBER_MISMATCH
    txMISSING_METHOD_INVOCATION_EXPRESSION
    Preondition Violations
    Expression tx.commit() cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertFalse(iter.hasNext()) is a void method call, and thus it cannot be parameterized
    Expression tx.commit() is a void method call, and thus it cannot be parameterized
    Expression tx.commit() cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertFalse(iter.hasNext()) is a void method call, and thus it cannot be parameterized
    Expression tx.commit() is a void method call, and thus it cannot be parameterized
    27
    tx.commit();
    25
    s.delete(i1);
                                      
    26
    s.delete(i2);
                                      
    27
    t.commit();
    27
    t.commit();
    21
    tx.commit();
    Differences
    Expression1Expression2Difference
    ttxVARIABLE_NAME_MISMATCH
    21
    tx.commit();
                                                      
    23
    assertUpdateCount(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();
    28
    s.close();
    28
    s.close();
    29
    assertEquals(getSessions().getStatistics().getEntityFetchCount(), 2);
    29
    assertEquals(getSessions().getStatistics().getEntityFetchCount(), 2);
    24
    assertDeleteCount(0);
    Differences
    Expression1Expression2Difference
    assertEqualsassertDeleteCountMETHOD_INVOCATION_NAME_MISMATCH
    assertEquals(getSessions().getStatistics().getEntityFetchCount(),2)assertDeleteCount(0)ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression assertEquals(getSessions().getStatistics().getEntityFetchCount(),2) is a void method call, and thus it cannot be parameterized
    Expression assertDeleteCount(0) 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 assertDeleteCount(0) is a void method call, and thus it cannot be parameterized
    24
    assertDeleteCount(0);
    Precondition Violations (58)
    Row Violation
    1Expression getSessions().getStatistics().clear() is a void method call, and thus it cannot be parameterized
    2Expression clearCounts() 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 clearCounts() is a void method call, and thus it cannot be parameterized
    5Expression s.persist("Item",i1) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    6Expression s.persist("Item",i1) is a void method call, and thus it cannot be parameterized
    7Expression assertInsertCount(0) is a void method call, and thus it cannot be parameterized
    8Expression s.persist("Item",i1) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    9Expression s.persist("Item",i1) is a void method call, and thus it cannot be parameterized
    10Expression assertInsertCount(0) is a void method call, and thus it cannot be parameterized
    11Expression s.persist("Item",i2) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    12Expression s.persist(root) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    13Expression s.persist("Item",i2) is a void method call, and thus it cannot be parameterized
    14Expression s.persist(root) is a void method call, and thus it cannot be parameterized
    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 i2=(Item)iter.next(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    19Expression assertFalse(Hibernate.isInitialized(i1)) is a void method call, and thus it cannot be parameterized
    20Expression assertSame(managedChildren,root.getChildren()) is a void method call, and thus it cannot be parameterized
    21Expression assertFalse(Hibernate.isInitialized(i1)) is a void method call, and thus it cannot be parameterized
    22Expression assertSame(managedChildren,root.getChildren()) is a void method call, and thus it cannot be parameterized
    23Expression assertSame(root,s.merge(newRoot)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    24Expression assertFalse(Hibernate.isInitialized(i2)) is a void method call, and thus it cannot be parameterized
    25Expression assertSame(root,s.merge(newRoot)) is a void method call, and thus it cannot be parameterized
    26Expression assertSame(root,s.merge(newRoot)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    27Expression assertFalse(Hibernate.isInitialized(i2)) is a void method call, and thus it cannot be parameterized
    28Expression assertSame(root,s.merge(newRoot)) is a void method call, and thus it cannot be parameterized
    29Expression assertFalse(Hibernate.isInitialized(i1)) is a void method call, and thus it cannot be parameterized
    30Expression cleanup() is a void method call, and thus it cannot be parameterized
    31Expression assertFalse(Hibernate.isInitialized(i1)) is a void method call, and thus it cannot be parameterized
    32Expression cleanup() is a void method call, and thus it cannot be parameterized
    33Expression assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    34Expression assertFalse(Hibernate.isInitialized(i2)) is a void method call, and thus it cannot be parameterized
    35Expression assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2)) is a void method call, and thus it cannot be parameterized
    36Expression assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2)) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    37Expression assertFalse(Hibernate.isInitialized(i2)) is a void method call, and thus it cannot be parameterized
    38Expression assertEquals(s.createCriteria(NumberedNode.class).setProjection(Projections.rowCount()).uniqueResult(),new Integer(2)) is a void method call, and thus it cannot be parameterized
    39Expression assertEquals(i1.getName(),"foo") is a void method call, and thus it cannot be parameterized
    40Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    41Expression assertEquals(i1.getName(),"foo") is a void method call, and thus it cannot be parameterized
    42Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    43Expression assertEquals(i2.getName(),"bar") is a void method call, and thus it cannot be parameterized
    44Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    45Expression assertEquals(i2.getName(),"bar") is a void method call, and thus it cannot be parameterized
    46Expression assertTrue(Hibernate.isInitialized(managedChildren)) is a void method call, and thus it cannot be parameterized
    47Type org.hibernate.test.iterate.Item of variable i1 does not match with type java.util.Set of variable managedChildren
    48Expression tx.commit() cannot be parameterized, because it has dependencies to/from statements that will be extracted
    49Expression assertFalse(iter.hasNext()) is a void method call, and thus it cannot be parameterized
    50Expression tx.commit() is a void method call, and thus it cannot be parameterized
    51Expression tx.commit() cannot be parameterized, because it has dependencies to/from statements that will be extracted
    52Expression assertFalse(iter.hasNext()) is a void method call, and thus it cannot be parameterized
    53Expression tx.commit() is a void method call, and thus it cannot be parameterized
    54Unmatched statement tx=s.beginTransaction(); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    55Expression assertEquals(getSessions().getStatistics().getEntityFetchCount(),2) is a void method call, and thus it cannot be parameterized
    56Expression assertDeleteCount(0) is a void method call, and thus it cannot be parameterized
    57Expression assertEquals(getSessions().getStatistics().getEntityFetchCount(),2) is a void method call, and thus it cannot be parameterized
    58Expression assertDeleteCount(0) is a void method call, and thus it cannot be parameterized