package org.litesoft.gae.datastoreservice;

import org.litesoft.core.typeutils.Objects;
import java.util.*;

import junit.framework.TestCase;
import junit.framework.TestSuite;

import com.google.appengine.api.datastore.DatastoreService;
import com.google.appengine.api.datastore.DatastoreServiceConfig;
import com.google.appengine.api.datastore.DatastoreServiceFactory;
import com.google.appengine.api.datastore.Entity;
import com.google.appengine.api.datastore.EntityNotFoundException;
import com.google.appengine.api.datastore.FetchOptions;
import com.google.appengine.api.datastore.ImplicitTransactionManagementPolicy;
import com.google.appengine.api.datastore.Key;
import com.google.appengine.api.datastore.KeyFactory;
import com.google.appengine.api.datastore.PreparedQuery;
import com.google.appengine.api.datastore.Query;
import com.google.appengine.api.datastore.Transaction;
import com.google.appengine.api.datastore.ReadPolicy.Consistency;
import com.google.appengine.tools.development.testing.LocalDatastoreServiceTestConfig;
import com.google.appengine.tools.development.testing.LocalServiceTestHelper;

public class DatastoreServiceTest extends TestCase
{
    private static final String KIND = "TheFlintstones";

    private final LocalServiceTestHelper mHelper = new LocalServiceTestHelper( new LocalDatastoreServiceTestConfig() );

    public static TestSuite suite()
    {
        return new TestSuite( DatastoreServiceTest.class );
    }

    public DatastoreServiceTest( String name )
    {
        super( name );
    }

    public static void main( String[] args )
    {
        junit.textui.TestRunner.run( suite() );
    }

    @Override
    protected void setUp() throws Exception
    {
        super.setUp();
        mHelper.setUp();
        mConfig = DatastoreServiceConfig.Builder.withDefaults() // Deadline=null,
                // ImplicitTransactionManagementPolicy=NONE,
                // ReadPolicy.Consistency=STRONG
                .deadline( 5 ); // Deadline=5 secs
        mDatastoreService = DatastoreServiceFactory.getDatastoreService( mConfig );
        mGOD_Apollo = KeyFactory.createKey( "GODS", "Apollo" );
        mGOD_Venus = KeyFactory.createKey( "GODS", "Venus" );

    }

    @Override
    public void tearDown()
    {
        mHelper.tearDown();
    }

    private DatastoreServiceConfig mConfig;

    private DatastoreService mDatastoreService;

    private Key mGOD_Apollo, mGOD_Venus;

    private Entity createEntity( Key pGOD, String pName )
    {
        Entity zEntity = new Entity( KIND, pName, pGOD );
        zEntity.setUnindexedProperty( "Version", 1L );

        zEntity.setProperty( "Name", pName );
        zEntity.setUnindexedProperty( "Children", 0L );
        return zEntity;
    }

    private void inc( Entity pEntity, String pProperty )
    {
        Long zLong = (Long) pEntity.getProperty( pProperty );
        pEntity.setUnindexedProperty( pProperty, zLong + 1 );
    }

    private Entity updateChildren( Entity pEntity )
    {
        inc( pEntity, "Version" );
        inc( pEntity, "Children" );
        return pEntity;
    }

    public void test_DataStoreConfig() throws Exception
    {
        assertEquals( 5.0d, mConfig.getDeadline(), 0.0001 );
        assertEquals( ImplicitTransactionManagementPolicy.NONE, mConfig.getImplicitTransactionManagementPolicy() );
        assertEquals( Consistency.STRONG, mConfig.getReadPolicy().getConsistency() );
    }

    public void test_NonConflictingDifferentGodsOverlapingTransactionsNew() throws Exception
    {
        Transaction zApolloTransaction = mDatastoreService.beginTransaction();
        Transaction zVenusTransaction = mDatastoreService.beginTransaction();

        Entity zEntityFred = createEntity( mGOD_Apollo, "Fred" );
        mDatastoreService.put( zApolloTransaction, zEntityFred );
        Entity zEntityWilma = createEntity( mGOD_Venus, "Wilma" );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Entity zEntityBarney = createEntity( mGOD_Apollo, "Barney" );
        mDatastoreService.put( zApolloTransaction, zEntityBarney );
        Entity zEntityBetty = createEntity( mGOD_Venus, "Betty" );
        mDatastoreService.put( zVenusTransaction, zEntityBetty );

        zApolloTransaction.commit();
        zVenusTransaction.commit();

        readAndValidate( null, zEntityFred, "Fred", 1, 0 );
        readAndValidate( null, zEntityWilma, "Wilma", 1, 0 );

        readAndValidate( null, zEntityBarney, "Barney", 1, 0 );
        readAndValidate( null, zEntityBetty, "Betty", 1, 0 );
    }

    public void test_TransactionReadMultiGOD() throws Exception
    {
        Transaction zApolloTransaction = mDatastoreService.beginTransaction();
        Transaction zVenusTransaction = mDatastoreService.beginTransaction();

        Entity zEntityFred = createEntity( mGOD_Apollo, "Fred" );
        mDatastoreService.put( zApolloTransaction, zEntityFred );
        Entity zEntityWilma = createEntity( mGOD_Venus, "Wilma" );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        zApolloTransaction.commit();
        zVenusTransaction.commit();

        Transaction zTransaction = mDatastoreService.beginTransaction();
        mDatastoreService.get( zTransaction, zEntityFred.getKey() ); // will
        // succeed!
        try
        {
            mDatastoreService.get( zTransaction, zEntityWilma.getKey() ); // will
            // Fail!
            fail( "Fred & Wilma - Did NOT Fail with different GODS (Entity Groups)" );
        }
        catch ( IllegalArgumentException expected )
        {
            String zMessage = expected.getMessage();
            assertTrue( zMessage, zMessage
                    .startsWith( "can't operate on multiple entity groups in a single transaction." ) );
        }
        zTransaction.rollback();
    }

    public void test_TransactionUpdate() throws Exception
    {
        Transaction zApolloTransaction = mDatastoreService.beginTransaction();
        Transaction zVenusTransaction = mDatastoreService.beginTransaction();

        Entity zEntityFred = createEntity( mGOD_Apollo, "Fred" );
        mDatastoreService.put( zApolloTransaction, zEntityFred );
        Entity zEntityWilma = createEntity( mGOD_Venus, "Wilma" );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Entity zEntityBarney = createEntity( mGOD_Apollo, "Barney" );
        mDatastoreService.put( zApolloTransaction, zEntityBarney );
        Entity zEntityBetty = createEntity( mGOD_Venus, "Betty" );
        mDatastoreService.put( zVenusTransaction, zEntityBetty );

        zApolloTransaction.commit();
        zVenusTransaction.commit();

        zVenusTransaction = mDatastoreService.beginTransaction();

        zEntityWilma = updateChildren( readAndValidate( zVenusTransaction, zEntityWilma, "Wilma", 1, 0 ) );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Entity zEntityPebbles = createEntity( mGOD_Venus, "Pebbles" );
        mDatastoreService.put( zVenusTransaction, zEntityPebbles );

        // Can't Update Fred!

        zVenusTransaction.commit();

        zApolloTransaction = mDatastoreService.beginTransaction();

        zEntityBarney = updateChildren( readAndValidate( zApolloTransaction, zEntityBarney, "Barney", 1, 0 ) );
        mDatastoreService.put( zApolloTransaction, zEntityBarney );

        Entity zEntityBammBamm = createEntity( mGOD_Apollo, "BammBamm" );
        mDatastoreService.put( zApolloTransaction, zEntityBammBamm );

        // Can't Update Betty!

        zApolloTransaction.commit();

        readAndValidate( null, zEntityFred, "Fred", 1, 0 );
        readAndValidate( null, zEntityWilma, "Wilma", 2, 1 );
        readAndValidate( null, zEntityPebbles, "Pebbles", 1, 0 );

        readAndValidate( null, zEntityBarney, "Barney", 2, 1 );
        readAndValidate( null, zEntityBetty, "Betty", 1, 0 );
        readAndValidate( null, zEntityBammBamm, "BammBamm", 1, 0 );
    }

    public void test_NonConflictingDifferentGodsOverlapingTransactionsUpdate() throws Exception
    {
        Transaction zApolloTransaction = mDatastoreService.beginTransaction();
        Transaction zVenusTransaction = mDatastoreService.beginTransaction();

        Entity zEntityFred = createEntity( mGOD_Apollo, "Fred" );
        mDatastoreService.put( zApolloTransaction, zEntityFred );
        Entity zEntityWilma = createEntity( mGOD_Venus, "Wilma" );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        zApolloTransaction.commit();
        zVenusTransaction.commit();

        zApolloTransaction = mDatastoreService.beginTransaction();
        zVenusTransaction = mDatastoreService.beginTransaction();

        zEntityWilma = updateChildren( readAndValidate( zVenusTransaction, zEntityWilma, "Wilma", 1, 0 ) );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Entity zEntityPebbles = createEntity( mGOD_Venus, "Pebbles" );
        mDatastoreService.put( zVenusTransaction, zEntityPebbles );

        zEntityFred = updateChildren( readAndValidate( zApolloTransaction, zEntityFred, "Fred", 1, 0 ) );
        mDatastoreService.put( zApolloTransaction, zEntityFred );

        zApolloTransaction.commit();
        zVenusTransaction.commit();

        readAndValidate( null, zEntityFred, "Fred", 2, 1 );
        readAndValidate( null, zEntityWilma, "Wilma", 2, 1 );

        readAndValidate( null, zEntityPebbles, "Pebbles", 1, 0 );
    }

    public void test_ConflictingSameEntityOverlapingTransactionsUpdate() throws Exception
    {
        Transaction zVenusTransaction = mDatastoreService.beginTransaction();

        Entity zEntityWilma = createEntity( mGOD_Venus, "Wilma" );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        zVenusTransaction.commit();

        zVenusTransaction = mDatastoreService.beginTransaction();

        zEntityWilma = updateChildren( readAndValidate( zVenusTransaction, zEntityWilma, "Wilma", 1, 0 ) );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Entity zEntityPebbles = createEntity( mGOD_Venus, "Pebbles" );
        mDatastoreService.put( zVenusTransaction, zEntityPebbles );

        Transaction zVenus2Transaction = mDatastoreService.beginTransaction();

        Entity zEntityWilma2 = updateChildren( readAndValidate2( zVenus2Transaction, zEntityWilma, "Wilma", 1, 0 ) );
        mDatastoreService.put( zVenus2Transaction, zEntityWilma2 );

        zVenusTransaction.commit();

        try
        {
            zVenus2Transaction.commit();
            fail( "Two Transaction Wilma Update - Did NOT Fail" );
        }
        catch ( ConcurrentModificationException expected )
        {
            String zMessage = expected.getMessage();
            assertTrue( zMessage, zMessage.startsWith( "too much contention on these datastore entities. please try again." ) );
        }

        readAndValidate( null, zEntityWilma, "Wilma", 2, 1 );
    }

    public void test_NonConflictingSameGodDifferentEntityOverlapingTransactionsUpdate() throws Exception
    {
        Transaction zVenusTransaction = mDatastoreService.beginTransaction();

        Entity zEntityWilma = createEntity( mGOD_Venus, "Wilma" );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Entity zEntityBetty = createEntity( mGOD_Venus, "Betty" );
        mDatastoreService.put( zVenusTransaction, zEntityBetty );

        zVenusTransaction.commit();

        zVenusTransaction = mDatastoreService.beginTransaction();

        zEntityWilma = updateChildren( readAndValidate( zVenusTransaction, zEntityWilma, "Wilma", 1, 0 ) );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Transaction zVenus2Transaction = mDatastoreService.beginTransaction();

        zEntityBetty = updateChildren( readAndValidate( zVenus2Transaction, zEntityBetty, "Betty", 1, 0 ) );
        mDatastoreService.put( zVenus2Transaction, zEntityBetty );

        zVenusTransaction.commit();

        try
        {
            zVenus2Transaction.commit();
            fail( "Two Transaction Wilma & Betty Update - Did NOT Fail" );
        }
        catch ( ConcurrentModificationException expected )
        {
            String zMessage = expected.getMessage();
            assertTrue( zMessage, zMessage.startsWith( "too much contention on these datastore entities. please try again." ) );
        }

        readAndValidate( null, zEntityWilma, "Wilma", 2, 1 );
        readAndValidate2( null, zEntityBetty, "Betty", 1, 0 );
    }

    public void test_QueryAllDifferentGods() throws Exception
    {
        Transaction zApolloTransaction = mDatastoreService.beginTransaction();
        Transaction zVenusTransaction = mDatastoreService.beginTransaction();

        Entity zEntityFred = createEntity( mGOD_Apollo, "Fred" );
        mDatastoreService.put( zApolloTransaction, zEntityFred );
        Entity zEntityWilma = createEntity( mGOD_Venus, "Wilma" );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Entity zEntityBarney = createEntity( mGOD_Apollo, "Barney" );
        mDatastoreService.put( zApolloTransaction, zEntityBarney );
        Entity zEntityBetty = createEntity( mGOD_Venus, "Betty" );
        mDatastoreService.put( zVenusTransaction, zEntityBetty );

        zApolloTransaction.commit();
        zVenusTransaction.commit();

        PreparedQuery zQuery = mDatastoreService.prepare( new Query( KIND ).addSort( "Name" ) );

        List<Entity> zList = zQuery.asList( FetchOptions.Builder.withOffset( 0 ) );

        assertEquals( "Entities", 4, zList.size() );

        validate( zList.get( 0 ), "Barney", 1, 0 );
        validate( zList.get( 1 ), "Betty", 1, 0 );
        validate( zList.get( 2 ), "Fred", 1, 0 );
        validate( zList.get( 3 ), "Wilma", 1, 0 );
    }

    public void test_QuerySpecificGod() throws Exception
    {
        Transaction zApolloTransaction = mDatastoreService.beginTransaction();
        Transaction zVenusTransaction = mDatastoreService.beginTransaction();

        Entity zEntityFred = createEntity( mGOD_Apollo, "Fred" );
        mDatastoreService.put( zApolloTransaction, zEntityFred );
        Entity zEntityWilma = createEntity( mGOD_Venus, "Wilma" );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Entity zEntityBarney = createEntity( mGOD_Apollo, "Barney" );
        mDatastoreService.put( zApolloTransaction, zEntityBarney );
        Entity zEntityBetty = createEntity( mGOD_Venus, "Betty" );
        mDatastoreService.put( zVenusTransaction, zEntityBetty );

        zApolloTransaction.commit();
        zVenusTransaction.commit();

        PreparedQuery zQuery = mDatastoreService.prepare( new Query( KIND, mGOD_Apollo ).addSort( "Name" ) );

        List<Entity> zList = zQuery.asList( FetchOptions.Builder.withOffset( 0 ) );

        assertEquals( "Entities", 2, zList.size() );

        validate( zList.get( 0 ), "Barney", 1, 0 );
        validate( zList.get( 1 ), "Fred", 1, 0 );
    }

    public void test_QueryEqualsFilter() throws Exception
    {
        Transaction zApolloTransaction = mDatastoreService.beginTransaction();
        Transaction zVenusTransaction = mDatastoreService.beginTransaction();

        Entity zEntityFred = createEntity( mGOD_Apollo, "Fred" );
        mDatastoreService.put( zApolloTransaction, zEntityFred );
        Entity zEntityWilma = createEntity( mGOD_Venus, "Wilma" );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Entity zEntityBarney = createEntity( mGOD_Apollo, "Barney" );
        mDatastoreService.put( zApolloTransaction, zEntityBarney );
        Entity zEntityBetty = createEntity( mGOD_Venus, "Betty" );
        mDatastoreService.put( zVenusTransaction, zEntityBetty );

        zApolloTransaction.commit();
        zVenusTransaction.commit();

        PreparedQuery zQuery = mDatastoreService.prepare( new Query( KIND ).addSort( "Name" ).addFilter( "Name", Query.FilterOperator.EQUAL, "Barney") );

        List<Entity> zList = zQuery.asList( FetchOptions.Builder.withOffset( 0 ) );

        assertEquals( "Entities", 1, zList.size() );

        validate( zList.get( 0 ), "Barney", 1, 0 );
    }

    public void test_QueryLessThanFilter() throws Exception
    {
        Transaction zApolloTransaction = mDatastoreService.beginTransaction();
        Transaction zVenusTransaction = mDatastoreService.beginTransaction();

        Entity zEntityFred = createEntity( mGOD_Apollo, "Fred" );
        mDatastoreService.put( zApolloTransaction, zEntityFred );
        Entity zEntityWilma = createEntity( mGOD_Venus, "Wilma" );
        mDatastoreService.put( zVenusTransaction, zEntityWilma );

        Entity zEntityBarney = createEntity( mGOD_Apollo, "Barney" );
        mDatastoreService.put( zApolloTransaction, zEntityBarney );
        Entity zEntityBetty = createEntity( mGOD_Venus, "Betty" );
        mDatastoreService.put( zVenusTransaction, zEntityBetty );

        zApolloTransaction.commit();
        zVenusTransaction.commit();

        PreparedQuery zQuery = mDatastoreService.prepare( new Query( KIND ).addSort( "Name" ).addFilter( "Name", Query.FilterOperator.LESS_THAN, "C") );

        List<Entity> zList = zQuery.asList( FetchOptions.Builder.withOffset( 0 ) );

        assertEquals( "Entities", 2, zList.size() );

        validate( zList.get( 0 ), "Barney", 1, 0 );
        validate( zList.get( 1 ), "Betty", 1, 0 );
    }

    public void test_NullKey() throws Exception
    {
        try
        {
            KeyFactory.createKey( KIND, null );
            fail( "null Key did NOT fail" );
        }
        catch ( IllegalArgumentException expected )
        {
            String zMessage = expected.getMessage();
            assertTrue( zMessage, zMessage.startsWith( "name cannot be null or empty" ) );
        }
        // new Entity( KIND, null, pGOD ); // Does Not Fail, but
        // implicitly creates a auto-generated id key!!
    }

    public void test_EmptyKey() throws Exception
    {
        try
        {
            KeyFactory.createKey( KIND, "" );
            fail( "empty Key did NOT fail" );
        }
        catch ( IllegalArgumentException expected )
        {
            String zMessage = expected.getMessage();
            assertTrue( zMessage, zMessage.startsWith( "name cannot be null or empty" ) );
        }
    }

    public void test_IndexingString() throws Exception
    {
        Transaction zTransaction = mDatastoreService.beginTransaction();

        String v1, v2;

        mDatastoreService.put( zTransaction, createIndexingEntity( "Strings", null ) );
        mDatastoreService.put( zTransaction, createIndexingEntity( "Strings", v1 = "" ) );
        mDatastoreService.put( zTransaction, createIndexingEntity( "Strings", v2 = "Fred" ) );

        zTransaction.commit();

        PreparedQuery zQuery = mDatastoreService.prepare( new Query( "Strings" ).addSort( "FieldValue" ) );

        List<Entity> zList = zQuery.asList( FetchOptions.Builder.withOffset( 0 ) );

        assertEquals( "Entities", 3, zList.size() );

        validate( zList.get( 0 ), null );
        validate( zList.get( 1 ), v1 );
        validate( zList.get( 2 ), v2 );
    }

    public void test_IndexingBoolean() throws Exception
    {
        Transaction zTransaction = mDatastoreService.beginTransaction();

        Boolean v1, v2;

        mDatastoreService.put( zTransaction, createIndexingEntity( "Booleans", null ) );
        mDatastoreService.put( zTransaction, createIndexingEntity( "Booleans", v1 = Boolean.FALSE ) );
        mDatastoreService.put( zTransaction, createIndexingEntity( "Booleans", v2 = Boolean.TRUE ) );

        zTransaction.commit();

        PreparedQuery zQuery = mDatastoreService.prepare( new Query( "Booleans" ).addSort( "FieldValue" ) );

        List<Entity> zList = zQuery.asList( FetchOptions.Builder.withOffset( 0 ) );

        assertEquals( "Entities", 3, zList.size() );

        validate( zList.get( 0 ), null );
        validate( zList.get( 1 ), v1 );
        validate( zList.get( 2 ), v2 );
    }

    public void test_IndexingLong() throws Exception
    {
        Transaction zTransaction = mDatastoreService.beginTransaction();

        Long v1, v2;

        mDatastoreService.put( zTransaction, createIndexingEntity( "Longs", null ) );
        mDatastoreService.put( zTransaction, createIndexingEntity( "Longs", v1 = 1L ) );
        mDatastoreService.put( zTransaction, createIndexingEntity( "Longs", v2 = 100L ) );

        zTransaction.commit();

        PreparedQuery zQuery = mDatastoreService.prepare( new Query( "Longs" ).addSort( "FieldValue" ) );

        List<Entity> zList = zQuery.asList( FetchOptions.Builder.withOffset( 0 ) );

        assertEquals( "Entities", 3, zList.size() );

        validate( zList.get( 0 ), null );
        validate( zList.get( 1 ), v1 );
        validate( zList.get( 2 ), v2 );
    }

    public void test_IndexingDouble() throws Exception
    {
        Transaction zTransaction = mDatastoreService.beginTransaction();

        Double v1, v2;

        mDatastoreService.put( zTransaction, createIndexingEntity( "Doubles", null ) );
        mDatastoreService.put( zTransaction, createIndexingEntity( "Doubles", v1 = 1.1D ) );
        mDatastoreService.put( zTransaction, createIndexingEntity( "Doubles", v2 = 11.2D ) );

        zTransaction.commit();

        PreparedQuery zQuery = mDatastoreService.prepare( new Query( "Doubles" ).addSort( "FieldValue" ) );

        List<Entity> zList = zQuery.asList( FetchOptions.Builder.withOffset( 0 ) );

        assertEquals( "Entities", 3, zList.size() );

        validate( zList.get( 0 ), null );
        validate( zList.get( 1 ), v1 );
        validate( zList.get( 2 ), v2 );
    }

    public void test_IndexingDate() throws Exception
    {
        Transaction zTransaction = mDatastoreService.beginTransaction();

        Date v1, v2;

        mDatastoreService.put( zTransaction, createIndexingEntity( "Dates", null ) );
        mDatastoreService.put( zTransaction, createIndexingEntity( "Dates", v1 = createDate( 1957, 1, 4, 11, 12, 13, 14 ) ) );
        mDatastoreService.put( zTransaction, createIndexingEntity( "Dates", v2 = createDate( 2000, 2, 29, 0, 0, 0, 0 ) ) );

        zTransaction.commit();

        PreparedQuery zQuery = mDatastoreService.prepare( new Query( "Dates" ).addSort( "FieldValue" ) );

        List<Entity> zList = zQuery.asList( FetchOptions.Builder.withOffset( 0 ) );

        assertEquals( "Entities", 3, zList.size() );

        validate( zList.get( 0 ), null );
        validate( zList.get( 1 ), v1 );
        validate( zList.get( 2 ), v2 );
    }

    public void test_LargeCollections() throws Exception
    {
        Transaction zTransaction = mDatastoreService.beginTransaction();

        long zMaxLongsThatWork = 62645L;

        Entity zEntity;
        Set<Long> zLongs;

        try
        {
            zLongs = createLongs( zMaxLongsThatWork + 1 ); // Too Big!

            zEntity = new Entity( "LargeCollections", "Test" );
            zEntity.setProperty( "FieldValue", "Test" );
            zEntity.setUnindexedProperty( "Longs", zLongs );

            mDatastoreService.put( zTransaction, zEntity );

            fail( "Too Many did not fail w/ too large" );
        }
        catch ( Exception expected )
        {
            assertNotNull( expected ); // com.google.apphosting.api.ApiProxy$RequestTooLargeException: The request to API call datastore_v3.Put() was too large.
        }
        zLongs = createLongs( zMaxLongsThatWork ); // Just Small Enough!

        zEntity = new Entity( "LargeCollections", "Test" );
        zEntity.setProperty( "FieldValue", "Test" );
        zEntity.setUnindexedProperty( "Longs", zLongs );

        mDatastoreService.put( zTransaction, zEntity );

        zTransaction.commit();

        PreparedQuery zQuery = mDatastoreService.prepare( new Query( "LargeCollections" ).addSort( "FieldValue" ) );

        List<Entity> zList = zQuery.asList( FetchOptions.Builder.withOffset( 0 ) );

        assertEquals( "Entities", 1, zList.size() );

        zEntity = zList.get( 0 );

        assertEquals( "FieldValue", "Test", zEntity.getProperty( "FieldValue" ) );

        validate( zLongs, zEntity.getProperty( "Longs" ) );
    }

    private Set<Long> createLongs( long pLongsToCreate )
    {
        HashSet<Long> zSet = new HashSet<Long>();
        while ( --pLongsToCreate >= 0 )
        {
            zSet.add( pLongsToCreate );
        }
        return zSet;
    }

    @SuppressWarnings("unchecked")
    private void validate( Set<Long> zExpected, Object pFieldValue )
    {
        List<Long> zReadList = (List<Long>)pFieldValue;
        for (Long zLong : zReadList)
        {
            if ( !zExpected.remove( zLong ) )
            {
                fail( "Found value (" + zLong + "), not written" );
            }
        }
        if ( !zExpected.isEmpty() )
        {
            fail( "Did NOT read: " + zExpected );
        }
    }

    @SuppressWarnings("deprecation")
    private Date createDate( int pYear, int pMonth, int pDay, int pHour, int pMin, int pSec, int pMilliSecs )
    {
        Date zDate = new Date( pYear - 1900, pMonth - 1, pDay, pHour, pMin, pSec );
        if ( pMilliSecs != 0 )
        {
            zDate = new Date( zDate.getTime() + pMilliSecs );
        }
        return zDate;
    }

    @SuppressWarnings("deprecation")
    private String simpleDateToString( Date pDate )
    {
        int zYear = pDate.getYear() + 1900;
        int zMonth = pDate.getMonth() + 1;
        int zDay = pDate.getDate();
        int zHour = pDate.getHours();
        int zMin = pDate.getMinutes();
        int zSec = pDate.getSeconds();
        int zMilliSecs = (int)(pDate.getTime() - new Date( zYear - 1900, zMonth - 1, zDay, zHour, zMin, zSec ).getTime());
        return "" + zYear + "/" + zMonth + "/" + zDay + "-" + zHour + ":" + zMin + ":" + zSec + "." + zMilliSecs;
    }

    private String createIndexKey( Object pFieldValue )
    {
        if ( pFieldValue == null )
        {
            return " ";
        }
        if ( pFieldValue instanceof String )
        {
            return pFieldValue + "  ";
        }
        if ( pFieldValue instanceof Date )
        {
            return simpleDateToString( (Date)pFieldValue );
        }
        return pFieldValue.toString();
    }

    private Entity createIndexingEntity( String pKind, Object pFieldValue )
    {
        Entity zEntity = new Entity( pKind, createIndexKey( pFieldValue ), mGOD_Apollo );
        zEntity.setProperty( "FieldValue", pFieldValue );
        return zEntity;
    }

    private void validate( Entity pEntity, Object pExpectedFieldValue )
    {
        validate( pEntity, createIndexKey( pExpectedFieldValue ), pExpectedFieldValue );
    }

    private void validate( Entity pEntity, String pExpectedKey, Object pExpectedFieldValue )
    {
        assertEquals( "Entity Key", pExpectedKey, pEntity.getKey().getName() );
        Object zFieldValue = pEntity.getProperty( "FieldValue" );
        if ( pExpectedFieldValue == null )
        {
            assertNull( "FieldValue", zFieldValue );
        }
        else
        {
            assertEquals( "Entity FieldValue", pExpectedFieldValue, zFieldValue );
            assertEquals( "Entity FieldValue Class", pExpectedFieldValue.getClass(), zFieldValue.getClass() );
        }
    }

    private Entity readAndValidate( Transaction pTransaction, Entity pEntity, String pName, long pCurrentVersion, long pCurrentChildren )
            throws EntityNotFoundException
    {
        validate( pEntity, pName, pCurrentVersion, pCurrentChildren );

        return readAndValidate2( pTransaction, pEntity, pName, pCurrentVersion, pCurrentChildren );
    }

    private void validate( Entity pEntity, String pName, long pCurrentVersion, long pCurrentChildren )
    {
        assertEquals( "Current Entity Version", pCurrentVersion, pEntity.getProperty( "Version" ) );
        assertEquals( "Current Entity Name", pName, pEntity.getProperty( "Name" ) );
        assertEquals( "Current Entity Children", pCurrentChildren, pEntity.getProperty( "Children" ) );
    }

    private Entity readAndValidate2( Transaction pTransaction, Entity pEntity, String pName, long pCurrentVersion, long pCurrentChildren )
            throws EntityNotFoundException
    {
        Key zKey = pEntity.getKey();

        return readAndValidate3( pTransaction, zKey, pName, pCurrentVersion, pCurrentChildren );
    }

    private Entity readAndValidate3( Transaction pTransaction, Key zKey, String pName, long pCurrentVersion, long pCurrentChildren )
            throws EntityNotFoundException
    {
        assertEquals( "Key Kind", KIND, zKey.getKind() );
        assertEquals( "Key Name (Our Key Value)", pName, zKey.getName() );

        Entity zEntity = mDatastoreService.get( pTransaction, zKey );

        if ( pTransaction == null )
        {
            Object zVersion = zEntity.getProperty( "Version" );
            assertNotNull( "Read Entity Version", zVersion );
            if ( !zVersion.equals( pCurrentVersion ) )
            {
                Transaction zTransaction = mDatastoreService.beginTransaction();
                zEntity = mDatastoreService.get( zTransaction, zKey );
                zTransaction.rollback();
            }
        }

        assertEquals( "Read Entity Version", pCurrentVersion, zEntity.getProperty( "Version" ) );
        assertEquals( "Read Entity Name", pName, zEntity.getProperty( "Name" ) );
        assertEquals( "Read Entity Children", pCurrentChildren, zEntity.getProperty( "Children" ) );

        return zEntity;
    }
}