/*
* Hibernate OGM, Domain model persistence for NoSQL datastores
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.ogm.backendtck.type;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URL;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
import java.util.UUID;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.ogm.backendtck.type.Bookmark.Classifier;
import org.hibernate.ogm.utils.OgmTestCase;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* @author Emmanuel Bernard <emmanuel@hibernate.org>
* @author Nicolas Helleringer
* @author Oliver Carr <ocarr@redhat.com>
* @author Ajay Bhat
* @author Hardy Ferentschik
*/
public class BuiltInTypeTest extends OgmTestCase {
private static TimeZone originalTimeZone = null;
private Calendar calendar;
private Session session;
private Bookmark bookmark;
@BeforeClass
public static void setDefaultTimeZone() {
originalTimeZone = TimeZone.getDefault();
TimeZone.setDefault( TimeZone.getTimeZone( "UTC" ) );
}
@Before
public void setup() {
session = openSession();
calendar = Calendar.getInstance();
bookmark = new Bookmark();
}
@AfterClass
public static void resetDefaultTimeZone() {
TimeZone.setDefault( originalTimeZone );
}
// basic types
@Test
public void testStringSupport() throws Exception {
bookmark.setDescription( "Hibernate Site" );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "String value does not match", bookmark.getDescription(), loadedBookmark.getDescription() );
}
@Test
public void testCharacterSupport() throws Exception {
bookmark.setDelimiter( '/' );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Character value does not match", bookmark.getDelimiter(), loadedBookmark.getDelimiter() );
}
@Test
public void testIntegerMaxValueSupport() throws Exception {
bookmark.setStockCount( Integer.MAX_VALUE );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Integer value does not match", bookmark.getStockCount(), loadedBookmark.getStockCount() );
}
@Test
public void testIntegerMinValueSupport() throws Exception {
bookmark.setStockCount( Integer.MIN_VALUE );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Integer value does not match", bookmark.getStockCount(), loadedBookmark.getStockCount() );
}
@Test
public void testIntegerSupport() throws Exception {
bookmark.setStockCount( 567 );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Integer value does not match", bookmark.getStockCount(), loadedBookmark.getStockCount() );
}
@Test
public void testShortSupport() throws Exception {
bookmark.setUrlPort( (short) 80 );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Short value does not match", bookmark.getUrlPort(), loadedBookmark.getUrlPort() );
}
@Test
public void testLongMaxValueSupport() throws Exception {
bookmark.setUserId( Long.MAX_VALUE );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Long value does not match", bookmark.getUserId(), loadedBookmark.getUserId() );
}
@Test
public void testLongMinValueSupport() throws Exception {
bookmark.setUserId( Long.MIN_VALUE );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Long value does not match", bookmark.getUserId(), loadedBookmark.getUserId() );
}
@Test
public void testLongSupport() throws Exception {
bookmark.setUserId( 12L );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Long value does not match", bookmark.getUserId(), loadedBookmark.getUserId() );
}
@Test
public void testFloatMaxValueSupport() throws Exception {
bookmark.setVisitRatio( Float.MAX_VALUE );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Float value does not match", bookmark.getVisitRatio(), loadedBookmark.getVisitRatio() );
}
@Test
public void testFloatMinValueSupport() throws Exception {
bookmark.setVisitRatio( Float.MIN_VALUE );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Float value does not match", bookmark.getVisitRatio(), loadedBookmark.getVisitRatio() );
}
@Test
public void testFloatSupport() throws Exception {
bookmark.setVisitRatio( (float) 10.4 );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Float value does not match", bookmark.getVisitRatio(), loadedBookmark.getVisitRatio() );
}
@Test
public void testDoubleMaxValueSupport() throws Exception {
bookmark.setTaxPercentage( Double.MAX_VALUE );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Double value does not match", bookmark.getTaxPercentage(), loadedBookmark.getTaxPercentage() );
}
@Test
public void testDoubleMinValueSupport() throws Exception {
bookmark.setTaxPercentage( Double.MIN_VALUE );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Double value does not match", bookmark.getTaxPercentage(), loadedBookmark.getTaxPercentage() );
}
@Test
public void testDoubleSupport() throws Exception {
bookmark.setTaxPercentage( 12.34d );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Long value does not match", bookmark.getTaxPercentage(), loadedBookmark.getTaxPercentage() );
}
@Test
public void testBooleanSupport() throws Exception {
bookmark.setFavourite( Boolean.TRUE );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Boolean value does not match", bookmark.getFavourite(), loadedBookmark.getFavourite() );
}
@Test
public void testTrueFalseMappedBooleanSupport() throws Exception {
bookmark.setPrivate( true );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Boolean value does not match", bookmark.isPrivate(), loadedBookmark.isPrivate() );
}
@Test
public void testYesNoMappedBooleanSupport() throws Exception {
bookmark.setRead( true );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Boolean value does not match", bookmark.isRead(), loadedBookmark.isRead() );
}
@Test
public void testNumericallyMappedBooleanSupport() throws Exception {
bookmark.setShared( true );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Boolean value does not match", bookmark.isShared(), loadedBookmark.isShared() );
}
@Test
public void testByteSupport() throws Exception {
bookmark.setDisplayMask( (byte) '8' );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Byte value does not match", bookmark.getDisplayMask(), loadedBookmark.getDisplayMask() );
}
// byte arrays
@Test
public void testByteArrayAsLobSupport() throws Exception {
byte[] testData = "akshd aflasfukpao p43o5jpt jg ;sdj;dsaljg;0s=-34 '[sfk;flj s' [s[43u '#[s fpi'psfj;fds# s#s soj jfs \'kgs;".getBytes();
bookmark.setLob( testData );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertArrayEquals( "Original and loaded data do not match!", testData, loadedBookmark.getLob() );
}
@Test
public void testLongAsLobSupport() throws Exception {
bookmark.setLobWithLong( Long.MIN_VALUE );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Original and loaded data do not match!", (Long) Long.MIN_VALUE, (Long) loadedBookmark.getLobWithLong() );
}
@Test
public void testStringAsLobSupport() throws Exception {
String text = "Very long text ...";
bookmark.setLobWithString( text );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Original and loaded data do not match!", text, loadedBookmark.getLobWithString() );
}
@Test
public void testByteArraySupport() throws Exception {
byte[] testData = "slfhs;lafksa ;fi jewe a;u r9032ur t'-)_$U lkajds lf3022- 752 -9372-32 s;d'gd #fs'g# s;".getBytes();
bookmark.setData( testData );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertArrayEquals( "Original and loaded data do not match!", testData, loadedBookmark.getData() );
}
// enum types
@Test
public void testEnumTypeMappedAsStringSupport() throws Exception {
bookmark.setClassifier( Classifier.HOME );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals(
"String mapped enum value does not match", bookmark.getClassifier(), loadedBookmark.getClassifier()
);
}
@Test
public void testEnumTypeMappedAsOrdinalSupport() throws Exception {
bookmark.setClassifierAsOrdinal( Classifier.WORK );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals(
"Ordinal mapped enum value does not match", bookmark.getClassifierAsOrdinal(),
loadedBookmark.getClassifierAsOrdinal()
);
}
// Date/time types
@Test
public void testDatePersistedAsTemporalTypeDateSupport() throws Exception {
Date creationDate = new Date();
bookmark.setCreationDate( creationDate );
// TemporalType#Date only deals with year/month/day
calendar.setTime( creationDate );
int expectedYear = calendar.get( Calendar.YEAR );
int expectedMonth = calendar.get( Calendar.MONTH );
int expectedDay = calendar.get( Calendar.DAY_OF_MONTH );
int expectedTimeZoneOffset = calendar.getTimeZone().getRawOffset();
Bookmark loadedBookmark = saveAndGet( bookmark );
calendar.setTime( loadedBookmark.getCreationDate() );
int actualYear = calendar.get( Calendar.YEAR );
int actualMonth = calendar.get( Calendar.MONTH );
int actualDay = calendar.get( Calendar.DAY_OF_MONTH );
int actualTimeZoneOffset = calendar.getTimeZone().getRawOffset();
assertEquals( "Year value does not match", expectedYear, actualYear );
assertEquals( "Month value does not match", expectedMonth, actualMonth );
assertEquals( "Day value does not match", expectedDay, actualDay );
assertEquals( "Time zones doe not match", expectedTimeZoneOffset, actualTimeZoneOffset );
}
@Test
public void testDatePersistedAsTemporalTypeTimeSupport() throws Exception {
Date updateTime = new Date();
bookmark.setUpdateTime( updateTime );
// TemporalType#time only deals with the time component. Date should be set to zero epoch
calendar.setTime( updateTime );
int expectedHour = calendar.get( Calendar.HOUR_OF_DAY );
int expectedMinute = calendar.get( Calendar.MINUTE );
int expectedSecond = calendar.get( Calendar.SECOND );
int expectedTimeZoneOffset = calendar.getTimeZone().getRawOffset();
Bookmark loadedBookmark = saveAndGet( bookmark );
calendar.setTime( loadedBookmark.getUpdateTime() );
int actualHour = calendar.get( Calendar.HOUR_OF_DAY );
int actualMinute = calendar.get( Calendar.MINUTE );
int actualSecond = calendar.get( Calendar.SECOND );
int actualTimeZoneOffset = calendar.getTimeZone().getRawOffset();
assertEquals( "Hour value does not match", expectedHour, actualHour );
assertEquals( "Minute value does not match", expectedMinute, actualMinute );
assertEquals( "Second value does not match", expectedSecond, actualSecond );
assertEquals( "Time zones doe not match", expectedTimeZoneOffset, actualTimeZoneOffset );
}
@Test
public void testDatePersistedAsTemporalTypeTimestampSupport() throws Exception {
Date destructionDate = new Date();
bookmark.setDestructionDate( destructionDate );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "Year value does not match", bookmark.getDestructionDate(), loadedBookmark.getDestructionDate() );
}
@Test
public void testCalendarTemporalTypeTimestampSupport() throws Exception {
bookmark.setDestructionCalendar( Calendar.getInstance() );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals(
"Calendar value does not match", bookmark.getDestructionCalendar().getTime(),
loadedBookmark.getDestructionCalendar().getTime()
);
}
@Test
public void testCalendarPersistedAsTemporalTypeDateSupport() throws Exception {
Calendar creationCalendar = Calendar.getInstance();
bookmark.setCreationCalendar( creationCalendar );
// TemporalType#Date only deals with year/month/day
int expectedYear = creationCalendar.get( Calendar.YEAR );
int expectedMonth = creationCalendar.get( Calendar.MONTH );
int expectedDay = creationCalendar.get( Calendar.DAY_OF_MONTH );
int expectedTimeZoneOffset = creationCalendar.getTimeZone().getRawOffset();
Bookmark loadedBookmark = saveAndGet( bookmark );
Calendar loadedCalendar = loadedBookmark.getCreationCalendar();
int actualYear = loadedCalendar.get( Calendar.YEAR );
int actualMonth = loadedCalendar.get( Calendar.MONTH );
int actualDay = loadedCalendar.get( Calendar.DAY_OF_MONTH );
int actualTimeZoneOffset = loadedCalendar.getTimeZone().getRawOffset();
assertEquals( "Year value does not match", expectedYear, actualYear );
assertEquals( "Month value does not match", expectedMonth, actualMonth );
assertEquals( "Day value does not match", expectedDay, actualDay );
assertEquals( "Time zones doe not match", expectedTimeZoneOffset, actualTimeZoneOffset );
}
// Misc
@Test
public void testURLSupport() throws Exception {
bookmark.setUrl( new URL( "http://www.hibernate.org/" ) );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "URL value does not match", bookmark.getUrl(), loadedBookmark.getUrl() );
}
@Test
public void testUUIDSupport() throws Exception {
UUID serialNumber = UUID.randomUUID();
bookmark.setSerialNumber( serialNumber );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "UUID value does not match", bookmark.getSerialNumber(), loadedBookmark.getSerialNumber() );
}
@Test
public void testBigDecimalSupport() throws Exception {
bookmark.setSiteWeight( new BigDecimal( "21.77" ) );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "BigDecimal value does not match", bookmark.getSiteWeight(), loadedBookmark.getSiteWeight() );
}
@Test
public void testBigIntegerSupport() throws Exception {
bookmark.setVisitCount( new BigInteger( "444" ) );
Bookmark loadedBookmark = saveAndGet( bookmark );
assertEquals( "BigInteger value does not match", bookmark.getVisitCount(), loadedBookmark.getVisitCount() );
}
private Bookmark saveAndGet(Bookmark bookmark) {
// persist
Transaction transaction = session.beginTransaction();
session.persist( bookmark );
transaction.commit();
// making sure the session is cleared
session.clear();
// get
transaction = session.beginTransaction();
Bookmark retrievedBookmark = (Bookmark) session.get( Bookmark.class, bookmark.getId() );
transaction.commit();
return retrievedBookmark;
}
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Bookmark.class
};
}
}