@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,147 @@
+// Copyright 2015 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/s2point_index.h"
+
+#include <set>
+
+#include <gtest/gtest.h>
+#include "s2/s2cell_id.h"
+#include "s2/s2cell_union.h"
+#include "s2/s2testing.h"
+
+class S2PointIndexTest : public ::testing::Test {
+ protected:
+  using Index = S2PointIndex<int>;
+  using PointData = Index::PointData;
+  using Contents = std::multiset<PointData>;
+  Index index_;
+  Contents contents_;
+
+ public:
+  void Add(const S2Point& point, int data) {
+    index_.Add(point, data);
+    contents_.insert(PointData(point, data));
+  }
+
+  void Remove(const S2Point& point, int data) {
+    // If there are multiple copies, remove only one.
+    contents_.erase(contents_.find(PointData(point, data)));
+    index_.Remove(point, data);  // Invalidates "point".
+  }
+
+  void Verify() {
+    VerifyContents();
+    VerifyIteratorMethods();
+  }
+
+  void VerifyContents() {
+    Contents remaining = contents_;
+    for (Index::Iterator it(&index_); !it.done(); it.Next()) {
+      Contents::iterator element = remaining.find(it.point_data());
+      EXPECT_TRUE(element != remaining.end());
+      remaining.erase(element);
+    }
+    EXPECT_TRUE(remaining.empty());
+  }
+
+  void VerifyIteratorMethods() {
+    Index::Iterator it(&index_);
+    EXPECT_FALSE(it.Prev());
+    it.Finish();
+    EXPECT_TRUE(it.done());
+
+    // Iterate through all the cells in the index.
+    S2CellId prev_cellid = S2CellId::None();
+    S2CellId min_cellid = S2CellId::Begin(S2CellId::kMaxLevel);
+    for (it.Begin(); !it.done(); it.Next()) {
+      S2CellId cellid = it.id();
+      EXPECT_EQ(cellid, S2CellId(it.point()));
+      EXPECT_GE(cellid, prev_cellid);
+
+      typename Index::Iterator it2(&index_);
+      if (cellid == prev_cellid) {
+        it2.Seek(cellid);
+      }
+
+      // Generate a cellunion that covers the range of empty leaf cells between
+      // the last cell and this one.  Then make sure that seeking to any of
+      // those cells takes us to the immediately following cell.
+      if (cellid > prev_cellid) {
+        for (S2CellId skipped : S2CellUnion::FromBeginEnd(min_cellid, cellid)) {
+          it2.Seek(skipped);
+          EXPECT_EQ(cellid, it2.id());
+        }
+      }
+      // Test Prev(), Next(), and Seek().
+      if (prev_cellid.is_valid()) {
+        it2 = it;
+        EXPECT_TRUE(it2.Prev());
+        EXPECT_EQ(prev_cellid, it2.id());
+        it2.Next();
+        EXPECT_EQ(cellid, it2.id());
+        it2.Seek(prev_cellid);
+        EXPECT_EQ(prev_cellid, it2.id());
+      }
+      prev_cellid = cellid;
+      min_cellid = cellid.next();
+    }
+  }
+};
+
+TEST_F(S2PointIndexTest, NoPoints) {
+  Verify();
+}
+
+TEST_F(S2PointIndexTest, DuplicatePoints) {
+  for (int i = 0; i < 10; ++i) {
+    Add(S2Point(1, 0, 0), 123);  // All points have same Data argument.
+  }
+  Verify();
+  // Now remove half of the points.
+  for (int i = 0; i < 5; ++i) {
+    Remove(S2Point(1, 0, 0), 123);
+  }
+  Verify();
+}
+
+TEST_F(S2PointIndexTest, RandomPoints) {
+  for (int i = 0; i < 100; ++i) {
+    Add(S2Testing::RandomPoint(), S2Testing::rnd.Uniform(100));
+  }
+  Verify();
+  // Now remove some of the points.
+  for (int i = 0; i < 10; ++i) {
+    S2PointIndex<int>::Iterator it(&index_);
+    do {
+      it.Seek(S2Testing::GetRandomCellId(S2CellId::kMaxLevel));
+    } while (it.done());
+    Remove(it.point(), it.data());
+    Verify();
+  }
+}
+
+TEST(S2PointIndex, EmptyData) {
+  // Verify that when Data is an empty class, no space is used.
+  EXPECT_EQ(sizeof(S2Point), sizeof(S2PointIndex<>::PointData));
+
+  // Verify that points can be added and removed with an empty Data class.
+  S2PointIndex<> index;
+  index.Add(S2Point(1, 0, 0));
+  index.Remove(S2Point(1, 0, 0));
+  EXPECT_EQ(0, index.num_points());
+}

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

@@ -0,0 +1,72 @@
+// Copyright 2005 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/s2point_region.h"
+
+#include "s2/base/logging.h"
+#include "s2/util/coding/coder.h"
+#include "s2/s2cap.h"
+#include "s2/s2cell.h"
+#include "s2/s2latlng.h"
+#include "s2/s2latlng_rect.h"
+#include "s2/s2pointutil.h"
+
+static const unsigned char kCurrentLosslessEncodingVersionNumber = 1;
+
+S2PointRegion::~S2PointRegion() {
+}
+
+S2PointRegion* S2PointRegion::Clone() const {
+  return new S2PointRegion(point_);
+}
+
+S2Cap S2PointRegion::GetCapBound() const {
+  return S2Cap::FromPoint(point_);
+}
+
+S2LatLngRect S2PointRegion::GetRectBound() const {
+  S2LatLng ll(point_);
+  return S2LatLngRect(ll, ll);
+}
+
+bool S2PointRegion::MayIntersect(const S2Cell& cell) const {
+  return cell.Contains(point_);
+}
+
+void S2PointRegion::Encode(Encoder* encoder) const {
+  encoder->Ensure(30);  // sufficient
+
+  encoder->put8(kCurrentLosslessEncodingVersionNumber);
+  for (int i = 0; i < 3; ++i) {
+    encoder->putdouble(point_[i]);
+  }
+  S2_DCHECK_GE(encoder->avail(), 0);
+}
+
+bool S2PointRegion::Decode(Decoder* decoder) {
+  if (decoder->avail() < sizeof(unsigned char) + 3 * sizeof(double))
+    return false;
+  unsigned char version = decoder->get8();
+  if (version > kCurrentLosslessEncodingVersionNumber) return false;
+
+  for (int i = 0; i < 3; ++i) {
+    point_[i] = decoder->getdouble();
+  }
+  if (!S2::IsUnitLength(point_)) return false;
+
+  return true;
+}

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

@@ -0,0 +1,76 @@
+// Copyright 2005 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_S2POINT_REGION_H_
+#define S2_S2POINT_REGION_H_
+
+#include "s2/base/logging.h"
+#include "s2/_fp_contract_off.h"
+#include "s2/s1angle.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2region.h"
+#include "s2/third_party/absl/base/macros.h"
+
+class Decoder;
+class Encoder;
+class S2Cap;
+class S2Cell;
+class S2LatLngRect;
+
+// An S2PointRegion is a region that contains a single point.  It is more
+// expensive than the raw S2Point type and is useful mainly for completeness.
+//
+// This class is intended to be copied by value as desired.  It uses
+// the default copy constructor and assignment operator.
+class S2PointRegion final : public S2Region {
+ public:
+  // Create a region containing the given point, which must be unit length.
+  explicit S2PointRegion(const S2Point& point);
+
+  ~S2PointRegion() override;
+
+  const S2Point& point() const { return point_; }
+
+  ////////////////////////////////////////////////////////////////////////
+  // S2Region interface (see s2region.h for details):
+
+  S2PointRegion* Clone() const override;
+  S2Cap GetCapBound() const override;
+  S2LatLngRect GetRectBound() const override;
+  bool Contains(const S2Cell& cell) const override { return false; }
+  bool MayIntersect(const S2Cell& cell) const override;
+  bool Contains(const S2Point& p) const override { return (point_ == p); }
+
+  // Appends a serialized representation of the S2Point to "encoder".
+  //
+  // REQUIRES: "encoder" uses the default constructor, so that its buffer
+  //           can be enlarged as necessary by calling Ensure(int).
+  void Encode(Encoder* const encoder) const;
+
+  // Decodes an S2Point encoded with Encode().  Returns true on success.
+  // (Returns false if the encoded point is not unit length.)
+  bool Decode(Decoder* const decoder);
+
+ private:
+  S2Point point_;
+};
+
+inline S2PointRegion::S2PointRegion(const S2Point& point) : point_(point) {
+  S2_DCHECK(S2::IsUnitLength(point));
+}
+
+#endif  // S2_S2POINT_REGION_H_

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

@@ -0,0 +1,100 @@
+// Copyright 2005 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/s2point_region.h"
+
+#include <memory>
+
+#include <gtest/gtest.h>
+#include "s2/util/coding/coder.h"
+#include "s2/s2cap.h"
+#include "s2/s2cell.h"
+#include "s2/s2latlng.h"
+#include "s2/s2latlng_rect.h"
+
+using std::unique_ptr;
+
+namespace {
+
+TEST(S2PointRegionTest, Basic) {
+  S2Point p(1, 0, 0);
+  S2PointRegion r0(p);
+  EXPECT_EQ(r0.point(), p);
+  EXPECT_TRUE(r0.Contains(p));
+  EXPECT_TRUE(r0.Contains(r0.point()));
+  EXPECT_FALSE(r0.Contains(S2Point(1, 0, 1)));
+  unique_ptr<S2PointRegion> r0_clone(r0.Clone());
+  EXPECT_EQ(r0_clone->point(), r0.point());
+  EXPECT_EQ(r0.GetCapBound(), S2Cap::FromPoint(p));
+  S2LatLng ll(p);
+  EXPECT_EQ(r0.GetRectBound(), S2LatLngRect(ll, ll));
+
+  // The leaf cell containing a point is still much larger than the point.
+  S2Cell cell(p);
+  EXPECT_FALSE(r0.Contains(cell));
+  EXPECT_TRUE(r0.MayIntersect(cell));
+}
+
+TEST(S2PointRegionTest, EncodeAndDecode) {
+  S2Point p(.6, .8, 0);
+  S2PointRegion r(p);
+
+  Encoder encoder;
+  r.Encode(&encoder);
+
+  Decoder decoder(encoder.base(), encoder.length());
+  S2PointRegion decoded_r(S2Point(1, 0, 0));
+  decoded_r.Decode(&decoder);
+  S2Point decoded_p = decoded_r.point();
+
+  EXPECT_EQ(0.6, decoded_p[0]);
+  EXPECT_EQ(0.8, decoded_p[1]);
+  EXPECT_EQ(0.0, decoded_p[2]);
+}
+
+TEST(S2PointRegionTest, DecodeUnitLength) {
+  // Ensure that we have the right format for the next test.
+  Encoder encoder;
+  encoder.Ensure(1 + 3 * 8);
+
+  encoder.put8(1);  // version number
+  encoder.putdouble(1.0);
+  encoder.putdouble(0.0);
+  encoder.putdouble(0.0);
+
+  Decoder decoder(encoder.base(), encoder.length());
+  S2PointRegion r(S2Point(-1, 0, 0));
+  ASSERT_TRUE(r.Decode(&decoder));
+}
+
+TEST(S2PointRegionTest, DecodeNonUnitLength) {
+  // Ensure that a decode of a non-unit length vector returns false,
+  // rather than S2_DCHECK fails.
+  Encoder encoder;
+  encoder.Ensure(1 + 3 * 8);
+
+  encoder.put8(1);  // version number
+  encoder.putdouble(1.0);
+  encoder.putdouble(1.0);
+  encoder.putdouble(1.0);
+
+  Decoder decoder(encoder.base(), encoder.length());
+  S2PointRegion r(S2Point(-1, 0, 0));
+  ASSERT_FALSE(r.Decode(&decoder));
+}
+
+}  // namespace

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

@@ -0,0 +1,57 @@
+// Copyright 2018 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_S2POINT_SPAN_H_
+#define S2_S2POINT_SPAN_H_
+
+#include "s2/base/logging.h"
+#include "s2/third_party/absl/types/span.h"
+#include "s2/s2point.h"
+
+// S2PointSpan represents a view of an S2Point array.  It is used to pass
+// vertex arrays to functions that don't care about the actual array type
+// (e.g. std::vector<S2Point> or S2Point[]).
+//
+// NOTE: S2PointSpan has an implicit constructor from any container type with
+// data() and size() methods (such as std::vector and std::array).  Therefore
+// you can use such containers as arguments for any S2PointSpan parameter.
+using S2PointSpan = absl::Span<const S2Point>;
+
+// Like S2PointSpan, except that operator[] maps index values in the range
+// [n, 2*n-1] to the range [0, n-1] by subtracting n (where n == size()).
+// In other words, two full copies of the vertex array are available.  (This
+// is a compromise between convenience and efficiency, since computing the
+// index modulo "n" is surprisingly expensive.)
+//
+// This property is useful for implementing algorithms where the elements of
+// the span represent the vertices of a loop.
+class S2PointLoopSpan : public S2PointSpan {
+ public:
+  // Inherit all constructors.
+  using absl::Span<const S2Point>::Span;
+
+  // Like operator[], but allows index values in the range [0, 2*size()-1]
+  // where each index i >= size() is mapped to i - size().
+  reference operator[](int i) const noexcept {
+    S2_DCHECK_GE(i, 0);
+    S2_DCHECK_LT(i, 2 * size());
+    int j = i - static_cast<int>(size());
+    return S2PointSpan::operator[](j < 0 ? i : j);
+  }
+};
+
+#endif  // S2_S2POINT_SPAN_H_

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

@@ -0,0 +1,47 @@
+// Copyright 2005 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/s2point.h"
+
+#include <cstddef>
+#include <unordered_set>
+
+#include <gtest/gtest.h>
+#include "s2/s2cell.h"
+#include "s2/s2testing.h"
+
+using std::unordered_set;
+
+TEST(S2, S2PointHashSpreads) {
+  int kTestPoints = 1 << 16;
+  unordered_set<size_t> set;
+  unordered_set<S2Point, S2PointHash> points;
+  S2PointHash hasher;
+  S2Point base = S2Point(1, 1, 1);
+  for (int i = 0; i < kTestPoints; ++i) {
+    // All points in a tiny cap to test avalanche property of hash
+    // function (the cap would be of radius 1mm on Earth (4*10^9/2^35).
+    S2Point perturbed = base + S2Testing::RandomPoint() / (1ULL << 35);
+    perturbed = perturbed.Normalize();
+    set.insert(hasher(perturbed));
+    points.insert(perturbed);
+  }
+  // A real collision is extremely unlikely.
+  EXPECT_EQ(0, kTestPoints - points.size());
+  // Allow a few for the hash.
+  EXPECT_GE(10, kTestPoints - set.size());
+}

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

@@ -0,0 +1,127 @@
+// 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_S2POINT_VECTOR_SHAPE_H_
+#define S2_S2POINT_VECTOR_SHAPE_H_
+
+#include <vector>
+#include "s2/encoded_s2point_vector.h"
+#include "s2/s2shape.h"
+
+// S2PointVectorShape is an S2Shape representing a set of S2Points. Each point
+// is reprsented as a degenerate edge with the same starting and ending
+// vertices.
+//
+// This class is useful for adding a collection of points to an S2ShapeIndex.
+class S2PointVectorShape : public S2Shape {
+ public:
+  static constexpr TypeTag kTypeTag = 3;
+
+  // Constructs an empty point vector.
+  S2PointVectorShape() {}
+
+  // Constructs an S2PointVectorShape from a vector of points.
+  explicit S2PointVectorShape(std::vector<S2Point> points) {
+    points_ = std::move(points);
+  }
+
+  ~S2PointVectorShape() override = default;
+
+  int num_points() const { return static_cast<int>(points_.size()); }
+  const S2Point& point(int i) const { return points_[i]; }
+
+  // Appends an encoded representation of the S2PointVectorShape to "encoder".
+  //
+  // REQUIRES: "encoder" uses the default constructor, so that its buffer
+  //           can be enlarged as necessary by calling Ensure(int).
+  void Encode(Encoder* encoder,
+              s2coding::CodingHint hint = s2coding::CodingHint::COMPACT) const {
+    s2coding::EncodeS2PointVector(points_, hint, encoder);
+  }
+
+  // Decodes an S2PointVectorShape, returning true on success.  (The method
+  // name is chosen for compatibility with EncodedS2PointVectorShape below.)
+  bool Init(Decoder* decoder) {
+    s2coding::EncodedS2PointVector points;
+    if (!points.Init(decoder)) return false;
+    points_ = points.Decode();
+    return true;
+  }
+
+  // S2Shape interface:
+  int num_edges() const final { return num_points(); }
+  Edge edge(int e) const final { return Edge(points_[e], points_[e]); }
+  int dimension() const final { return 0; }
+  ReferencePoint GetReferencePoint() const final {
+    return ReferencePoint::Contained(false);
+  }
+  int num_chains() const final { return num_points(); }
+  Chain chain(int i) const final { return Chain(i, 1); }
+  Edge chain_edge(int i, int j) const final {
+    S2_DCHECK_EQ(j, 0);
+    return Edge(points_[i], points_[i]);
+  }
+  ChainPosition chain_position(int e) const final {
+    return ChainPosition(e, 0);
+  }
+  TypeTag type_tag() const override { return kTypeTag; }
+
+ private:
+  std::vector<S2Point> points_;
+};
+
+// Exactly like S2PointVectorShape, except that the points are kept in an
+// encoded form and are decoded only as they are accessed.  This allows for
+// very fast initialization and no additional memory use beyond the encoded
+// data.  The encoded data is not owned by this class; typically it points
+// into a large contiguous buffer that contains other encoded data as well.
+class EncodedS2PointVectorShape : public S2Shape {
+ public:
+  // Constructs an uninitialized object; requires Init() to be called.
+  EncodedS2PointVectorShape() {}
+
+  // Initializes an EncodedS2PointVectorShape.
+  //
+  // REQUIRES: The Decoder data buffer must outlive this object.
+  bool Init(Decoder* decoder) { return points_.Init(decoder); }
+
+  int num_points() const { return static_cast<int>(points_.size()); }
+  S2Point point(int i) const { return points_[i]; }
+
+  // S2Shape interface:
+  int num_edges() const final { return num_points(); }
+  Edge edge(int e) const final { return Edge(points_[e], points_[e]); }
+  int dimension() const final { return 0; }
+  ReferencePoint GetReferencePoint() const final {
+    return ReferencePoint::Contained(false);
+  }
+  int num_chains() const final { return num_points(); }
+  Chain chain(int i) const final { return Chain(i, 1); }
+  Edge chain_edge(int i, int j) const final {
+    S2_DCHECK_EQ(j, 0);
+    return Edge(points_[i], points_[i]);
+  }
+  ChainPosition chain_position(int e) const final {
+    return ChainPosition(e, 0);
+  }
+
+ private:
+  s2coding::EncodedS2PointVector points_;
+};
+
+
+#endif  // S2_S2POINT_VECTOR_SHAPE_H_

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

@@ -0,0 +1,59 @@
+// 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/s2point_vector_shape.h"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/s2testing.h"
+
+TEST(S2PointVectorShape, Empty) {
+  std::vector<S2Point> points;
+  S2PointVectorShape shape(std::move(points));
+  EXPECT_EQ(0, shape.num_edges());
+  EXPECT_EQ(0, shape.num_chains());
+  EXPECT_EQ(0, shape.dimension());
+  EXPECT_TRUE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(S2PointVectorShape, ConstructionAndAccess) {
+  std::vector<S2Point> points;
+  S2Testing::rnd.Reset(FLAGS_s2_random_seed);
+  const int kNumPoints = 100;
+  for (int i = 0; i < kNumPoints; ++i) {
+    points.push_back(S2Testing::RandomPoint());
+  }
+  S2PointVectorShape shape(std::move(points));
+
+  EXPECT_EQ(kNumPoints, shape.num_edges());
+  EXPECT_EQ(kNumPoints, shape.num_chains());
+  EXPECT_EQ(0, shape.dimension());
+  EXPECT_FALSE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  S2Testing::rnd.Reset(FLAGS_s2_random_seed);
+  for (int i = 0; i < kNumPoints; ++i) {
+    EXPECT_EQ(i, shape.chain(i).start);
+    EXPECT_EQ(1, shape.chain(i).length);
+    auto edge = shape.edge(i);
+    S2Point pt = S2Testing::RandomPoint();
+    EXPECT_EQ(pt, edge.v0);
+    EXPECT_EQ(pt, edge.v1);
+  }
+}