lucene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jpou...@apache.org
Subject [2/4] lucene-solr:master: Revert "Make the nightly test smaller so that it does not fail with GC overhead exceeded (OOM). Clean up random number fetching to make it shorter."
Date Wed, 01 Aug 2018 13:45:39 GMT
Revert "Make the nightly test smaller so that it does not fail with GC overhead exceeded (OOM).
Clean up random number fetching to make it shorter."

This reverts commit 3203e99d8fbcaac3458fcf882d4ec229f97dfa43.


Project: http://git-wip-us.apache.org/repos/asf/lucene-solr/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucene-solr/commit/e56c8722
Tree: http://git-wip-us.apache.org/repos/asf/lucene-solr/tree/e56c8722
Diff: http://git-wip-us.apache.org/repos/asf/lucene-solr/diff/e56c8722

Branch: refs/heads/master
Commit: e56c8722ce99338e980b32e100b96f2c19af9ddf
Parents: 86a39fa
Author: Adrien Grand <jpountz@gmail.com>
Authored: Wed Aug 1 15:44:57 2018 +0200
Committer: Adrien Grand <jpountz@gmail.com>
Committed: Wed Aug 1 15:44:57 2018 +0200

----------------------------------------------------------------------
 .../lucene/document/TestLatLonShapeQueries.java | 15 ++---
 .../java/org/apache/lucene/geo/GeoTestUtil.java | 70 ++++++++++----------
 2 files changed, 42 insertions(+), 43 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/e56c8722/lucene/sandbox/src/test/org/apache/lucene/document/TestLatLonShapeQueries.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/test/org/apache/lucene/document/TestLatLonShapeQueries.java
b/lucene/sandbox/src/test/org/apache/lucene/document/TestLatLonShapeQueries.java
index 21d4e83..03941b9 100644
--- a/lucene/sandbox/src/test/org/apache/lucene/document/TestLatLonShapeQueries.java
+++ b/lucene/sandbox/src/test/org/apache/lucene/document/TestLatLonShapeQueries.java
@@ -45,8 +45,6 @@ import org.apache.lucene.util.FixedBitSet;
 import org.apache.lucene.util.IOUtils;
 import org.apache.lucene.util.LuceneTestCase;
 
-import static com.carrotsearch.randomizedtesting.RandomizedTest.randomBoolean;
-import static com.carrotsearch.randomizedtesting.RandomizedTest.randomInt;
 import static org.apache.lucene.geo.GeoEncodingUtils.decodeLatitude;
 import static org.apache.lucene.geo.GeoEncodingUtils.decodeLongitude;
 import static org.apache.lucene.geo.GeoEncodingUtils.encodeLatitude;
@@ -106,7 +104,7 @@ public class TestLatLonShapeQueries extends LuceneTestCase {
 
   @Nightly
   public void testRandomBig() throws Exception {
-    doTestRandom(50000);
+    doTestRandom(200000);
   }
 
   private void doTestRandom(int count) throws Exception {
@@ -118,7 +116,7 @@ public class TestLatLonShapeQueries extends LuceneTestCase {
 
     Polygon[] polygons = new Polygon[numPolygons];
     for (int id = 0; id < numPolygons; ++id) {
-      int x = randomInt(20);
+      int x = random().nextInt(20);
       if (x == 17) {
         polygons[id] = null;
         if (VERBOSE) {
@@ -129,7 +127,6 @@ public class TestLatLonShapeQueries extends LuceneTestCase {
         polygons[id] = GeoTestUtil.nextPolygon();
       }
     }
-
     verify(polygons);
   }
 
@@ -176,8 +173,8 @@ public class TestLatLonShapeQueries extends LuceneTestCase {
         poly2D[id] = Polygon2D.create(quantizePolygon(polygons[id]));
       }
       w.addDocument(doc);
-      if (id > 0 && randomInt(100) == 42) {
-        int idToDelete = randomInt(id);
+      if (id > 0 && random().nextInt(100) == 42) {
+        int idToDelete = random().nextInt(id);
         w.deleteDocuments(new Term("id", ""+idToDelete));
         deleted.add(idToDelete);
         if (VERBOSE) {
@@ -186,7 +183,7 @@ public class TestLatLonShapeQueries extends LuceneTestCase {
       }
     }
 
-    if (randomBoolean()) {
+    if (random().nextBoolean()) {
       w.forceMerge(1);
     }
     final IndexReader r = DirectoryReader.open(w);
@@ -201,7 +198,7 @@ public class TestLatLonShapeQueries extends LuceneTestCase {
 
     for (int iter = 0; iter < iters; ++iter) {
       if (VERBOSE) {
-        System.out.println("\nTEST: iter=" + (iter + 1) + " of " + iters + " s=" + s);
+        System.out.println("\nTEST: iter=" + (iter+1) + " of " + iters + " s=" + s);
       }
 
       // BBox

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/e56c8722/lucene/test-framework/src/java/org/apache/lucene/geo/GeoTestUtil.java
----------------------------------------------------------------------
diff --git a/lucene/test-framework/src/java/org/apache/lucene/geo/GeoTestUtil.java b/lucene/test-framework/src/java/org/apache/lucene/geo/GeoTestUtil.java
index 8817d20..fe81fd6 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/geo/GeoTestUtil.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/geo/GeoTestUtil.java
@@ -19,16 +19,13 @@ package org.apache.lucene.geo;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Random;
 
 import org.apache.lucene.util.NumericUtils;
 import org.apache.lucene.util.SloppyMath;
 import org.apache.lucene.util.TestUtil;
 
-import static com.carrotsearch.randomizedtesting.RandomizedTest.randomBoolean;
-import static com.carrotsearch.randomizedtesting.RandomizedTest.randomDouble;
-import static com.carrotsearch.randomizedtesting.RandomizedTest.randomInt;
-import static com.carrotsearch.randomizedtesting.RandomizedTest.randomIntBetween;
-import static org.apache.lucene.util.LuceneTestCase.random;
+import com.carrotsearch.randomizedtesting.RandomizedContext;
 
 /** static methods for testing geo */
 public class GeoTestUtil {
@@ -66,7 +63,7 @@ public class GeoTestUtil {
 
     // first pick a base value.
     final double baseValue;
-    int surpriseMe = randomInt(17);
+    int surpriseMe = random().nextInt(17);
     if (surpriseMe == 0) {
       // random bits
       long lowBits = NumericUtils.doubleToSortableLong(low);
@@ -84,18 +81,18 @@ public class GeoTestUtil {
     } else if (surpriseMe == 4) {
       // divide up space into block of 360
       double delta = (high - low) / 360;
-      int block = randomInt(360);
+      int block = random().nextInt(360);
       baseValue = low + delta * block;
     } else {
       // distributed ~ evenly
-      baseValue = low + (high - low) * randomDouble();
+      baseValue = low + (high - low) * random().nextDouble();
     }
 
     assert baseValue >= low;
     assert baseValue <= high;
 
     // either return the base value or adjust it by 1 ulp in a random direction (if possible)
-    int adjustMe = randomInt(17);
+    int adjustMe = random().nextInt(17);
     if (adjustMe == 0) {
       return Math.nextAfter(adjustMe, high);
     } else if (adjustMe == 1) {
@@ -109,7 +106,7 @@ public class GeoTestUtil {
   private static double nextLatitudeNear(double otherLatitude, double delta) {
     delta = Math.abs(delta);
     GeoUtils.checkLatitude(otherLatitude);
-    int surpriseMe = randomInt(97);
+    int surpriseMe = random().nextInt(97);
     if (surpriseMe == 0) {
       // purely random
       return nextLatitude();
@@ -126,7 +123,7 @@ public class GeoTestUtil {
   private static double nextLongitudeNear(double otherLongitude, double delta) {
     delta = Math.abs(delta);
     GeoUtils.checkLongitude(otherLongitude);
-    int surpriseMe = randomInt(97);
+    int surpriseMe = random().nextInt(97);
     if (surpriseMe == 0) {
       // purely random
       return nextLongitude();
@@ -148,7 +145,7 @@ public class GeoTestUtil {
     assert maxLatitude >= minLatitude;
     GeoUtils.checkLatitude(minLatitude);
     GeoUtils.checkLatitude(maxLatitude);
-    if (randomInt(47) == 0) {
+    if (random().nextInt(47) == 0) {
       // purely random
       return nextLatitude();
     } else {
@@ -169,7 +166,7 @@ public class GeoTestUtil {
     assert maxLongitude >= minLongitude;
     GeoUtils.checkLongitude(minLongitude);
     GeoUtils.checkLongitude(maxLongitude);
-    if (randomInt(47) == 0) {
+    if (random().nextInt(47) == 0) {
       // purely random
       return nextLongitude();
     } else {
@@ -214,7 +211,7 @@ public class GeoTestUtil {
   public static double[] nextPointNear(Rectangle rectangle) {
     if (rectangle.crossesDateline()) {
       // pick a "side" of the two boxes we really are
-      if (randomBoolean()) {
+      if (random().nextBoolean()) {
         return nextPointNear(new Rectangle(rectangle.minLat, rectangle.maxLat, -180, rectangle.maxLon));
       } else {
         return nextPointNear(new Rectangle(rectangle.minLat, rectangle.maxLat, rectangle.minLon,
180));
@@ -232,11 +229,11 @@ public class GeoTestUtil {
     Polygon holes[] = polygon.getHoles();
 
     // if there are any holes, target them aggressively
-    if (holes.length > 0 && randomInt(3) == 0) {
-      return nextPointNear(holes[randomInt(holes.length)]);
+    if (holes.length > 0 && random().nextInt(3) == 0) {
+      return nextPointNear(holes[random().nextInt(holes.length)]);
     }
 
-    int surpriseMe = randomInt(97);
+    int surpriseMe = random().nextInt(97);
     if (surpriseMe == 0) {
       // purely random
       return new double[] { nextLatitude(), nextLongitude() };
@@ -245,7 +242,7 @@ public class GeoTestUtil {
       return new double[] { nextLatitudeBetween(polygon.minLat, polygon.maxLat), nextLongitudeBetween(polygon.minLon,
polygon.maxLon) };
     } else if (surpriseMe < 20) {
       // target a vertex
-      int vertex = randomInt(polyLats.length - 1);
+      int vertex = random().nextInt(polyLats.length - 1);
       return new double[] { nextLatitudeNear(polyLats[vertex], polyLats[vertex+1] - polyLats[vertex]),

                             nextLongitudeNear(polyLons[vertex], polyLons[vertex+1] - polyLons[vertex])
};
     } else if (surpriseMe < 30) {
@@ -253,14 +250,14 @@ public class GeoTestUtil {
       Polygon container = boxPolygon(new Rectangle(polygon.minLat, polygon.maxLat, polygon.minLon,
polygon.maxLon));
       double containerLats[] = container.getPolyLats();
       double containerLons[] = container.getPolyLons();
-      int startVertex = randomInt(containerLats.length - 1);
+      int startVertex = random().nextInt(containerLats.length - 1);
       return nextPointAroundLine(containerLats[startVertex], containerLons[startVertex],

                                  containerLats[startVertex+1], containerLons[startVertex+1]);
     } else {
       // target points around diagonals between vertices
-      int startVertex = randomInt(polyLats.length - 1);
+      int startVertex = random().nextInt(polyLats.length - 1);
       // but favor edges heavily
-      int endVertex = randomBoolean() ? startVertex + 1 : randomInt(polyLats.length - 1);
+      int endVertex = random().nextBoolean() ? startVertex + 1 : random().nextInt(polyLats.length
- 1);
       return nextPointAroundLine(polyLats[startVertex], polyLons[startVertex], 
                                  polyLats[endVertex],   polyLons[endVertex]);
     }
@@ -273,11 +270,11 @@ public class GeoTestUtil {
     
     // if there are any holes, target them aggressively
     Polygon holes[] = polygon.getHoles();
-    if (holes.length > 0 && randomInt(3) == 0) {
-      return nextBoxNear(holes[randomInt(holes.length)]);
+    if (holes.length > 0 && random().nextInt(3) == 0) {
+      return nextBoxNear(holes[random().nextInt(holes.length)]);
     }
     
-    int surpriseMe = randomInt(97);
+    int surpriseMe = random().nextInt(97);
     if (surpriseMe == 0) {
       // formed from two interesting points
       point1 = nextPointNear(polygon);
@@ -289,7 +286,7 @@ public class GeoTestUtil {
       // now figure out a good delta: we use a rough heuristic, up to the length of an edge
       double polyLats[] = polygon.getPolyLats();
       double polyLons[] = polygon.getPolyLons();
-      int vertex = randomInt(polyLats.length - 1);
+      int vertex = random().nextInt(polyLats.length - 1);
       double deltaX = polyLons[vertex+1] - polyLons[vertex];
       double deltaY = polyLats[vertex+1] - polyLats[vertex];
       double edgeLength = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
@@ -389,14 +386,14 @@ public class GeoTestUtil {
 
   /** returns next pseudorandom polygon */
   public static Polygon nextPolygon() {
-    if (randomBoolean()) {
+    if (random().nextBoolean()) {
       return surpriseMePolygon();
-    } else if (randomInt(10) == 1) {
+    } else if (random().nextInt(10) == 1) {
       // this poly is slow to create ... only do it 10% of the time:
       while (true) {
-        int gons = randomIntBetween(4, 500);
+        int gons = TestUtil.nextInt(random(), 4, 500);
         // So the poly can cover at most 50% of the earth's surface:
-        double radiusMeters = randomDouble() * GeoUtils.EARTH_MEAN_RADIUS_METERS * Math.PI
/ 2.0 + 1.0;
+        double radiusMeters = random().nextDouble() * GeoUtils.EARTH_MEAN_RADIUS_METERS *
Math.PI / 2.0 + 1.0;
         try {
           return createRegularPolygon(nextLatitude(), nextLongitude(), radiusMeters, gons);
         } catch (IllegalArgumentException iae) {
@@ -406,7 +403,7 @@ public class GeoTestUtil {
     }
 
     Rectangle box = nextBoxInternal(false);
-    if (randomBoolean()) {
+    if (random().nextBoolean()) {
       // box
       return boxPolygon(box);
     } else {
@@ -483,19 +480,19 @@ public class GeoTestUtil {
       //System.out.println("\nPOLY ITER");
       double centerLat = nextLatitude();
       double centerLon = nextLongitude();
-      double radius = 0.1 + 20 * randomDouble();
-      double radiusDelta = randomDouble();
+      double radius = 0.1 + 20 * random().nextDouble();
+      double radiusDelta = random().nextDouble();
 
       ArrayList<Double> lats = new ArrayList<>();
       ArrayList<Double> lons = new ArrayList<>();
       double angle = 0.0;
       while (true) {
-        angle += randomDouble() * 40.0;
+        angle += random().nextDouble()*40.0;
         //System.out.println("  angle " + angle);
         if (angle > 360) {
           break;
         }
-        double len = radius * (1.0 - radiusDelta + radiusDelta * randomDouble());
+        double len = radius * (1.0 - radiusDelta + radiusDelta * random().nextDouble());
         //System.out.println("    len=" + len);
         double lat = centerLat + len * Math.cos(SloppyMath.toRadians(angle));
         double lon = centerLon + len * Math.sin(SloppyMath.toRadians(angle));
@@ -524,6 +521,11 @@ public class GeoTestUtil {
     }
   }
 
+  /** Keep it simple, we don't need to take arbitrary Random for geo tests */
+  private static Random random() {
+   return RandomizedContext.current().getRandom();
+  }
+
   /** 
    * Returns svg of polygon for debugging. 
    * <p>


Mime
View raw message