From 78dac6903e542223d234ab87648ac384672b8a74 Mon Sep 17 00:00:00 2001
From: Anton Persson <anton.persson@neotechnology.com>
Date: Fri, 28 Sep 2018 16:16:40 +0200
Subject: [PATCH] Rearrange members in ValueCreatorUtil

---
 .../impl/index/schema/ValueCreatorUtil.java   | 170 ++++++++++--------
 1 file changed, 95 insertions(+), 75 deletions(-)

diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/index/schema/ValueCreatorUtil.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/index/schema/ValueCreatorUtil.java
index 08be329078619..0893b1aca7bc4 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/index/schema/ValueCreatorUtil.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/index/schema/ValueCreatorUtil.java
@@ -54,20 +54,10 @@ abstract class ValueCreatorUtil<KEY extends NativeIndexKey<KEY>, VALUE extends N
         this.indexDescriptor = indexDescriptor;
     }
 
-    IndexEntryUpdate<IndexDescriptor>[] someUpdates( RandomRule randomRule )
-    {
-        Iterator<IndexEntryUpdate<IndexDescriptor>> randomUpdateGenerator = randomUpdateGenerator( randomRule );
-        //noinspection unchecked
-        IndexEntryUpdate<IndexDescriptor>[] result = new IndexEntryUpdate[N_VALUES];
-        for ( int i = 0; i < N_VALUES; i++ )
-        {
-            result[i] = randomUpdateGenerator.next();
-        }
-        return result;
-    }
-
     abstract RandomValues.Type[] supportedTypes();
 
+    abstract int compareIndexedPropertyValue( KEY key1, KEY key2 );
+
     protected double fractionDuplicates()
     {
         return 0.1;
@@ -78,85 +68,34 @@ IndexQuery rangeQuery( Value from, boolean fromInclusive, Value to, boolean toIn
         return IndexQuery.range( 0, from, fromInclusive, to, toInclusive );
     }
 
-    abstract int compareIndexedPropertyValue( KEY key1, KEY key2 );
-
     StoreIndexDescriptor indexDescriptor()
     {
         return indexDescriptor;
     }
 
-    void copyValue( VALUE value, VALUE intoValue )
-    {   // no-op until we decide to use value for something
+    IndexEntryUpdate<IndexDescriptor>[] someUpdates( RandomRule randomRule )
+    {
+        Iterator<IndexEntryUpdate<IndexDescriptor>> randomUpdateGenerator = randomUpdateGenerator( randomRule );
+        //noinspection unchecked
+        IndexEntryUpdate<IndexDescriptor>[] result = new IndexEntryUpdate[N_VALUES];
+        for ( int i = 0; i < N_VALUES; i++ )
+        {
+            result[i] = randomUpdateGenerator.next();
+        }
+        return result;
     }
 
     Iterator<IndexEntryUpdate<IndexDescriptor>> randomUpdateGenerator( RandomRule randomRule )
     {
         Iterator<Value> valueIterator = randomValueGenerator( randomRule );
-        return new PrefetchingIterator<IndexEntryUpdate<IndexDescriptor>>()
-        {
-            private long currentEntityId;
-
-            @Override
-            protected IndexEntryUpdate<IndexDescriptor> fetchNextOrNull()
-            {
-                Value value = valueIterator.next();
-                return add( currentEntityId++, value );
-            }
-        };
+        return new RandomUpdateGenerator( valueIterator );
     }
 
     private Iterator<Value> randomValueGenerator( RandomRule randomRule )
     {
         RandomValues randomValues = randomRule.randomValues();
         double fractionDuplicates = fractionDuplicates();
-        return new PrefetchingIterator<Value>()
-        {
-            private final Set<Value> uniqueCompareValues = new HashSet<>();
-            private final List<Value> uniqueValues = new ArrayList<>();
-
-            @Override
-            protected Value fetchNextOrNull()
-            {
-                Value value;
-                if ( fractionDuplicates > 0 && !uniqueValues.isEmpty() &&
-                        randomValues.nextFloat() < fractionDuplicates )
-                {
-                    value = randomValues.among( uniqueValues );
-                }
-                else
-                {
-                    value = newUniqueValue( randomValues, uniqueCompareValues, uniqueValues );
-                }
-
-                return value;
-            }
-        };
-    }
-
-    private Value newUniqueValue( RandomValues random, Set<Value> uniqueCompareValues, List<Value> uniqueValues )
-    {
-        Value value;
-        do
-        {
-            value = random.nextValueOfTypes( supportedTypes() );
-        }
-        while ( !uniqueCompareValues.add( value ) );
-        uniqueValues.add( value );
-        return value;
-    }
-
-    Value[] extractValuesFromUpdates( IndexEntryUpdate<IndexDescriptor>[] updates )
-    {
-        Value[] values = new Value[updates.length];
-        for ( int i = 0; i < updates.length; i++ )
-        {
-            if ( updates[i].values().length > 1 )
-            {
-                throw new UnsupportedOperationException( "This method does not support composite entries" );
-            }
-            values[i] = updates[i].values()[0];
-        }
-        return values;
+        return new RandomValueGenerator( fractionDuplicates, randomValues );
     }
 
     IndexEntryUpdate<IndexDescriptor>[] someUpdatesWithDuplicateValues( RandomRule randomRule )
@@ -181,6 +120,20 @@ IndexEntryUpdate<IndexDescriptor>[] generateAddUpdatesFor( Value[] values )
         return indexEntryUpdates;
     }
 
+    Value[] extractValuesFromUpdates( IndexEntryUpdate<IndexDescriptor>[] updates )
+    {
+        Value[] values = new Value[updates.length];
+        for ( int i = 0; i < updates.length; i++ )
+        {
+            if ( updates[i].values().length > 1 )
+            {
+                throw new UnsupportedOperationException( "This method does not support composite entries" );
+            }
+            values[i] = updates[i].values()[0];
+        }
+        return values;
+    }
+
     protected IndexEntryUpdate<IndexDescriptor> add( long nodeId, Value value )
     {
         return IndexEntryUpdate.add( nodeId, indexDescriptor, value );
@@ -200,4 +153,71 @@ void sort( IndexEntryUpdate<IndexDescriptor>[] updates )
     {
         Arrays.sort( updates, UPDATE_COMPARATOR );
     }
+
+    void copyValue( VALUE value, VALUE intoValue )
+    {   // no-op until we decide to use value for something
+    }
+
+    private class RandomValueGenerator extends PrefetchingIterator<Value>
+    {
+        private final Set<Value> uniqueCompareValues;
+        private final List<Value> uniqueValues;
+        private final double fractionDuplicates;
+        private final RandomValues randomValues;
+
+        RandomValueGenerator( double fractionDuplicates, RandomValues randomValues )
+        {
+            this.fractionDuplicates = fractionDuplicates;
+            this.randomValues = randomValues;
+            this.uniqueCompareValues = new HashSet<>();
+            this.uniqueValues = new ArrayList<>();
+        }
+
+        @Override
+        protected Value fetchNextOrNull()
+        {
+            Value value;
+            if ( fractionDuplicates > 0 && !uniqueValues.isEmpty() &&
+                    randomValues.nextFloat() < fractionDuplicates )
+            {
+                value = randomValues.among( uniqueValues );
+            }
+            else
+            {
+                value = newUniqueValue( randomValues, uniqueCompareValues, uniqueValues );
+            }
+
+            return value;
+        }
+
+        private Value newUniqueValue( RandomValues random, Set<Value> uniqueCompareValues, List<Value> uniqueValues )
+        {
+            Value value;
+            do
+            {
+                value = random.nextValueOfTypes( supportedTypes() );
+            }
+            while ( !uniqueCompareValues.add( value ) );
+            uniqueValues.add( value );
+            return value;
+        }
+    }
+
+    private class RandomUpdateGenerator extends PrefetchingIterator<IndexEntryUpdate<IndexDescriptor>>
+    {
+        private final Iterator<Value> valueIterator;
+        private long currentEntityId;
+
+        RandomUpdateGenerator( Iterator<Value> valueIterator )
+        {
+            this.valueIterator = valueIterator;
+        }
+
+        @Override
+        protected IndexEntryUpdate<IndexDescriptor> fetchNextOrNull()
+        {
+            Value value = valueIterator.next();
+            return add( currentEntityId++, value );
+        }
+    }
 }