[hibernate-commits] Hibernate SVN: r20917 - in core/patches/JBOSS_EAP_3_3_2_CP03_JBPAPP-5939/core/src/test/java/org/hibernate: id and 1 other directories.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Tue Feb 15 12:56:06 EST 2011
Author: alessandrolt
Date: 2011-02-15 12:56:05 -0500 (Tue, 15 Feb 2011)
New Revision: 20917
Added:
core/patches/JBOSS_EAP_3_3_2_CP03_JBPAPP-5939/core/src/test/java/org/hibernate/id/
core/patches/JBOSS_EAP_3_3_2_CP03_JBPAPP-5939/core/src/test/java/org/hibernate/id/enhanced/
core/patches/JBOSS_EAP_3_3_2_CP03_JBPAPP-5939/core/src/test/java/org/hibernate/id/enhanced/OptimizerUnitTest.java
Log:
Added: core/patches/JBOSS_EAP_3_3_2_CP03_JBPAPP-5939/core/src/test/java/org/hibernate/id/enhanced/OptimizerUnitTest.java
===================================================================
--- core/patches/JBOSS_EAP_3_3_2_CP03_JBPAPP-5939/core/src/test/java/org/hibernate/id/enhanced/OptimizerUnitTest.java (rev 0)
+++ core/patches/JBOSS_EAP_3_3_2_CP03_JBPAPP-5939/core/src/test/java/org/hibernate/id/enhanced/OptimizerUnitTest.java 2011-02-15 17:56:05 UTC (rev 20917)
@@ -0,0 +1,337 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2010, Red Hat Inc. or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Inc.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ */
+package org.hibernate.id.enhanced;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+//
+//import org.hibernate.id.IdentifierGeneratorHelper;
+//import org.hibernate.id.IntegralDataTypeHolder;
+
+/**
+ * {@inheritDoc}
+ *
+ * @author Steve Ebersole
+ */
+ at SuppressWarnings({ "deprecation" })
+public class OptimizerUnitTest extends TestCase {
+ public OptimizerUnitTest(String string) {
+ super( string );
+ }
+
+ public static Test suite() {
+ return new TestSuite( OptimizerUnitTest.class );
+ }
+
+ public void testBasicNoOptimizerUsage() {
+ // test historic sequence behavior, where the initial values start at 1...
+ SourceMock sequence = new SourceMock( 1 );
+ Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.NONE, Long.class, 1 );
+ for ( int i = 1; i < 11; i++ ) {
+ final Long next = ( Long ) optimizer.generate( sequence );
+ assertEquals( i, next.intValue() );
+ }
+ assertEquals( 10, sequence.getTimesCalled() );
+ assertEquals( 10, sequence.getCurrentValue() );
+
+ // test historic table behavior, where the initial values started at 0 (we now force 1 to be the first used id value)
+ sequence = new SourceMock( 0 );
+ optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.NONE, Long.class, 1 );
+ for ( int i = 1; i < 11; i++ ) {
+ final Long next = ( Long ) optimizer.generate( sequence );
+ assertEquals( i, next.intValue() );
+ }
+ assertEquals( 11, sequence.getTimesCalled() ); // an extra time to get to 1 initially
+ assertEquals( 10, sequence.getCurrentValue() );
+ }
+
+ public void testBasicHiLoOptimizerUsage() {
+ int increment = 10;
+ Long next;
+
+ // test historic sequence behavior, where the initial values start at 1...
+ SourceMock sequence = new SourceMock( 1 );
+ Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.HILO, Long.class, increment );
+ for ( int i = 1; i <= increment; i++ ) {
+ next = ( Long ) optimizer.generate( sequence );
+ assertEquals( i, next.intValue() );
+ }
+ assertEquals( 1, sequence.getTimesCalled() ); // once to initialze state
+ assertEquals( 1, sequence.getCurrentValue() );
+ // force a "clock over"
+ next = ( Long ) optimizer.generate( sequence );
+ assertEquals( 11, next.intValue() );
+ assertEquals( 2, sequence.getTimesCalled() );
+ assertEquals( 2, sequence.getCurrentValue() );
+
+ // test historic table behavior, where the initial values started at 0 (we now force 1 to be the first used id value)
+ sequence = new SourceMock( 0 );
+ optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.HILO, Long.class, increment );
+ for ( int i = 1; i <= increment; i++ ) {
+ next = ( Long ) optimizer.generate( sequence );
+ assertEquals( i, next.intValue() );
+ }
+ assertEquals( 2, sequence.getTimesCalled() ); // here have have an extra call to get to 1 initially
+ assertEquals( 1, sequence.getCurrentValue() );
+ // force a "clock over"
+ next = ( Long ) optimizer.generate( sequence );
+ assertEquals( 11, next.intValue() );
+ assertEquals( 3, sequence.getTimesCalled() );
+ assertEquals( 2, sequence.getCurrentValue() );
+ }
+
+ public void testBasicPooledOptimizerUsage() {
+ Long next;
+ // test historic sequence behavior, where the initial values start at 1...
+ SourceMock sequence = new SourceMock( 1, 10 );
+ Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.POOL, Long.class, 10 );
+ for ( int i = 1; i < 11; i++ ) {
+ next = ( Long ) optimizer.generate( sequence );
+ assertEquals( i, next.intValue() );
+ }
+ assertEquals( 2, sequence.getTimesCalled() ); // twice to initialize state
+ assertEquals( 11, sequence.getCurrentValue() );
+ // force a "clock over"
+ next = ( Long ) optimizer.generate( sequence );
+ assertEquals( 11, next.intValue() );
+ assertEquals( 3, sequence.getTimesCalled() );
+ assertEquals( 21, sequence.getCurrentValue() );
+ }
+
+ public void testSubsequentPooledOptimizerUsage() {
+ // test the pooled optimizer in situation where the sequence is already beyond its initial value on init.
+ // cheat by telling the sequence to start with 1000
+ final SourceMock sequence = new SourceMock( 1001, 3, 5 );
+ // but tell the optimizer the start-with is 1
+ final Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.POOL, Long.class, 3, 1 );
+
+ assertEquals( 5, sequence.getTimesCalled() );
+ assertEquals( 1001, sequence.getCurrentValue() );
+
+ Long next = (Long) optimizer.generate( sequence );
+ assertEquals( 1001, next.intValue() );
+ assertEquals( (5+1), sequence.getTimesCalled() );
+ assertEquals( (1001+3), sequence.getCurrentValue() );
+
+ next = (Long) optimizer.generate( sequence );
+ assertEquals( (1001+1), next.intValue() );
+ assertEquals( (5+1), sequence.getTimesCalled() );
+ assertEquals( (1001+3), sequence.getCurrentValue() );
+
+ next = (Long) optimizer.generate( sequence );
+ assertEquals( (1001+2), next.intValue() );
+ assertEquals( (5+1), sequence.getTimesCalled() );
+ assertEquals( (1001+3), sequence.getCurrentValue() );
+
+ // force a "clock over"
+ next = (Long) optimizer.generate( sequence );
+ assertEquals( (1001+3), next.intValue() );
+ assertEquals( (5+2), sequence.getTimesCalled() );
+ assertEquals( (1001+6), sequence.getCurrentValue() );
+ }
+
+// public void testBasicPooledLoOptimizerUsage() {
+// final SourceMock sequence = new SourceMock( 1, 3 );
+// final Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.POOL_LO, Long.class, 3 );
+//
+// assertEquals( 0, sequence.getTimesCalled() );
+// assertEquals( -1, sequence.getCurrentValue() );
+//
+// Long next = ( Long ) optimizer.generate( sequence );
+// assertEquals( 1, next.intValue() );
+// assertEquals( 1, sequence.getTimesCalled() );
+// assertEquals( 1, sequence.getCurrentValue() );
+//
+// next = ( Long ) optimizer.generate( sequence );
+// assertEquals( 2, next.intValue() );
+// assertEquals( 1, sequence.getTimesCalled() );
+// assertEquals( 1, sequence.getCurrentValue() );
+//
+// next = ( Long ) optimizer.generate( sequence );
+// assertEquals( 3, next.intValue() );
+// assertEquals( 1, sequence.getTimesCalled() );
+// assertEquals( 1, sequence.getCurrentValue() );
+//
+//// // force a "clock over"
+// next = ( Long ) optimizer.generate( sequence );
+// assertEquals( 4, next.intValue() );
+// assertEquals( 2, sequence.getTimesCalled() );
+// assertEquals( (1+3), sequence.getCurrentValue() );
+// }
+
+ public void testSubsequentPooledLoOptimizerUsage() {
+ // test the pooled optimizer in situation where the sequence is already beyond its initial value on init.
+ // cheat by telling the sequence to start with 1000
+ final SourceMock sequence = new SourceMock( 1001, 3, 5 );
+ // but tell the optimizer the start-with is 1
+ final Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.POOL, Long.class, 3, 1 );
+
+ assertEquals( 5, sequence.getTimesCalled() );
+ assertEquals( 1001, sequence.getCurrentValue() );
+
+ Long next = ( Long ) optimizer.generate( sequence );
+ assertEquals( (1001), next.intValue() );
+ assertEquals( (5+1), sequence.getTimesCalled() );
+ assertEquals( (1001+3), sequence.getCurrentValue() );
+
+ next = ( Long ) optimizer.generate( sequence );
+ assertEquals( (1001+1), next.intValue() );
+ assertEquals( (5+1), sequence.getTimesCalled() );
+ assertEquals( (1001+3), sequence.getCurrentValue() );
+
+ next = ( Long ) optimizer.generate( sequence );
+ assertEquals( (1001+2), next.intValue() );
+ assertEquals( (5+1), sequence.getTimesCalled() );
+ assertEquals( (1001+3), sequence.getCurrentValue() );
+
+// // force a "clock over"
+ next = ( Long ) optimizer.generate( sequence );
+ assertEquals( (1001+3), next.intValue() );
+ assertEquals( (5+2), sequence.getTimesCalled() );
+ assertEquals( (1001+6), sequence.getCurrentValue() );
+ }
+
+ public void testRecoveredPooledOptimizerUsage() {
+ final SourceMock sequence = new SourceMock( 1, 3 );
+ final Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.POOL, Long.class, 3, 1 );
+
+ assertEquals( 0, sequence.getTimesCalled() );
+ assertEquals( -1, sequence.getCurrentValue() );
+
+ Long next = ( Long ) optimizer.generate( sequence );
+ assertEquals( 1, next.intValue() );
+ assertEquals( 2, sequence.getTimesCalled() );
+ assertEquals( 4, sequence.getCurrentValue() );
+
+ // app ends, and starts back up (we should "lose" only 2 and 3 as id values)
+ final Optimizer optimizer2 = OptimizerFactory.buildOptimizer( OptimizerFactory.POOL, Long.class, 3, 1 );
+ next = ( Long ) optimizer2.generate( sequence );
+ assertEquals( 4, next.intValue() );
+ assertEquals( 3, sequence.getTimesCalled() );
+ assertEquals( 7, sequence.getCurrentValue() );
+ }
+
+// public void testRecoveredPooledLoOptimizerUsage() {
+// final SourceMock sequence = new SourceMock( 1, 3 );
+// final Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.POOL_LO, Long.class, 3, 1 );
+//
+// assertEquals( 0, sequence.getTimesCalled() );
+// assertEquals( -1, sequence.getCurrentValue() );
+//
+// Long next = ( Long ) optimizer.generate( sequence );
+// assertEquals( 1, next.intValue() );
+// assertEquals( 1, sequence.getTimesCalled() );
+// assertEquals( 1, sequence.getCurrentValue() );
+//
+// // app ends, and starts back up (we should "lose" only 2 and 3 as id values)
+// final Optimizer optimizer2 = OptimizerFactory.buildOptimizer( OptimizerFactory.POOL_LO, Long.class, 3, 1 );
+// next = ( Long ) optimizer2.generate( sequence );
+// assertEquals( 4, next.intValue() );
+// assertEquals( 2, sequence.getTimesCalled() );
+// assertEquals( 4, sequence.getCurrentValue() );
+// }
+
+ private static class SourceMock implements AccessCallback {
+ private long value;
+ private long initialValue;
+ private int increment;
+ private int timesCalled = 0;
+
+ public SourceMock(long initialValue) {
+ this( initialValue, 1 );
+ }
+
+ public SourceMock(long initialValue, int increment) {
+ this( initialValue, increment, 0 );
+ }
+
+ public SourceMock(long initialValue, int increment, int timesCalled) {
+ this.increment = increment;
+ this.timesCalled = timesCalled;
+ if ( timesCalled != 0 ) {
+ this.value=initialValue;
+ this.initialValue = 1;
+ }
+ else {
+ this.value=-1;
+ this.initialValue = initialValue;
+ }
+ }
+
+ public long getNextValue() {
+ try {
+ if ( timesCalled == 0 ) {
+ initValue();
+ return value;
+ }
+ else {
+ return value+=increment;
+ }
+ }
+ finally {
+ timesCalled++;
+ }
+ }
+
+ private void initValue() {
+ this.value = initialValue;
+ }
+
+ public int getTimesCalled() {
+ return timesCalled;
+ }
+
+ public long getCurrentValue() {
+ return value;
+ }
+ }
+
+// public void testNoopDumping() {
+// SourceMock sequence = new SourceMock( 1 );
+// Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.NONE, Long.class, 1 );
+// for ( int i = 1; i <= 41; i++ ) {
+// System.out.println( i + " => " + optimizer.generate( sequence ) + " (" + sequence.getCurrentValue() + ")" );
+// }
+// }
+//
+// public void testHiLoDumping() {
+// int increment = 10;
+// SourceMock sequence = new SourceMock( 1 );
+// Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.HILO, Long.class, increment );
+// for ( int i = 1; i <= 41; i++ ) {
+// System.out.println( i + " => " + optimizer.generate( sequence ) + " (" + sequence.getCurrentValue() + ")" );
+// }
+// }
+//
+// public void testPooledDumping() {
+// int increment = 10;
+// SourceMock sequence = new SourceMock( 1, increment );
+// Optimizer optimizer = OptimizerFactory.buildOptimizer( OptimizerFactory.POOL, Long.class, increment );
+// for ( int i = 1; i <= 41; i++ ) {
+// System.out.println( i + " => " + optimizer.generate( sequence ) + " (" + sequence.getCurrentValue() + ")" );
+// }
+// }
+
+}
More information about the hibernate-commits
mailing list