@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/s2/s2shapeutil_edge_iterator.h

@@ -0,0 +1,72 @@
+// Copyright Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef S2_S2SHAPEUTIL_EDGE_ITERATOR_H_
+#define S2_S2SHAPEUTIL_EDGE_ITERATOR_H_
+
+#include "s2/s2shape_index.h"
+#include "s2/s2shapeutil_shape_edge_id.h"
+
+namespace s2shapeutil {
+
+// An iterator that advances through all edges in an S2ShapeIndex.
+//
+// Example usage:
+//
+// for (EdgeIterator it(index); !it.Done(); it.Next()) {
+//   auto edge = it.edge();
+//   //...
+// }
+class EdgeIterator {
+ public:
+  explicit EdgeIterator(const S2ShapeIndex* index);
+
+  // Returns the current shape id.
+  int32 shape_id() const { return shape_id_; }
+
+  // Returns the current edge id.
+  int32 edge_id() const { return edge_id_; }
+
+  // Returns the current (shape_id, edge_id).
+  ShapeEdgeId shape_edge_id() const { return ShapeEdgeId(shape_id_, edge_id_); }
+
+  // Returns the current edge.
+  S2Shape::Edge edge() const;
+
+  // Returns true if there are no more edges in the index.
+  bool Done() const { return shape_id() >= index_->num_shape_ids(); }
+
+  // Advances to the next edge.
+  void Next();
+
+  bool operator==(const EdgeIterator& other) const {
+    return index_ == other.index_ && shape_id_ == other.shape_id_ &&
+           edge_id_ == other.edge_id_;
+  }
+
+  bool operator!=(const EdgeIterator& other) const { return !(*this == other); }
+
+  string DebugString() const;
+
+ private:
+  const S2ShapeIndex* index_;
+  int32 shape_id_;
+  int32 num_edges_;
+  int32 edge_id_;
+};
+
+}  // namespace s2shapeutil
+
+#endif  // S2_S2SHAPEUTIL_EDGE_ITERATOR_H_

package/third_party/s2geometry/src/s2/s2shapeutil_edge_iterator_test.cc

@@ -0,0 +1,116 @@
+// Copyright Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "s2/s2shapeutil_edge_iterator.h"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s2text_format.h"
+
+namespace s2shapeutil {
+
+namespace {
+
+// Returns the full list of edges in g.
+// The edges are collected from points, lines, and polygons in that order.
+std::vector<S2Shape::Edge> GetEdges(const S2ShapeIndex* index) {
+  std::vector<S2Shape::Edge> result;
+  for (S2Shape* shape : *index) {
+    if (shape == nullptr) continue;
+    for (int j = 0; j < shape->num_edges(); ++j) {
+      result.push_back(shape->edge(j));
+    }
+  }
+  return result;
+}
+
+// Verifies that the edges produced by an EdgeIterator matches GetEdges.
+void Verify(const S2ShapeIndex* index) {
+  std::vector<S2Shape::Edge> expected = GetEdges(index);
+
+  int i = 0;
+  for (EdgeIterator it(index); !it.Done(); it.Next(), ++i) {
+    ASSERT_TRUE(i < expected.size());
+    EXPECT_EQ(expected[i], it.edge());
+  }
+}
+
+}  // namespace
+
+TEST(S2ShapeutilEdgeIteratorTest, Empty) {
+  auto index = s2textformat::MakeIndex("##");
+  Verify(index.get());
+}
+
+TEST(S2ShapeutilEdgeIteratorTest, Points) {
+  auto index = s2textformat::MakeIndex("0:0|1:1##");
+  Verify(index.get());
+}
+
+TEST(S2ShapeutilEdgeIteratorTest, Lines) {
+  auto index = s2textformat::MakeIndex("#0:0,10:10|5:5,5:10|1:2,2:1#");
+  Verify(index.get());
+}
+
+TEST(S2ShapeutilEdgeIteratorTest, Polygons) {
+  auto index =
+      s2textformat::MakeIndex("##10:10,10:0,0:0|-10:-10,-10:0,0:0,0:-10");
+  Verify(index.get());
+}
+
+TEST(S2ShapeutilEdgeIteratorTest, Collection) {
+  auto index = s2textformat::MakeIndex(
+      "1:1|7:2#1:1,2:2,3:3|2:2,1:7#"
+      "10:10,10:0,0:0;20:20,20:10,10:10|15:15,15:0,0:0");
+  Verify(index.get());
+}
+
+TEST(S2ShapeutilEdgeIteratorTest, Remove) {
+  auto index = s2textformat::MakeIndex(
+      "1:1|7:2#1:1,2:2,3:3|2:2,1:7#"
+      "10:10,10:0,0:0;20:20,20:10,10:10|15:15,15:0,0:0");
+  index->Release(0);
+
+  Verify(index.get());
+}
+
+TEST(S2ShapeutilEdgeIteratorTest, AssignmentAndEquality) {
+  auto index1 = s2textformat::MakeIndex(
+      "1:1|7:2#1:1,2:2,3:3|2:2,1:7#"
+      "10:10,10:0,0:0;20:20,20:10,10:10|15:15,15:0,0:0");
+
+  auto index2 = s2textformat::MakeIndex(
+      "1:1|7:2#1:1,2:2,3:3|2:2,1:7#"
+      "10:10,10:0,0:0;20:20,20:10,10:10|15:15,15:0,0:0");
+
+  EdgeIterator it1(index1.get());
+  EdgeIterator it2(index2.get());
+
+  // Different indices.
+  EXPECT_TRUE(it1 != it2);
+
+  it1 = it2;
+  EXPECT_EQ(it1, it2);
+
+  it1.Next();
+  EXPECT_TRUE(it1 != it2);
+
+  it2.Next();
+  EXPECT_EQ(it1, it2);
+}
+
+}  // namespace s2shapeutil

package/third_party/s2geometry/src/s2/s2shapeutil_get_reference_point.cc

@@ -0,0 +1,107 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s2shapeutil_get_reference_point.h"
+
+#include <algorithm>
+
+#include "s2/base/logging.h"
+#include "s2/s2contains_vertex_query.h"
+
+using std::vector;
+using ReferencePoint = S2Shape::ReferencePoint;
+
+namespace s2shapeutil {
+
+// This is a helper function for GetReferencePoint() below.
+//
+// If the given vertex "vtest" is unbalanced (see definition below), sets
+// "result" to a ReferencePoint indicating whther "vtest" is contained and
+// returns true.  Otherwise returns false.
+static bool GetReferencePointAtVertex(
+    const S2Shape& shape, const S2Point& vtest, ReferencePoint* result) {
+  // Let P be an unbalanced vertex.  Vertex P is defined to be inside the
+  // region if the region contains a particular direction vector starting from
+  // P, namely the direction S2::Ortho(P).  This can be calculated using
+  // S2ContainsVertexQuery.
+  S2ContainsVertexQuery contains_query(vtest);
+  int n = shape.num_edges();
+  for (int e = 0; e < n; ++e) {
+    auto edge = shape.edge(e);
+    if (edge.v0 == vtest) contains_query.AddEdge(edge.v1, 1);
+    if (edge.v1 == vtest) contains_query.AddEdge(edge.v0, -1);
+  }
+  int contains_sign = contains_query.ContainsSign();
+  if (contains_sign == 0) {
+    return false;  // There are no unmatched edges incident to this vertex.
+  }
+  result->point = vtest;
+  result->contained = contains_sign > 0;
+  return true;
+}
+
+// See documentation in header file.
+S2Shape::ReferencePoint GetReferencePoint(const S2Shape& shape) {
+  S2_DCHECK_EQ(shape.dimension(), 2);
+  if (shape.num_edges() == 0) {
+    // A shape with no edges is defined to be full if and only if it
+    // contains at least one chain.
+    return ReferencePoint::Contained(shape.num_chains() > 0);
+  }
+  // Define a "matched" edge as one that can be paired with a corresponding
+  // reversed edge.  Define a vertex as "balanced" if all of its edges are
+  // matched. In order to determine containment, we must find an unbalanced
+  // vertex.  Often every vertex is unbalanced, so we start by trying an
+  // arbitrary vertex.
+  auto edge = shape.edge(0);
+  ReferencePoint result;
+  if (GetReferencePointAtVertex(shape, edge.v0, &result)) {
+    return result;
+  }
+  // That didn't work, so now we do some extra work to find an unbalanced
+  // vertex (if any).  Essentially we gather a list of edges and a list of
+  // reversed edges, and then sort them.  The first edge that appears in one
+  // list but not the other is guaranteed to be unmatched.
+  int n = shape.num_edges();
+  vector<S2Shape::Edge> edges(n), rev_edges(n);
+  for (int i = 0; i < n; ++i) {
+    auto edge = shape.edge(i);
+    edges[i] = edge;
+    rev_edges[i] = S2Shape::Edge(edge.v1, edge.v0);
+  }
+  std::sort(edges.begin(), edges.end());
+  std::sort(rev_edges.begin(), rev_edges.end());
+  for (int i = 0; i < n; ++i) {
+    if (edges[i] < rev_edges[i]) {  // edges[i] is unmatched
+      S2_CHECK(GetReferencePointAtVertex(shape, edges[i].v0, &result));
+      return result;
+    }
+    if (rev_edges[i] < edges[i]) {  // rev_edges[i] is unmatched
+      S2_CHECK(GetReferencePointAtVertex(shape, rev_edges[i].v0, &result));
+      return result;
+    }
+  }
+  // All vertices are balanced, so this polygon is either empty or full except
+  // for degeneracies.  By convention it is defined to be full if it contains
+  // any chain with no edges.
+  for (int i = 0; i < shape.num_chains(); ++i) {
+    if (shape.chain(i).length == 0) return ReferencePoint::Contained(true);
+  }
+  return ReferencePoint::Contained(false);
+}
+
+}  // namespace s2shapeutil

package/third_party/s2geometry/src/s2/s2shapeutil_get_reference_point.h

@@ -0,0 +1,48 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#ifndef S2_S2SHAPEUTIL_GET_REFERENCE_POINT_H_
+#define S2_S2SHAPEUTIL_GET_REFERENCE_POINT_H_
+
+#include "s2/s2shape_index.h"
+
+namespace s2shapeutil {
+
+// This is a helper function for implementing S2Shape::GetReferencePoint().
+//
+// Given a shape consisting of closed polygonal loops, the interior of the
+// shape is defined as the region to the left of all edges (which must be
+// oriented consistently).  This function then chooses an arbitrary point and
+// returns true if that point is contained by the shape.
+//
+// Unlike S2Loop and S2Polygon, this method allows duplicate vertices and
+// edges, which requires some extra care with definitions.  The rule that we
+// apply is that an edge and its reverse edge "cancel" each other: the result
+// is the same as if that edge pair were not present.  Therefore shapes that
+// consist only of degenerate loop(s) are either empty or full; by convention,
+// the shape is considered full if and only if it contains an empty loop (see
+// S2LaxPolygonShape for details).
+//
+// Determining whether a loop on the sphere contains a point is harder than
+// the corresponding problem in 2D plane geometry.  It cannot be implemented
+// just by counting edge crossings because there is no such thing as a "point
+// at infinity" that is guaranteed to be outside the loop.
+S2Shape::ReferencePoint GetReferencePoint(const S2Shape& shape);
+
+}  // namespace s2shapeutil
+
+#endif  // S2_S2SHAPEUTIL_GET_REFERENCE_POINT_H_

package/third_party/s2geometry/src/s2/s2shapeutil_get_reference_point_test.cc

@@ -0,0 +1,104 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s2shapeutil_get_reference_point.h"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/s2lax_polygon_shape.h"
+#include "s2/s2polygon.h"
+#include "s2/s2shapeutil_contains_brute_force.h"
+#include "s2/s2testing.h"
+#include "s2/s2text_format.h"
+
+using std::vector;
+
+namespace s2shapeutil {
+
+TEST(GetReferencePoint, EmptyPolygon) {
+  S2LaxPolygonShape shape((S2Polygon()));
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(GetReferencePoint, FullPolygon) {
+  S2LaxPolygonShape shape(S2Polygon(s2textformat::MakeLoopOrDie("full")));
+  EXPECT_TRUE(shape.GetReferencePoint().contained);
+}
+
+TEST(GetReferencePoint, DegenerateLoops) {
+  vector<S2LaxPolygonShape::Loop> loops = {
+    s2textformat::ParsePoints("1:1, 1:2, 2:2, 1:2, 1:3, 1:2, 1:1"),
+    s2textformat::ParsePoints("0:0, 0:3, 0:6, 0:9, 0:6, 0:3, 0:0"),
+    s2textformat::ParsePoints("5:5, 6:6")
+  };
+  S2LaxPolygonShape shape(loops);
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(GetReferencePoint, InvertedLoops) {
+  vector<S2LaxPolygonShape::Loop> loops = {
+    s2textformat::ParsePoints("1:2, 1:1, 2:2"),
+    s2textformat::ParsePoints("3:4, 3:3, 4:4")
+  };
+  S2LaxPolygonShape shape(loops);
+  EXPECT_TRUE(s2shapeutil::ContainsBruteForce(shape, S2::Origin()));
+}
+
+TEST(GetReferencePoint, PartiallyDegenerateLoops) {
+  for (int iter = 0; iter < 100; ++iter) {
+    // First we construct a long convoluted edge chain that follows the
+    // S2CellId Hilbert curve.  At some random point along the curve, we
+    // insert a small triangular loop.
+    vector<S2LaxPolygonShape::Loop> loops(1);
+    S2LaxPolygonShape::Loop* loop = &loops[0];
+    const int num_vertices = 100;
+    S2CellId start = S2Testing::GetRandomCellId(S2CellId::kMaxLevel - 1);
+    S2CellId end = start.advance_wrap(num_vertices);
+    S2CellId loop_cellid = start.advance_wrap(
+        S2Testing::rnd.Uniform(num_vertices - 2) + 1);
+    vector<S2Point> triangle;
+    for (S2CellId cellid = start; cellid != end; cellid = cellid.next_wrap()) {
+      if (cellid == loop_cellid) {
+        // Insert a small triangular loop.  We save the loop so that we can
+        // test whether it contains the origin later.
+        triangle.push_back(cellid.child(0).ToPoint());
+        triangle.push_back(cellid.child(1).ToPoint());
+        triangle.push_back(cellid.child(2).ToPoint());
+        loop->insert(loop->end(), triangle.begin(), triangle.end());
+        loop->push_back(cellid.child(0).ToPoint());
+      } else {
+        loop->push_back(cellid.ToPoint());
+      }
+    }
+    // Now we retrace our steps, except that we skip the three edges that form
+    // the triangular loop above.
+    for (S2CellId cellid = end; cellid != start; cellid = cellid.prev_wrap()) {
+      if (cellid == loop_cellid) {
+        loop->push_back(cellid.child(0).ToPoint());
+      } else {
+        loop->push_back(cellid.ToPoint());
+      }
+    }
+    S2LaxPolygonShape shape(loops);
+    S2Loop triangle_loop(triangle);
+    auto ref = shape.GetReferencePoint();
+    EXPECT_EQ(triangle_loop.Contains(ref.point), ref.contained);
+  }
+}
+
+}  // namespace s2shapeutil

package/third_party/s2geometry/src/s2/s2shapeutil_range_iterator.cc

@@ -0,0 +1,58 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s2shapeutil_range_iterator.h"
+
+namespace s2shapeutil {
+
+RangeIterator::RangeIterator(const S2ShapeIndex& index)
+    : it_(&index, S2ShapeIndex::BEGIN) {
+  Refresh();
+}
+
+void RangeIterator::Next() {
+  it_.Next();
+  Refresh();
+}
+
+void RangeIterator::SeekTo(const RangeIterator& target) {
+  it_.Seek(target.range_min());
+  // If the current cell does not overlap "target", it is possible that the
+  // previous cell is the one we are looking for.  This can only happen when
+  // the previous cell contains "target" but has a smaller S2CellId.
+  if (it_.done() || it_.id().range_min() > target.range_max()) {
+    if (it_.Prev() && it_.id().range_max() < target.id()) it_.Next();
+  }
+  Refresh();
+}
+
+void RangeIterator::SeekBeyond(const RangeIterator& target) {
+  it_.Seek(target.range_max().next());
+  if (!it_.done() && it_.id().range_min() <= target.range_max()) {
+    it_.Next();
+  }
+  Refresh();
+}
+
+// This method is inline, but is only called by non-inline methods defined in
+// this file.  Putting the definition here enforces this requirement.
+inline void RangeIterator::Refresh() {
+  range_min_ = id().range_min();
+  range_max_ = id().range_max();
+}
+
+}  // namespace s2shapeutil

package/third_party/s2geometry/src/s2/s2shapeutil_range_iterator.h

@@ -0,0 +1,65 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#ifndef S2_S2SHAPEUTIL_RANGE_ITERATOR_H_
+#define S2_S2SHAPEUTIL_RANGE_ITERATOR_H_
+
+#include "s2/s2cell_id.h"
+#include "s2/s2shape_index.h"
+
+class S2Loop;
+class S2Error;
+
+namespace s2shapeutil {
+
+// RangeIterator is a wrapper over S2ShapeIndex::Iterator with extra methods
+// that are useful for merging the contents of two or more S2ShapeIndexes.
+class RangeIterator {
+ public:
+  // Construct a new RangeIterator positioned at the first cell of the index.
+  explicit RangeIterator(const S2ShapeIndex& index);
+
+  // The current S2CellId and cell contents.
+  S2CellId id() const { return it_.id(); }
+  const S2ShapeIndexCell& cell() const { return it_.cell(); }
+
+  // The min and max leaf cell ids covered by the current cell.  If done() is
+  // true, these methods return a value larger than any valid cell id.
+  S2CellId range_min() const { return range_min_; }
+  S2CellId range_max() const { return range_max_; }
+
+  void Next();
+  bool done() { return it_.done(); }
+
+  // Position the iterator at the first cell that overlaps or follows
+  // "target", i.e. such that range_max() >= target.range_min().
+  void SeekTo(const RangeIterator& target);
+
+  // Position the iterator at the first cell that follows "target", i.e. the
+  // first cell such that range_min() > target.range_max().
+  void SeekBeyond(const RangeIterator& target);
+
+ private:
+  // Updates internal state after the iterator has been repositioned.
+  void Refresh();
+  S2ShapeIndex::Iterator it_;
+  S2CellId range_min_, range_max_;
+};
+
+}  // namespace s2shapeutil
+
+#endif  // S2_S2SHAPEUTIL_RANGE_ITERATOR_H_

package/third_party/s2geometry/src/s2/s2shapeutil_range_iterator_test.cc

@@ -0,0 +1,61 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s2shapeutil_range_iterator.h"
+
+#include <gtest/gtest.h>
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s2text_format.h"
+
+namespace s2shapeutil {
+
+TEST(RangeIterator, Next) {
+  // Create an index with one point each on S2CellId faces 0, 1, and 2.
+  auto index = s2textformat::MakeIndex("0:0 | 0:90 | 90:0 # #");
+  RangeIterator it(*index);
+  EXPECT_EQ(0, it.id().face());
+  it.Next();
+  EXPECT_EQ(1, it.id().face());
+  it.Next();
+  EXPECT_EQ(2, it.id().face());
+  it.Next();
+  EXPECT_EQ(S2CellId::Sentinel(), it.id());
+  EXPECT_TRUE(it.done());
+}
+
+TEST(RangeIterator, EmptyIndex) {
+  auto empty = s2textformat::MakeIndex("# #");
+  auto non_empty = s2textformat::MakeIndex("0:0 # #");
+  RangeIterator empty_it(*empty);
+  RangeIterator non_empty_it(*non_empty);
+  EXPECT_FALSE(non_empty_it.done());
+  EXPECT_TRUE(empty_it.done());
+
+  empty_it.SeekTo(non_empty_it);
+  EXPECT_TRUE(empty_it.done());
+
+  empty_it.SeekBeyond(non_empty_it);
+  EXPECT_TRUE(empty_it.done());
+
+  empty_it.SeekTo(empty_it);
+  EXPECT_TRUE(empty_it.done());
+
+  empty_it.SeekBeyond(empty_it);
+  EXPECT_TRUE(empty_it.done());
+}
+
+}  // namespace s2shapeutil