Skip to content

Commit

Permalink
Neo4jPackV2Test use Randoms when creating random Values
Browse files Browse the repository at this point in the history 
This fixes a problem where Durations breaking Duration limit where created.
  • Loading branch information
@burqen
burqen committed Sep 5, 2018
1 parent 3a584fa commit 802ef3e
Show file tree
Hide file tree
Showing 3 changed files with 57 additions and 62 deletions.
94 changes: 36 additions & 58 deletions community/bolt/src/test/java/org/neo4j/bolt/v2/messaging/Neo4jPackV2Test.java
View file
Expand Up @@ -19,6 +19,7 @@
*/
package org.neo4j.bolt.v2.messaging;

import org.junit.Rule;
import org.junit.Test;

import java.io.IOException;
Expand All @@ -28,16 +29,14 @@
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoField;
import java.time.temporal.ValueRange;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.IntStream;

import org.neo4j.bolt.v1.messaging.Neo4jPack;
import org.neo4j.bolt.v1.packstream.PackedInputArray;
import org.neo4j.bolt.v1.packstream.PackedOutputArray;
import org.neo4j.test.rule.RandomRule;
import org.neo4j.values.AnyValue;
import org.neo4j.values.storable.CoordinateReferenceSystem;
import org.neo4j.values.storable.DateTimeValue;
Expand All @@ -52,15 +51,6 @@

import static java.nio.charset.StandardCharsets.UTF_8;
import static java.time.ZoneOffset.UTC;
import static java.time.temporal.ChronoField.DAY_OF_MONTH;
import static java.time.temporal.ChronoField.EPOCH_DAY;
import static java.time.temporal.ChronoField.HOUR_OF_DAY;
import static java.time.temporal.ChronoField.MINUTE_OF_HOUR;
import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
import static java.time.temporal.ChronoField.NANO_OF_DAY;
import static java.time.temporal.ChronoField.NANO_OF_SECOND;
import static java.time.temporal.ChronoField.SECOND_OF_MINUTE;
import static java.time.temporal.ChronoField.YEAR;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.neo4j.bolt.v1.packstream.PackStream.INT_16;
Expand All @@ -70,11 +60,10 @@
import static org.neo4j.values.storable.CoordinateReferenceSystem.WGS84;
import static org.neo4j.values.storable.CoordinateReferenceSystem.WGS84_3D;
import static org.neo4j.values.storable.DateTimeValue.datetime;
import static org.neo4j.values.storable.DateValue.epochDate;
import static org.neo4j.values.storable.DateValue.date;
import static org.neo4j.values.storable.DurationValue.duration;
import static org.neo4j.values.storable.LocalDateTimeValue.localDateTime;
import static org.neo4j.values.storable.LocalTimeValue.localTime;
import static org.neo4j.values.storable.TimeValue.time;
import static org.neo4j.values.storable.Values.doubleValue;
import static org.neo4j.values.storable.Values.intValue;
import static org.neo4j.values.storable.Values.unsafePointValue;
Expand All @@ -91,6 +80,9 @@ public class Neo4jPackV2Test
private static final int RANDOM_LISTS_TO_TEST = 1_000;
private static final int RANDOM_LIST_MAX_SIZE = 500;

@Rule
public RandomRule random = new RandomRule();

@Test
public void shouldFailToPackPointWithIllegalDimensions()
{
Expand Down Expand Up @@ -173,6 +165,12 @@ public void shouldPackAndUnpackDuration()
testPackingAndUnpacking( this::randomDuration );
}

@Test
public void shouldPackAndUnpackPeriod()
{
testPackingAndUnpacking( this::randomPeriod );
}

@Test
public void shouldPackAndUnpackListsOfDuration()
{
Expand Down Expand Up @@ -306,7 +304,7 @@ private static <T extends AnyValue> void testPackingAndUnpacking( Function<Integ
} );
}

private static void testPackingPointsWithWrongDimensions( int dimensions )
private void testPackingPointsWithWrongDimensions( int dimensions )
{
PointValue point = randomPoint( 0, dimensions );
try
Expand Down Expand Up @@ -357,15 +355,15 @@ private static <T extends AnyValue> T unpack( PackedOutputArray output )
}
}

private static <T extends AnyValue> ListValue randomList( Supplier<T> randomValueGenerator )
private <T extends AnyValue> ListValue randomList( Supplier<T> randomValueGenerator )
{
return randomList( index -> randomValueGenerator.get() );
}

private static <T extends AnyValue> ListValue randomList( Function<Integer,T> randomValueGenerator )
private <T extends AnyValue> ListValue randomList( Function<Integer,T> randomValueGenerator )
{
AnyValue[] values = random().ints( RANDOM_LISTS_TO_TEST, 1, RANDOM_LIST_MAX_SIZE )
.mapToObj( index -> randomValueGenerator.apply( index ) )
AnyValue[] values = random.ints( RANDOM_LISTS_TO_TEST, 1, RANDOM_LIST_MAX_SIZE )
.mapToObj( randomValueGenerator::apply )
.toArray( AnyValue[]::new );

return list( values );
Expand All @@ -381,7 +379,7 @@ private PointValue randomPoint3D( int index )
return randomPoint( index, 3 );
}

private static PointValue randomPoint( int index, int dimension )
private PointValue randomPoint( int index, int dimension )
{
CoordinateReferenceSystem crs;
if ( index % 2 == 0 )
Expand All @@ -393,77 +391,57 @@ private static PointValue randomPoint( int index, int dimension )
crs = dimension == 2 ? Cartesian : Cartesian_3D;
}

return unsafePointValue( crs, random().doubles( dimension, Double.MIN_VALUE, Double.MAX_VALUE ).toArray() );
return unsafePointValue( crs, random.doubles( dimension, Double.MIN_VALUE, Double.MAX_VALUE ).toArray() );
}

private DurationValue randomDuration( int index )
private DurationValue randomDuration()
{
return duration( randomLong( index ), randomLong( index ), randomLong( index ), randomLong( index ) );
return duration( random.randoms().randomDuration() );
}

private DurationValue randomPeriod()
{
return duration( random.randoms().randomPeriod() );
}

private DateValue randomDate()
{
return epochDate( random( EPOCH_DAY ) );
return date( random.randoms().randomDate() );
}

private LocalTimeValue randomLocalTime()
{
return localTime( random( NANO_OF_DAY ) );
return localTime( random.randoms().randomLocalTime() );
}

private TimeValue randomTime()
{
return time( random( NANO_OF_DAY ), randomZoneOffset() );
return TimeValue.time( random.randoms().randomTime() );
}

private LocalDateTimeValue randomLocalDateTime()
{
return localDateTime( random( YEAR ), random( MONTH_OF_YEAR ), random( DAY_OF_MONTH ), random( HOUR_OF_DAY ),
random( MINUTE_OF_HOUR ), random( SECOND_OF_MINUTE ), random( NANO_OF_SECOND ) );
return localDateTime( random.randoms().randomLocalDateTime() );
}

private DateTimeValue randomDateTimeWithTimeZoneName()
{
return datetime( random( YEAR ), random( MONTH_OF_YEAR ), random( DAY_OF_MONTH ), random( HOUR_OF_DAY ),
random( MINUTE_OF_HOUR ), random( SECOND_OF_MINUTE ), random( NANO_OF_SECOND ), randomZoneIdWithName() );
return datetime( random.randoms().randomDateTime( randomZoneIdWithName() ) );
}

private DateTimeValue randomDateTimeWithTimeZoneOffset()
{
return datetime( random( YEAR ), random( MONTH_OF_YEAR ), random( DAY_OF_MONTH ), random( HOUR_OF_DAY ),
random( MINUTE_OF_HOUR ), random( SECOND_OF_MINUTE ), random( NANO_OF_SECOND ), randomZoneOffset() );
}

private static long randomLong( long origin )
{
return random().nextLong( origin, Long.MAX_VALUE );
}

private static int random( ChronoField chronoField )
{
ValueRange range = chronoField.range();
int min = (int) range.getMinimum();
int max = (int) range.getSmallestMaximum();
if ( max != range.getSmallestMaximum() )
{
max = Integer.MAX_VALUE;
}
return random().nextInt( min, max );
return datetime( random.randoms().randomDateTime( randomZoneOffset() ) );
}

private static ZoneOffset randomZoneOffset()
private ZoneOffset randomZoneOffset()
{
return ZoneOffset.ofTotalSeconds( random().nextInt( ZoneOffset.MIN.getTotalSeconds(), ZoneOffset.MAX.getTotalSeconds() + 1 ) );
return ZoneOffset.ofTotalSeconds( random.nextInt( ZoneOffset.MIN.getTotalSeconds(), ZoneOffset.MAX.getTotalSeconds() ) );
}

private static ZoneId randomZoneIdWithName()
private ZoneId randomZoneIdWithName()
{
String timeZoneName = TIME_ZONE_NAMES[random().nextInt( TIME_ZONE_NAMES.length )];
String timeZoneName = TIME_ZONE_NAMES[ random.nextInt( TIME_ZONE_NAMES.length )];
return ZoneId.of( timeZoneName );
}

private static ThreadLocalRandom random()
{
return ThreadLocalRandom.current();
}
}
13 changes: 9 additions & 4 deletions community/common/src/test/java/org/neo4j/test/Randoms.java
View file
Expand Up @@ -27,9 +27,9 @@
import java.time.LocalTime;
import java.time.OffsetTime;
import java.time.Period;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAmount;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
Expand Down Expand Up @@ -349,16 +349,21 @@ private Instant randomInstant()

public ZonedDateTime randomDateTime()
{
return ZonedDateTime.ofInstant( randomInstant(), UTC );
return randomDateTime( UTC );
}

public TemporalAmount randomPeriod()
public ZonedDateTime randomDateTime( ZoneId zoneId )
{
return ZonedDateTime.ofInstant( randomInstant(), zoneId );
}

public Period randomPeriod()
{
// Based on Java period (years, months and days)
return Period.of( random.nextInt(), random.nextInt( 12 ), random.nextInt( 28 ) );
}

public TemporalAmount randomDuration()
public Duration randomDuration()
{
// Based on java duration (seconds)
return Duration.of( nextLong( DAYS.getDuration().getSeconds() ), ChronoUnit.SECONDS );
Expand Down
12 changes: 12 additions & 0 deletions community/common/src/test/java/org/neo4j/test/rule/RandomRule.java
View file
Expand Up @@ -31,6 +31,8 @@
import java.util.List;
import java.util.Random;
import java.util.function.Consumer;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;

import org.neo4j.helpers.Exceptions;
import org.neo4j.test.Randoms;
Expand Down Expand Up @@ -134,6 +136,11 @@ public double nextDouble()
return random.nextDouble();
}

public DoubleStream doubles( int dimension, double minValue, double maxValue )
{
return random.doubles( dimension, minValue, maxValue );
}

public float nextFloat()
{
return random.nextFloat();
Expand All @@ -154,6 +161,11 @@ public int nextInt( int origin, int bound )
return random.nextInt( (bound - origin) + 1 ) + origin;
}

public IntStream ints( long streamSize, int randomNumberOrigin, int randomNumberBound )
{
return random.ints( streamSize, randomNumberOrigin, randomNumberBound );
}

public double nextGaussian()
{
return random.nextGaussian();
Expand Down

0 comments on commit 802ef3e

Please sign in to comment.