1 files changed, 167 insertions, 0 deletions
diff --git a/jstests/core/index/geo/geo_s2intersection.js b/jstests/core/index/geo/geo_s2intersection.js
new file mode 100644
index 00000000000..958da005a9f
--- /dev/null
+++ b/jstests/core/index/geo/geo_s2intersection.js
@@ -0,0 +1,167 @@
+/**
+ * Tests $geoIntersect basic functionality.
+ */
+(function() {
+"use strict";
+
+var t = db.geo_s2intersectinglines;
+t.drop();
+t.createIndex({geo: "2dsphere"});
+
+/**All the tests in this file are generally confirming intersections based upon
+ * these three geo objects.
+ */
+var canonLine = {
+    name: 'canonLine',
+    geo: {type: "LineString", coordinates: [[0.0, 0.0], [1.0, 0.0]]}
+};
+
+var canonPoint = {name: 'canonPoint', geo: {type: "Point", coordinates: [10.0, 10.0]}};
+
+var canonPoly = {
+    name: 'canonPoly',
+    geo: {
+        type: "Polygon",
+        coordinates: [[[50.0, 50.0], [51.0, 50.0], [51.0, 51.0], [50.0, 51.0], [50.0, 50.0]]]
+    }
+};
+
+t.insert(canonLine);
+t.insert(canonPoint);
+t.insert(canonPoly);
+
+// Case 1: Basic sanity intersection.
+var testLine = {type: "LineString", coordinates: [[0.5, 0.5], [0.5, -0.5]]};
+
+var result = t.find({geo: {$geoIntersects: {$geometry: testLine}}});
+assert.eq(result.count(), 1);
+assert.eq(result[0]['name'], 'canonLine');
+
+// Case 2: Basic Polygon intersection.
+// we expect that the canonLine should intersect with this polygon.
+var testPoly = {
+    type: "Polygon",
+    coordinates: [[[0.4, -0.1], [0.4, 0.1], [0.6, 0.1], [0.6, -0.1], [0.4, -0.1]]]
+};
+
+result = t.find({geo: {$geoIntersects: {$geometry: testPoly}}});
+assert.eq(result.count(), 1);
+assert.eq(result[0]['name'], 'canonLine');
+
+// Case 3: Intersects the vertex of a line.
+// When a line intersects the vertex of a line, we expect this to
+// count as a geoIntersection.
+testLine = {
+    type: "LineString",
+    coordinates: [[0.0, 0.5], [0.0, -0.5]]
+};
+
+result = t.find({geo: {$geoIntersects: {$geometry: testLine}}});
+assert.eq(result.count(), 1);
+assert.eq(result[0]['name'], 'canonLine');
+
+// Case 4: Sanity no intersection.
+// This line just misses the canonLine in the negative direction.  This
+// should not count as a geoIntersection.
+testLine = {
+    type: "LineString",
+    coordinates: [[-0.1, 0.5], [-0.1, -0.5]]
+};
+
+result = t.find({geo: {$geoIntersects: {$geometry: testLine}}});
+assert.eq(result.count(), 0);
+
+// Case 5: Overlapping line - only partially overlaps.
+// Undefined behaviour: does intersect
+testLine = {
+    type: "LineString",
+    coordinates: [[-0.5, 0.0], [0.5, 0.0]]
+};
+
+var result = t.find({geo: {$geoIntersects: {$geometry: testLine}}});
+assert.eq(result.count(), 1);
+assert.eq(result[0]['name'], 'canonLine');
+
+// Case 6: Contained line - this line is fully contained by the canonLine
+// Undefined behaviour: doesn't intersect.
+testLine = {
+    type: "LineString",
+    coordinates: [[0.1, 0.0], [0.9, 0.0]]
+};
+
+result = t.find({geo: {$geoIntersects: {$geometry: testLine}}});
+assert.eq(result.count(), 0);
+
+// Case 7: Identical line in the identical position.
+// Undefined behaviour: does intersect.
+testLine = {
+    type: "LineString",
+    coordinates: [[0.0, 0.0], [1.0, 0.0]]
+};
+
+result = t.find({geo: {$geoIntersects: {$geometry: testLine}}});
+assert.eq(result.count(), 1);
+assert.eq(result[0]['name'], 'canonLine');
+
+// Case 8: Point intersection - we search with a line that intersects
+// with the canonPoint.
+testLine = {
+    type: "LineString",
+    coordinates: [[10.0, 11.0], [10.0, 9.0]]
+};
+
+result = t.find({geo: {$geoIntersects: {$geometry: testLine}}});
+assert.eq(result.count(), 1);
+assert.eq(result[0]['name'], 'canonPoint');
+
+// Case 9: Point point intersection
+// as above but with an identical point to the canonPoint.  We expect an
+// intersection here.
+testPoint = {
+    type: "Point",
+    coordinates: [10.0, 10.0]
+};
+
+result = t.find({geo: {$geoIntersects: {$geometry: testPoint}}});
+assert.eq(result.count(), 1);
+assert.eq(result[0]['name'], 'canonPoint');
+
+// Case 10: Sanity point non-intersection.
+var testPoint = {type: "Point", coordinates: [12.0, 12.0]};
+
+result = t.find({geo: {$geoIntersects: {$geometry: testPoint}}});
+assert.eq(result.count(), 0);
+
+// Case 11: Point polygon intersection
+// verify that a point inside a polygon $geoIntersects.
+testPoint = {
+    type: "Point",
+    coordinates: [50.5, 50.5]
+};
+
+result = t.find({geo: {$geoIntersects: {$geometry: testPoint}}});
+assert.eq(result.count(), 1);
+assert.eq(result[0]['name'], 'canonPoly');
+
+// Case 12: Make sure that we properly handle and $and of two
+// $geoIntersects predicates.
+t.drop();
+t.createIndex({a: "2dsphere"});
+t.insert({a: {type: "Polygon", coordinates: [[[0, 0], [3, 6], [6, 0], [0, 0]]]}});
+
+var firstPoint = {$geometry: {type: "Point", coordinates: [3.0, 1.0]}};
+var secondPoint = {$geometry: {type: "Point", coordinates: [4.0, 1.0]}};
+
+// First point should intersect with the polygon.
+result = t.find({a: {$geoIntersects: firstPoint}});
+assert.eq(result.count(), 1);
+
+// Second point also intersects with the polygon.
+result = t.find({a: {$geoIntersects: secondPoint}});
+assert.eq(result.count(), 1);
+
+// Both points intersect with the polygon, so the $and of
+// two $geoIntersects should as well.
+result = t.find({$and: [{a: {$geoIntersects: firstPoint}}, {a: {$geoIntersects: secondPoint}}]});
+assert.eq(result.count(), 1);
+})();