gt:         assertEquals( array2.length, propertyValue.length );
context: /**
   * Copyright (c) 2002-2011 "Neo Technology,"
   * Network Engine for Objects in Lund AB [http://neotechnology.com]
   *
   * This file is part of Neo4j.
   *
   * Neo4j is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as
   * published by the Free Software Foundation, either version 3 of the
   * License, or (at your option) any later version.
   *
   * 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 Affero General Public License for more details.
   *
   * You should have received a copy of the GNU Affero General Public License
   * along with this program. If not, see <http://www.gnu.org/licenses/>.
   */
  package org.neo4j.kernel.impl.core;
  
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertTrue;
  
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Test;
  import org.neo4j.graphdb.Node;
  import org.neo4j.kernel.impl.AbstractNeo4jTestCase;
  
  public class TestPropertyTypes extends AbstractNeo4jTestCase
  {
      private Node node1 = null;
  
      @Before
      public void createInitialNode()
      {
          node1 = getGraphDb().createNode();
      }
  
      @After
      public void deleteInitialNode()
      {
          node1.delete();
      }
  
      @Test
      public void testDoubleType()
      {
          Double dValue = new Double( 45.678d );
          String key = "testdouble";
          node1.setProperty( key, dValue );
          newTransaction();
          clearCache();
          Double propertyValue = null;
          propertyValue = (Double) node1.getProperty( key );
          assertEquals( dValue, propertyValue );
          dValue = new Double( 56784.3243d );
          node1.setProperty( key, dValue );
          newTransaction();
          clearCache();
          propertyValue = (Double) node1.getProperty( key );
          assertEquals( dValue, propertyValue );
  
          node1.removeProperty( key );
          newTransaction();
          clearCache();
          assertTrue( !node1.hasProperty( key ) );
      }
  
      @Test
      public void testFloatType()
      {
          Float fValue = new Float( 45.678f );
          String key = "testfloat";
          node1.setProperty( key, fValue );
          newTransaction();
  
          clearCache();
          Float propertyValue = null;
          propertyValue = (Float) node1.getProperty( key );
          assertEquals( fValue, propertyValue );
  
          fValue = new Float( 5684.3243f );
          node1.setProperty( key, fValue );
          newTransaction();
  
          clearCache();
          propertyValue = (Float) node1.getProperty( key );
          assertEquals( fValue, propertyValue );
  
          node1.removeProperty( key );
          newTransaction();
  
          clearCache();
          assertTrue( !node1.hasProperty( key ) );
      }
  
      @Test
      public void testLongType()
      {
          long time = System.currentTimeMillis();
          Long lValue = new Long( time );
          String key = "testlong";
          node1.setProperty( key, lValue );
          newTransaction();
  
          clearCache();
          Long propertyValue = null;
          propertyValue = (Long) node1.getProperty( key );
          assertEquals( lValue, propertyValue );
  
          lValue = new Long( System.currentTimeMillis() );
          node1.setProperty( key, lValue );
          newTransaction();
  
          clearCache();
          propertyValue = (Long) node1.getProperty( key );
          assertEquals( lValue, propertyValue );
  
          node1.removeProperty( key );
          newTransaction();
  
          clearCache();
          assertTrue( !node1.hasProperty( key ) );
      }
  
      @Test
      public void testByteType()
      {
          byte b = (byte) 177;
          Byte bValue = new Byte( b );
          String key = "testbyte";
          node1.setProperty( key, bValue );
          newTransaction();
  
          clearCache();
          Byte propertyValue = null;
          propertyValue = (Byte) node1.getProperty( key );
          assertEquals( bValue, propertyValue );
  
          bValue = new Byte( (byte) 200 );
          node1.setProperty( key, bValue );
          newTransaction();
  
          clearCache();
          propertyValue = (Byte) node1.getProperty( key );
          assertEquals( bValue, propertyValue );
  
          node1.removeProperty( key );
          newTransaction();
  
          clearCache();
          assertTrue( !node1.hasProperty( key ) );
      }
  
      @Test
      public void testShortType()
      {
          short value = 453;
          Short sValue = new Short( value );
          String key = "testshort";
          node1.setProperty( key, sValue );
          newTransaction();
  
          clearCache();
          Short propertyValue = null;
          propertyValue = (Short) node1.getProperty( key );
          assertEquals( sValue, propertyValue );
  
          sValue = new Short( (short) 5335 );
          node1.setProperty( key, sValue );
          newTransaction();
  
          clearCache();
          propertyValue = (Short) node1.getProperty( key );
          assertEquals( sValue, propertyValue );
  
          node1.removeProperty( key );
          newTransaction();
  
          clearCache();
          assertTrue( !node1.hasProperty( key ) );
      }
  
      @Test
      public void testCharType()
      {
          char c = 'c';
          Character cValue = new Character( c );
          String key = "testchar";
          node1.setProperty( key, cValue );
          newTransaction();
  
          clearCache();
          Character propertyValue = null;
          propertyValue = (Character) node1.getProperty( key );
          assertEquals( cValue, propertyValue );
  
          cValue = new Character( 'd' );
          node1.setProperty( key, cValue );
          newTransaction();
  
          clearCache();
          propertyValue = (Character) node1.getProperty( key );
          assertEquals( cValue, propertyValue );
  
          node1.removeProperty( key );
          newTransaction();
  
          clearCache();
          assertTrue( !node1.hasProperty( key ) );
      }
  
      @Test
      public void testIntArray()
      {
          int[] array1 = new int[] { 1, 2, 3, 4, 5 };
          Integer[] array2 = new Integer[] { 6, 7, 8 };
          String key = "testintarray";
          node1.setProperty( key, array1 );
          newTransaction();
  
          clearCache();
          int propertyValue[] = null;
          propertyValue = (int[]) node1.getProperty( key );
          assertEquals( array1.length, propertyValue.length );
          for ( int i = 0; i < array1.length; i++ )
          {
              assertEquals( array1[i], propertyValue[i] );
          }
  
          node1.setProperty( key, array2 );
          newTransaction();
  
          clearCache();
          propertyValue = (int[]) node1.getProperty( key );
          assertEquals( array2.length, propertyValue.length );
          for ( int i = 0; i < array2.length; i++ )
          {
              assertEquals( array2[i], new Integer( propertyValue[i] ) );
          }
  
          node1.removeProperty( key );
          newTransaction();
  
          clearCache();
          assertTrue( !node1.hasProperty( key ) );
      }
  
      @Test
      public void testShortArray()
      {
          short[] array1 = new short[] { 1, 2, 3, 4, 5 };
          Short[] array2 = new Short[] { 6, 7, 8 };
          String key = "testintarray";
          node1.setProperty( key, array1 );
          newTransaction();
  
          clearCache();
          short propertyValue[] = null;
          propertyValue = (short[]) node1.getProperty( key );
          assertEquals( array1.length, propertyValue.length );
          for ( int i = 0; i < array1.length; i++ )
          {
              assertEquals( array1[i], propertyValue[i] );
          }
  
          node1.setProperty( key, array2 );
          newTransaction();
  
          clearCache();
          propertyValue = (short[]) node1.getProperty( key );
          assertEquals( array2.length, propertyValue.length );
          for ( int i = 0; i < array2.length; i++ )
          {
              assertEquals( array2[i], new Short( propertyValue[i] ) );
          }
  
          node1.removeProperty( key );
          newTransaction();
  
          clearCache();
          assertTrue( !node1.hasProperty( key ) );
      }
  
      @Test
      public void testStringArray()
      {
          String[] array1 = new String[] { "a", "b", "c", "d", "e" };
          String[] array2 = new String[] { "ff", "gg", "hh" };
          String key = "teststringarray";
          node1.setProperty( key, array1 );
          newTransaction();
  
          clearCache();
          String propertyValue[] = null;
          propertyValue = (String[]) node1.getProperty( key );
          assertEquals( array1.length, propertyValue.length );
          for ( int i = 0; i < array1.length; i++ )
          {
              assertEquals( array1[i], propertyValue[i] );
          }
  
          node1.setProperty( key, array2 );
          newTransaction();
  
          clearCache();
          propertyValue = (String[]) node1.getProperty( key );
          assertEquals( array2.length, propertyValue.length );
          for ( int i = 0; i < array2.length; i++ )
          {
              assertEquals( array2[i], propertyValue[i] );
          }
  
          node1.removeProperty( key );
          newTransaction();
  
          clearCache();
          assertTrue( !node1.hasProperty( key ) );
      }
  
      @Test
      public void testBooleanArray()
      {
          boolean[] array1 = new boolean[] { true, false, true, false, true };
          Boolean[] array2 = new Boolean[] { false, true, false };
          String key = "testboolarray";
          node1.setProperty( key, array1 );
          newTransaction();
  
          clearCache();
          boolean propertyValue[] = null;
          propertyValue = (boolean[]) node1.getProperty( key );
          assertEquals( array1.length, propertyValue.length );
          for ( int i = 0; i < array1.length; i++ )
          {
              assertEquals( array1[i], propertyValue[i] );
          }
  
          node1.setProperty( key, array2 );
          newTransaction();
  
          clearCache();
          propertyValue = (boolean[]) node1.getProperty( key );
          assertEquals( array2.length, propertyValue.length );
          for ( int i = 0; i < array2.length; i++ )
          {
              assertEquals( array2[i], new Boolean( propertyValue[i] ) );
          }
  
          node1.removeProperty( key );
          newTransaction();
  
          clearCache();
          assertTrue( !node1.hasProperty( key ) );
      }
  
      @Test
      public void testDoubleArray()
      {
          double[] array1 = new double[] { 1.0, 2.0, 3.0, 4.0, 5.0 };
          Double[] array2 = new Double[] { 6.0, 7.0, 8.0 };
          String key = "testdoublearray";
          node1.setProperty( key, array1 );
          newTransaction();
  
          clearCache();
          double propertyValue[] = null;
          propertyValue = (double[]) node1.getProperty( key );
          assertEquals( array1.length, propertyValue.length );
          for ( int i = 0; i < array1.length; i++ )
          {
              assertEquals( array1[i], propertyValue[i], 0.0 );
          }
  
          node1.setProperty( key, array2 );
          newTransaction();
  
          clearCache();
          propertyValue = (double[]) node1.getProperty( key );
  