lint tests: check all errors

paulmach · paulmach · commit 64f442908ec0 · 2023-01-06T10:50:22.000-08:00
diff --git a/encoding/ewkb/ewkb_test.go b/encoding/ewkb/ewkb_test.go
@@ -13,7 +13,10 @@ import (
 
 func TestMarshal(t *testing.T) {
 	for _, g := range orb.AllGeometries {
-		Marshal(g, 0, binary.BigEndian)
+		_, err := Marshal(g, 0, binary.BigEndian)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -39,7 +42,10 @@ func BenchmarkEncode_Point(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		e.Encode(g)
+		err := e.Encode(g)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -53,7 +59,10 @@ func BenchmarkEncode_LineString(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		e.Encode(g)
+		err := e.Encode(g)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -129,7 +138,7 @@ func compare(t testing.TB, e orb.Geometry, s int, b []byte) {
 	// pass in srid
 	buf.Reset()
 	en.SetSRID(10101)
-	en.Encode(e, s)
+	err = en.Encode(e, s)
 	if err != nil {
 		t.Errorf("encode with srid error: %v", err)
 	}
diff --git a/encoding/internal/wkbcommon/wkb_test.go b/encoding/internal/wkbcommon/wkb_test.go
@@ -10,7 +10,10 @@ import (
 
 func TestMarshal(t *testing.T) {
 	for _, g := range orb.AllGeometries {
-		Marshal(g, 0, binary.BigEndian)
+		_, err := Marshal(g, 0, binary.BigEndian)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
diff --git a/encoding/mvt/example_test.go b/encoding/mvt/example_test.go
@@ -27,14 +27,19 @@ func ExampleMarshal() {
 
 	// encoding using the Mapbox Vector Tile protobuf encoding.
 	data, err := mvt.Marshal(layers) // this data is NOT gzipped.
+	_ = data
+
+	// error checking
+	if err != nil {
+		log.Fatalf("marshal error: %v", err)
+	}
 
 	// Sometimes MVT data is stored and transferred gzip compressed. In that case:
 	data, err = mvt.MarshalGzipped(layers)
+	_ = data
 
 	// error checking
 	if err != nil {
 		log.Fatalf("marshal error: %v", err)
 	}
-
-	_ = data
 }
diff --git a/encoding/mvt/marshal_test.go b/encoding/mvt/marshal_test.go
@@ -558,7 +558,10 @@ func BenchmarkMarshal(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		Marshal(layers)
+		_, err := Marshal(layers)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -573,7 +576,10 @@ func BenchmarkUnmarshal(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		Unmarshal(data)
+		_, err := Unmarshal(data)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
diff --git a/encoding/wkb/wkb_test.go b/encoding/wkb/wkb_test.go
@@ -12,7 +12,10 @@ import (
 
 func TestMarshal(t *testing.T) {
 	for _, g := range orb.AllGeometries {
-		Marshal(g, binary.BigEndian)
+		_, err := Marshal(g, binary.BigEndian)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -29,7 +32,10 @@ func BenchmarkEncode_Point(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		e.Encode(g)
+		err := e.Encode(g)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -43,7 +49,10 @@ func BenchmarkEncode_LineString(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		e.Encode(g)
+		err := e.Encode(g)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
diff --git a/geojson/example_pointer_test.go b/geojson/example_pointer_test.go
@@ -2,6 +2,7 @@ package geojson_test
 
 import (
 	"fmt"
+	"log"
 
 	"github.com/paulmach/orb"
 	"github.com/paulmach/orb/geojson"
@@ -26,12 +27,18 @@ func Example_centroid() {
 	// feature with center {0.5, 0.5} but centroid {0.25, 0.25}
 	f := geojson.NewFeature(orb.MultiPoint{{0, 0}, {0, 0}, {0, 0}, {1, 1}})
 	f.Properties["centroid"] = "0.25"
-	qt.Add(CentroidPoint{f})
+	err := qt.Add(CentroidPoint{f})
+	if err != nil {
+		log.Fatalf("unexpected error: %v", err)
+	}
 
 	// feature with centroid {0.6, 0.6}
 	f = geojson.NewFeature(orb.Point{0.6, 0.6})
 	f.Properties["centroid"] = "0.6"
-	qt.Add(CentroidPoint{f})
+	err = qt.Add(CentroidPoint{f})
+	if err != nil {
+		log.Fatalf("unexpected error: %v", err)
+	}
 
 	feature := qt.Find(orb.Point{0.5, 0.5}).(CentroidPoint).Feature
 	fmt.Printf("centroid=%s", feature.Properties["centroid"])
diff --git a/geojson/example_test.go b/geojson/example_test.go
@@ -15,7 +15,10 @@ func ExampleFeature_Point() {
 	f.Properties["key"] = "value"
 
 	qt := quadtree.New(f.Geometry.Bound().Pad(1))
-	qt.Add(f) // add the feature to a quadtree
+	err := qt.Add(f) // add the feature to a quadtree
+	if err != nil {
+		log.Fatalf("unexpected error: %v", err)
+	}
 
 	// type assert the feature back into a Feature from
 	// the orb.Pointer interface.
@@ -39,7 +42,10 @@ func ExampleFeatureCollection_foreignMembers() {
 	  }`)
 
 	fc := geojson.NewFeatureCollection()
-	json.Unmarshal(rawJSON, &fc)
+	err := json.Unmarshal(rawJSON, &fc)
+	if err != nil {
+		log.Fatalf("invalid json: %v", err)
+	}
 
 	fmt.Println(fc.Features[0].Geometry)
 	fmt.Println(fc.ExtraMembers["title"])
@@ -90,7 +96,10 @@ func ExampleFeatureCollection_foreignMembersCustom() {
 	  }`)
 
 	fc := &MyFeatureCollection{}
-	json.Unmarshal(rawJSON, &fc)
+	err := json.Unmarshal(rawJSON, &fc)
+	if err != nil {
+		log.Fatalf("invalid json: %v", err)
+	}
 
 	fmt.Println(fc.FeatureCollection.Features[0].Geometry)
 	fmt.Println(fc.Features[0].Geometry)
@@ -151,13 +160,13 @@ func ExampleFeatureCollection_MarshalJSON() {
 	fc := geojson.NewFeatureCollection()
 	fc.Append(geojson.NewFeature(orb.Point{1, 2}))
 
-	data, err := fc.MarshalJSON()
+	_, err := fc.MarshalJSON()
 	if err != nil {
 		log.Fatalf("marshal error: %v", err)
 	}
 
 	// standard lib encoding/json package will also work
-	data, err = json.MarshalIndent(fc, "", " ")
+	data, err := json.MarshalIndent(fc, "", " ")
 	if err != nil {
 		log.Fatalf("marshal error: %v", err)
 	}
diff --git a/geojson/geometry_test.go b/geojson/geometry_test.go
@@ -356,7 +356,10 @@ func BenchmarkGeometryMarshalJSON(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		g.MarshalJSON()
+		_, err := g.MarshalJSON()
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -375,6 +378,9 @@ func BenchmarkGeometryUnmarshalJSON(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		g.UnmarshalJSON(data)
+		err := g.UnmarshalJSON(data)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
diff --git a/maptile/tilecover/benchmarks_test.go b/maptile/tilecover/benchmarks_test.go
@@ -12,7 +12,10 @@ func BenchmarkPoint(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		Geometry(p, 6)
+		_, err := Geometry(p, 6)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -22,7 +25,10 @@ func BenchmarkRoad_z6(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		Geometry(g, 6)
+		_, err := Geometry(g, 6)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -32,7 +38,10 @@ func BenchmarkRoad_z18(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		Geometry(g, 18)
+		_, err := Geometry(g, 18)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -42,7 +51,10 @@ func BenchmarkRoad_z28(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		Geometry(g, 28)
+		_, err := Geometry(g, 28)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -52,7 +64,10 @@ func BenchmarkRussia_z6(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		Geometry(g, 6)
+		_, err := Geometry(g, 6)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -62,7 +77,10 @@ func BenchmarkRussia_z8(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		Geometry(g, 8)
+		_, err := Geometry(g, 8)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -72,7 +90,10 @@ func BenchmarkRussia_z10(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		Geometry(g, 10)
+		_, err := Geometry(g, 10)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -94,7 +115,10 @@ func BenchmarkRussiaLine_z6(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		Geometry(g, 6)
+		_, err := Geometry(g, 6)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -105,7 +129,10 @@ func BenchmarkRussiaLine_z8(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		Geometry(g, 8)
+		_, err := Geometry(g, 8)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
 
@@ -116,6 +143,9 @@ func BenchmarkRussiaLine_z10(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		Geometry(g, 10)
+		_, err := Geometry(g, 10)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
 	}
 }
diff --git a/maptile/tilecover/helpers_test.go b/maptile/tilecover/helpers_test.go
@@ -8,6 +8,9 @@ import (
 
 func TestGeometry(t *testing.T) {
 	for _, g := range orb.AllGeometries {
-		Geometry(g, 1)
+		_, err := Geometry(g, 1)
+		if err != nil {
+			t.Fatalf("unexpected error for %T: %v", g, err)
+		}
 	}
 }
diff --git a/quadtree/benchmarks_test.go b/quadtree/benchmarks_test.go
diff --git a/quadtree/example_test.go b/quadtree/example_test.go
diff --git a/quadtree/quadtree_test.go b/quadtree/quadtree_test.go
diff --git a/simplify/benchmarks_test.go b/simplify/benchmarks_test.go
diff --git a/simplify/helpers.go b/simplify/helpers.go

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,10 @@ import (`
`13`	`13`
`14`	`14`	`func TestMarshal(t *testing.T) {`
`15`	`15`	`for _, g := range orb.AllGeometries {`
`16`		`- Marshal(g, 0, binary.BigEndian)`
	`16`	`+ _, err := Marshal(g, 0, binary.BigEndian)`
	`17`	`+ if err != nil {`
	`18`	`+ t.Fatalf("unexpected error: %v", err)`
	`19`	`+ }`
`17`	`20`	`}`
`18`	`21`	`}`
`19`	`22`
`@@ -39,7 +42,10 @@ func BenchmarkEncode_Point(b *testing.B) {`
`39`	`42`	`b.ReportAllocs()`
`40`	`43`	`b.ResetTimer()`
`41`	`44`	`for i := 0; i < b.N; i++ {`
`42`		`- e.Encode(g)`
	`45`	`+ err := e.Encode(g)`
	`46`	`+ if err != nil {`
	`47`	`+ b.Fatalf("unexpected error: %v", err)`
	`48`	`+ }`
`43`	`49`	`}`
`44`	`50`	`}`
`45`	`51`
`@@ -53,7 +59,10 @@ func BenchmarkEncode_LineString(b *testing.B) {`
`53`	`59`	`b.ReportAllocs()`
`54`	`60`	`b.ResetTimer()`
`55`	`61`	`for i := 0; i < b.N; i++ {`
`56`		`- e.Encode(g)`
	`62`	`+ err := e.Encode(g)`
	`63`	`+ if err != nil {`
	`64`	`+ b.Fatalf("unexpected error: %v", err)`
	`65`	`+ }`
`57`	`66`	`}`
`58`	`67`	`}`
`59`	`68`
`@@ -129,7 +138,7 @@ func compare(t testing.TB, e orb.Geometry, s int, b []byte) {`
`129`	`138`	`// pass in srid`
`130`	`139`	`buf.Reset()`
`131`	`140`	`en.SetSRID(10101)`
`132`		`- en.Encode(e, s)`
	`141`	`+ err = en.Encode(e, s)`
`133`	`142`	`if err != nil {`
`134`	`143`	`t.Errorf("encode with srid error: %v", err)`
`135`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,10 @@ import (`
`10`	`10`
`11`	`11`	`func TestMarshal(t *testing.T) {`
`12`	`12`	`for _, g := range orb.AllGeometries {`
`13`		`- Marshal(g, 0, binary.BigEndian)`
	`13`	`+ _, err := Marshal(g, 0, binary.BigEndian)`
	`14`	`+ if err != nil {`
	`15`	`+ t.Fatalf("unexpected error: %v", err)`
	`16`	`+ }`
`14`	`17`	`}`
`15`	`18`	`}`
`16`	`19`
Original file line number	Diff line number	Diff line change
`@@ -558,7 +558,10 @@ func BenchmarkMarshal(b *testing.B) {`
`558`	`558`	`b.ResetTimer()`
`559`	`559`
`560`	`560`	`for i := 0; i < b.N; i++ {`
`561`		`- Marshal(layers)`
	`561`	`+ _, err := Marshal(layers)`
	`562`	`+ if err != nil {`
	`563`	`+ b.Fatalf("unexpected error: %v", err)`
	`564`	`+ }`
`562`	`565`	`}`
`563`	`566`	`}`
`564`	`567`
`@@ -573,7 +576,10 @@ func BenchmarkUnmarshal(b *testing.B) {`
`573`	`576`	`b.ResetTimer()`
`574`	`577`
`575`	`578`	`for i := 0; i < b.N; i++ {`
`576`		`- Unmarshal(data)`
	`579`	`+ _, err := Unmarshal(data)`
	`580`	`+ if err != nil {`
	`581`	`+ b.Fatalf("unexpected error: %v", err)`
	`582`	`+ }`
`577`	`583`	`}`
`578`	`584`	`}`
`579`	`585`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,10 @@ import (`
`12`	`12`
`13`	`13`	`func TestMarshal(t *testing.T) {`
`14`	`14`	`for _, g := range orb.AllGeometries {`
`15`		`- Marshal(g, binary.BigEndian)`
	`15`	`+ _, err := Marshal(g, binary.BigEndian)`
	`16`	`+ if err != nil {`
	`17`	`+ t.Fatalf("unexpected error: %v", err)`
	`18`	`+ }`
`16`	`19`	`}`
`17`	`20`	`}`
`18`	`21`
`@@ -29,7 +32,10 @@ func BenchmarkEncode_Point(b *testing.B) {`
`29`	`32`	`b.ReportAllocs()`
`30`	`33`	`b.ResetTimer()`
`31`	`34`	`for i := 0; i < b.N; i++ {`
`32`		`- e.Encode(g)`
	`35`	`+ err := e.Encode(g)`
	`36`	`+ if err != nil {`
	`37`	`+ b.Fatalf("unexpected error: %v", err)`
	`38`	`+ }`
`33`	`39`	`}`
`34`	`40`	`}`
`35`	`41`
`@@ -43,7 +49,10 @@ func BenchmarkEncode_LineString(b *testing.B) {`
`43`	`49`	`b.ReportAllocs()`
`44`	`50`	`b.ResetTimer()`
`45`	`51`	`for i := 0; i < b.N; i++ {`
`46`		`- e.Encode(g)`
	`52`	`+ err := e.Encode(g)`
	`53`	`+ if err != nil {`
	`54`	`+ b.Fatalf("unexpected error: %v", err)`
	`55`	`+ }`
`47`	`56`	`}`
`48`	`57`	`}`
`49`	`58`
Original file line number	Diff line number	Diff line change
`@@ -356,7 +356,10 @@ func BenchmarkGeometryMarshalJSON(b *testing.B) {`
`356`	`356`	`b.ReportAllocs()`
`357`	`357`	`b.ResetTimer()`
`358`	`358`	`for i := 0; i < b.N; i++ {`
`359`		`- g.MarshalJSON()`
	`359`	`+ _, err := g.MarshalJSON()`
	`360`	`+ if err != nil {`
	`361`	`+ b.Fatalf("unexpected error: %v", err)`
	`362`	`+ }`
`360`	`363`	`}`
`361`	`364`	`}`
`362`	`365`
`@@ -375,6 +378,9 @@ func BenchmarkGeometryUnmarshalJSON(b *testing.B) {`
`375`	`378`	`b.ReportAllocs()`
`376`	`379`	`b.ResetTimer()`
`377`	`380`	`for i := 0; i < b.N; i++ {`
`378`		`- g.UnmarshalJSON(data)`
	`381`	`+ err := g.UnmarshalJSON(data)`
	`382`	`+ if err != nil {`
	`383`	`+ b.Fatalf("unexpected error: %v", err)`
	`384`	`+ }`
`379`	`385`	`}`
`380`	`386`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,10 @@ func BenchmarkPoint(b *testing.B) {`
`12`	`12`	`b.ReportAllocs()`
`13`	`13`	`b.ResetTimer()`
`14`	`14`	`for i := 0; i < b.N; i++ {`
`15`		`- Geometry(p, 6)`
	`15`	`+ _, err := Geometry(p, 6)`
	`16`	`+ if err != nil {`
	`17`	`+ b.Fatalf("unexpected error: %v", err)`
	`18`	`+ }`
`16`	`19`	`}`
`17`	`20`	`}`
`18`	`21`
`@@ -22,7 +25,10 @@ func BenchmarkRoad_z6(b *testing.B) {`
`22`	`25`	`b.ReportAllocs()`
`23`	`26`	`b.ResetTimer()`
`24`	`27`	`for i := 0; i < b.N; i++ {`
`25`		`- Geometry(g, 6)`
	`28`	`+ _, err := Geometry(g, 6)`
	`29`	`+ if err != nil {`
	`30`	`+ b.Fatalf("unexpected error: %v", err)`
	`31`	`+ }`
`26`	`32`	`}`
`27`	`33`	`}`
`28`	`34`
`@@ -32,7 +38,10 @@ func BenchmarkRoad_z18(b *testing.B) {`
`32`	`38`	`b.ReportAllocs()`
`33`	`39`	`b.ResetTimer()`
`34`	`40`	`for i := 0; i < b.N; i++ {`
`35`		`- Geometry(g, 18)`
	`41`	`+ _, err := Geometry(g, 18)`
	`42`	`+ if err != nil {`
	`43`	`+ b.Fatalf("unexpected error: %v", err)`
	`44`	`+ }`
`36`	`45`	`}`
`37`	`46`	`}`
`38`	`47`
`@@ -42,7 +51,10 @@ func BenchmarkRoad_z28(b *testing.B) {`
`42`	`51`	`b.ReportAllocs()`
`43`	`52`	`b.ResetTimer()`
`44`	`53`	`for i := 0; i < b.N; i++ {`
`45`		`- Geometry(g, 28)`
	`54`	`+ _, err := Geometry(g, 28)`
	`55`	`+ if err != nil {`
	`56`	`+ b.Fatalf("unexpected error: %v", err)`
	`57`	`+ }`
`46`	`58`	`}`
`47`	`59`	`}`
`48`	`60`
`@@ -52,7 +64,10 @@ func BenchmarkRussia_z6(b *testing.B) {`
`52`	`64`	`b.ReportAllocs()`
`53`	`65`	`b.ResetTimer()`
`54`	`66`	`for i := 0; i < b.N; i++ {`
`55`		`- Geometry(g, 6)`
	`67`	`+ _, err := Geometry(g, 6)`
	`68`	`+ if err != nil {`
	`69`	`+ b.Fatalf("unexpected error: %v", err)`
	`70`	`+ }`
`56`	`71`	`}`
`57`	`72`	`}`
`58`	`73`
`@@ -62,7 +77,10 @@ func BenchmarkRussia_z8(b *testing.B) {`
`62`	`77`	`b.ReportAllocs()`
`63`	`78`	`b.ResetTimer()`
`64`	`79`	`for i := 0; i < b.N; i++ {`
`65`		`- Geometry(g, 8)`
	`80`	`+ _, err := Geometry(g, 8)`
	`81`	`+ if err != nil {`
	`82`	`+ b.Fatalf("unexpected error: %v", err)`
	`83`	`+ }`
`66`	`84`	`}`
`67`	`85`	`}`
`68`	`86`
`@@ -72,7 +90,10 @@ func BenchmarkRussia_z10(b *testing.B) {`
`72`	`90`	`b.ReportAllocs()`
`73`	`91`	`b.ResetTimer()`
`74`	`92`	`for i := 0; i < b.N; i++ {`
`75`		`- Geometry(g, 10)`
	`93`	`+ _, err := Geometry(g, 10)`
	`94`	`+ if err != nil {`
	`95`	`+ b.Fatalf("unexpected error: %v", err)`
	`96`	`+ }`
`76`	`97`	`}`
`77`	`98`	`}`
`78`	`99`
`@@ -94,7 +115,10 @@ func BenchmarkRussiaLine_z6(b *testing.B) {`
`94`	`115`	`b.ReportAllocs()`
`95`	`116`	`b.ResetTimer()`
`96`	`117`	`for i := 0; i < b.N; i++ {`
`97`		`- Geometry(g, 6)`
	`118`	`+ _, err := Geometry(g, 6)`
	`119`	`+ if err != nil {`
	`120`	`+ b.Fatalf("unexpected error: %v", err)`
	`121`	`+ }`
`98`	`122`	`}`
`99`	`123`	`}`
`100`	`124`
`@@ -105,7 +129,10 @@ func BenchmarkRussiaLine_z8(b *testing.B) {`
`105`	`129`	`b.ReportAllocs()`
`106`	`130`	`b.ResetTimer()`
`107`	`131`	`for i := 0; i < b.N; i++ {`
`108`		`- Geometry(g, 8)`
	`132`	`+ _, err := Geometry(g, 8)`
	`133`	`+ if err != nil {`
	`134`	`+ b.Fatalf("unexpected error: %v", err)`
	`135`	`+ }`
`109`	`136`	`}`
`110`	`137`	`}`
`111`	`138`
`@@ -116,6 +143,9 @@ func BenchmarkRussiaLine_z10(b *testing.B) {`
`116`	`143`	`b.ReportAllocs()`
`117`	`144`	`b.ResetTimer()`
`118`	`145`	`for i := 0; i < b.N; i++ {`
`119`		`- Geometry(g, 10)`
	`146`	`+ _, err := Geometry(g, 10)`
	`147`	`+ if err != nil {`
	`148`	`+ b.Fatalf("unexpected error: %v", err)`
	`149`	`+ }`
`120`	`150`	`}`
`121`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,9 @@ import (`
`8`	`8`
`9`	`9`	`func TestGeometry(t *testing.T) {`
`10`	`10`	`for _, g := range orb.AllGeometries {`
`11`		`- Geometry(g, 1)`
	`11`	`+ _, err := Geometry(g, 1)`
	`12`	`+ if err != nil {`
	`13`	`+ t.Fatalf("unexpected error for %T: %v", g, err)`
	`14`	`+ }`
`12`	`15`	`}`
`13`	`16`	`}`