add Equal function and some tests

Author: paulmach

clone.go

@@ -6,6 +6,10 @@ import (
 
 // Clone will make a deep copy of the geometry.
 func Clone(g Geometry) Geometry {
+	if g == nil {
+		return nil
+	}
+
 	switch g := g.(type) {
 	case Point:
 		return g

clone_test.go

@@ -0,0 +1,18 @@
+package orb
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestClone(t *testing.T) {
+	for _, g := range AllGeometries {
+		// this closure is necessary if tests are run in parallel, maybe
+		func(geom Geometry) {
+			t.Run(fmt.Sprintf("%T", g), func(t *testing.T) {
+				// should not panic
+				Clone(geom)
+			})
+		}(g)
+	}
+}

equal.go

@@ -0,0 +1,39 @@
+package orb
+
+import (
+	"fmt"
+)
+
+// Equal returns if the two geometrires are equal.
+func Equal(g1, g2 Geometry) bool {
+	if g1 == nil || g2 == nil {
+		return g1 == g2
+	}
+
+	if g1.GeoJSONType() != g2.GeoJSONType() {
+		return false
+	}
+
+	switch g1 := g1.(type) {
+	case Point:
+		return g1.Equal(g2.(Point))
+	case MultiPoint:
+		return g1.Equal(g2.(MultiPoint))
+	case LineString:
+		return g1.Equal(g2.(LineString))
+	case MultiLineString:
+		return g1.Equal(g2.(MultiLineString))
+	case Ring:
+		return g1.Equal(g2.(Ring))
+	case Polygon:
+		return g1.Equal(g2.(Polygon))
+	case MultiPolygon:
+		return g1.Equal(g2.(MultiPolygon))
+	case Collection:
+		return g1.Equal(g2.(Collection))
+	case Bound:
+		return g1.Equal(g2.(Bound))
+	}
+
+	panic(fmt.Sprintf("geometry type not supported: %T", g1))
+}

equal_test.go

@@ -0,0 +1,19 @@
+package orb
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestEqual(t *testing.T) {
+	for _, g := range AllGeometries {
+		// this closure is necessary if tests are run in parallel, maybe
+		func(geom Geometry) {
+			t.Run(fmt.Sprintf("%T", g), func(t *testing.T) {
+				if !Equal(geom, geom) {
+					t.Errorf("%T not equal", g)
+				}
+			})
+		}(g)
+	}
+}

geometry.go

@@ -35,6 +35,34 @@ func (mp MultiPolygon) private()     {}
 func (b Bound) private()             {}
 func (c Collection) private()        {}
 
+// AllGeometries lists all possible types and values that a geometry
+// interface can be. It should be used only for testing to verify
+// function that accept a Geometry will work in all cases.
+var AllGeometries = []Geometry{
+	nil,
+	Point{},
+	MultiPoint{},
+	LineString{},
+	MultiLineString{},
+	Ring{},
+	Polygon{},
+	MultiPolygon{},
+	Bound{},
+	Collection{},
+
+	// nil values
+	MultiPoint(nil),
+	LineString(nil),
+	MultiLineString(nil),
+	Ring(nil),
+	Polygon(nil),
+	MultiPolygon(nil),
+	Collection(nil),
+
+	// Collection of Collection
+	Collection{Collection{Point{}}},
+}
+
 // A Collection is a collection of geometries that is also a Geometry.
 type Collection []Geometry
 
@@ -65,6 +93,22 @@ func (c Collection) Bound() Bound {
 	return r
 }
 
+// Equal compares two collections. Returns true if lengths are the same
+// and all the sub geometries are the same and in the same order.
+func (c Collection) Equal(collection Collection) bool {
+	if len(c) != len(collection) {
+		return false
+	}
+
+	for i, g := range c {
+		if !Equal(g, collection[i]) {
+			return false
+		}
+	}
+
+	return true
+}
+
 // Clone returns a deep copy of the collection.
 func (c Collection) Clone() Collection {
 	if c == nil {