New Upstream Snapshot - golang-github-jacobsa-oglematchers
Ready changes
Summary
Merged new upstream version: 0.0~git20150720 (was: 0.0~git20150320).
Resulting package
Built on 2022-03-28T11:46 (took 3m19s)
The resulting binary packages can be installed (if you have the apt repository enabled) by running one of:
apt install -t fresh-snapshots golang-github-jacobsa-oglematchers-dev
Lintian Result
Diff
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..dd8fc74
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+*.6
+6.out
+_obj/
+_test/
+_testmain.go
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..b972119
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,4 @@
+# Cf. http://docs.travis-ci.com/user/getting-started/
+# Cf. http://docs.travis-ci.com/user/languages/go/
+
+language: go
diff --git a/debian/changelog b/debian/changelog
index 5044a0d..c9aa366 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,8 +1,12 @@
-golang-github-jacobsa-oglematchers (0.0~git20150320-4) UNRELEASED; urgency=medium
+golang-github-jacobsa-oglematchers (0.0~git20150720-1) UNRELEASED; urgency=medium
+ [ Alexandre Viau ]
* Point Vcs-* urls to salsa.debian.org.
- -- Alexandre Viau <aviau@debian.org> Mon, 02 Apr 2018 18:02:15 -0400
+ [ Debian Janitor ]
+ * New upstream snapshot.
+
+ -- Alexandre Viau <aviau@debian.org> Mon, 28 Mar 2022 11:43:33 -0000
golang-github-jacobsa-oglematchers (0.0~git20150320-3) unstable; urgency=medium
diff --git a/equals.go b/equals.go
index 26280c5..a510707 100644
--- a/equals.go
+++ b/equals.go
@@ -86,7 +86,7 @@ func isSignedInteger(v reflect.Value) bool {
func isUnsignedInteger(v reflect.Value) bool {
k := v.Kind()
- return k >= reflect.Uint && k <= reflect.Uint64
+ return k >= reflect.Uint && k <= reflect.Uintptr
}
func isInteger(v reflect.Value) bool {
@@ -313,19 +313,6 @@ func checkAgainstBool(e bool, c reflect.Value) (err error) {
return
}
-func checkAgainstUintptr(e uintptr, c reflect.Value) (err error) {
- if c.Kind() != reflect.Uintptr {
- err = NewFatalError("which is not a uintptr")
- return
- }
-
- err = errors.New("")
- if uintptr(c.Uint()) == e {
- err = nil
- }
- return
-}
-
func checkAgainstChan(e reflect.Value, c reflect.Value) (err error) {
// Create a description of e's type, e.g. "chan int".
typeStr := fmt.Sprintf("%s %s", e.Type().ChanDir(), e.Type().Elem())
@@ -501,9 +488,6 @@ func (m *equalsMatcher) Matches(candidate interface{}) error {
case isUnsignedInteger(e):
return checkAgainstUint64(e.Uint(), c)
- case ek == reflect.Uintptr:
- return checkAgainstUintptr(uintptr(e.Uint()), c)
-
case ek == reflect.Float32:
return checkAgainstFloat32(float32(e.Float()), c)
diff --git a/equals_test.go b/equals_test.go
index 6fdbd9b..25e372c 100644
--- a/equals_test.go
+++ b/equals_test.go
@@ -17,10 +17,11 @@ package oglematchers_test
import (
"fmt"
- . "github.com/jacobsa/oglematchers"
- . "github.com/jacobsa/ogletest"
"math"
"unsafe"
+
+ . "github.com/jacobsa/oglematchers"
+ . "github.com/jacobsa/ogletest"
)
var someInt int = -17
@@ -124,6 +125,7 @@ func (t *EqualsTest) NegativeIntegerLiteral() {
equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
// Non-equal values of signed integer type.
equalsTestCase{int(-1073741823), false, false, ""},
@@ -137,7 +139,6 @@ func (t *EqualsTest) NegativeIntegerLiteral() {
equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -168,6 +169,7 @@ func (t *EqualsTest) PositiveIntegerLiteral() {
equalsTestCase{int64(1073741824), true, false, ""},
equalsTestCase{uint32(1073741824), true, false, ""},
equalsTestCase{uint64(1073741824), true, false, ""},
+ equalsTestCase{uintptr(1073741824), true, false, ""},
equalsTestCase{float32(1073741824), true, false, ""},
equalsTestCase{float64(1073741824), true, false, ""},
equalsTestCase{complex64(1073741824), true, false, ""},
@@ -185,7 +187,6 @@ func (t *EqualsTest) PositiveIntegerLiteral() {
equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -228,6 +229,7 @@ func (t *EqualsTest) NegativeIntegralFloatingPointLiteral() {
equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
// Non-equal values of signed integer type.
equalsTestCase{int(-1073741823), false, false, ""},
@@ -241,7 +243,6 @@ func (t *EqualsTest) NegativeIntegralFloatingPointLiteral() {
equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -283,6 +284,7 @@ func (t *EqualsTest) PositiveIntegralFloatingPointLiteral() {
equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
// Non-equal values of numeric type.
equalsTestCase{int(1073741823), false, false, ""},
@@ -297,7 +299,6 @@ func (t *EqualsTest) PositiveIntegralFloatingPointLiteral() {
equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -337,10 +338,10 @@ func (t *EqualsTest) NonIntegralFloatingPointLiteral() {
equalsTestCase{uint(17), false, false, ""},
equalsTestCase{uint32(17), false, false, ""},
equalsTestCase{uint64(17), false, false, ""},
+ equalsTestCase{uintptr(17), false, false, ""},
equalsTestCase{complex128(17.1 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -460,6 +461,7 @@ func (t *EqualsTest) NegativeInt() {
equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
// Non-equal values of signed integer type.
equalsTestCase{int(-1073741823), false, false, ""},
@@ -473,7 +475,6 @@ func (t *EqualsTest) NegativeInt() {
equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -504,6 +505,7 @@ func (t *EqualsTest) PositiveInt() {
equalsTestCase{int64(1073741824), true, false, ""},
equalsTestCase{uint32(1073741824), true, false, ""},
equalsTestCase{uint64(1073741824), true, false, ""},
+ equalsTestCase{uintptr(1073741824), true, false, ""},
equalsTestCase{float32(1073741824), true, false, ""},
equalsTestCase{float64(1073741824), true, false, ""},
equalsTestCase{complex64(1073741824), true, false, ""},
@@ -521,7 +523,6 @@ func (t *EqualsTest) PositiveInt() {
equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -566,6 +567,7 @@ func (t *EqualsTest) NegativeInt8() {
equalsTestCase{uint16((1 << 16) - 17), false, false, ""},
equalsTestCase{uint32((1 << 32) - 17), false, false, ""},
equalsTestCase{uint64((1 << 64) - 17), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 17), false, false, ""},
// Non-equal values of signed integer type.
equalsTestCase{int(-16), false, false, ""},
@@ -581,7 +583,6 @@ func (t *EqualsTest) NegativeInt8() {
equalsTestCase{complex64(-17 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr((1 << 32) - 17), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{-17}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -620,6 +621,7 @@ func (t *EqualsTest) ZeroInt8() {
equalsTestCase{uint16(0), true, false, ""},
equalsTestCase{uint32(0), true, false, ""},
equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
// Non-equal values of numeric type.
equalsTestCase{int(1), false, false, ""},
@@ -633,7 +635,6 @@ func (t *EqualsTest) ZeroInt8() {
equalsTestCase{complex64(0 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{0}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -672,6 +673,7 @@ func (t *EqualsTest) PositiveInt8() {
equalsTestCase{uint16(17), true, false, ""},
equalsTestCase{uint32(17), true, false, ""},
equalsTestCase{uint64(17), true, false, ""},
+ equalsTestCase{uintptr(17), true, false, ""},
// Non-equal values of numeric type.
equalsTestCase{int(16), false, false, ""},
@@ -685,7 +687,6 @@ func (t *EqualsTest) PositiveInt8() {
equalsTestCase{complex64(17 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(17), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{17}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -728,6 +729,7 @@ func (t *EqualsTest) NegativeInt16() {
equalsTestCase{uint16((1 << 16) - 32766), false, false, ""},
equalsTestCase{uint32((1 << 32) - 32766), false, false, ""},
equalsTestCase{uint64((1 << 64) - 32766), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 32766), false, false, ""},
// Non-equal values of signed integer type.
equalsTestCase{int(-16), false, false, ""},
@@ -743,7 +745,6 @@ func (t *EqualsTest) NegativeInt16() {
equalsTestCase{complex64(-32766 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr((1 << 32) - 32766), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{-32766}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -782,6 +783,7 @@ func (t *EqualsTest) ZeroInt16() {
equalsTestCase{uint16(0), true, false, ""},
equalsTestCase{uint32(0), true, false, ""},
equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
// Non-equal values of numeric type.
equalsTestCase{int(1), false, false, ""},
@@ -795,7 +797,6 @@ func (t *EqualsTest) ZeroInt16() {
equalsTestCase{complex64(0 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{0}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -832,6 +833,7 @@ func (t *EqualsTest) PositiveInt16() {
equalsTestCase{uint16(32765), true, false, ""},
equalsTestCase{uint32(32765), true, false, ""},
equalsTestCase{uint64(32765), true, false, ""},
+ equalsTestCase{uintptr(32765), true, false, ""},
// Non-equal values of numeric type.
equalsTestCase{int(32764), false, false, ""},
@@ -844,7 +846,6 @@ func (t *EqualsTest) PositiveInt16() {
equalsTestCase{complex64(32765 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(32765), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{32765}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -886,6 +887,7 @@ func (t *EqualsTest) NegativeInt32() {
equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
// Non-equal values of signed integer type.
equalsTestCase{int(-1073741823), false, false, ""},
@@ -899,7 +901,6 @@ func (t *EqualsTest) NegativeInt32() {
equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -930,6 +931,7 @@ func (t *EqualsTest) PositiveInt32() {
equalsTestCase{int64(1073741824), true, false, ""},
equalsTestCase{uint32(1073741824), true, false, ""},
equalsTestCase{uint64(1073741824), true, false, ""},
+ equalsTestCase{uintptr(1073741824), true, false, ""},
equalsTestCase{float32(1073741824), true, false, ""},
equalsTestCase{float64(1073741824), true, false, ""},
equalsTestCase{complex64(1073741824), true, false, ""},
@@ -947,7 +949,6 @@ func (t *EqualsTest) PositiveInt32() {
equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -995,7 +996,6 @@ func (t *EqualsTest) NegativeInt64() {
equalsTestCase{complex128(-1099511627776 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -1021,6 +1021,7 @@ func (t *EqualsTest) PositiveInt64() {
equalsTestCase{1099511627776 + 0i, true, false, ""},
equalsTestCase{int64(1099511627776), true, false, ""},
equalsTestCase{uint64(1099511627776), true, false, ""},
+ equalsTestCase{uintptr(1099511627776), true, false, ""},
equalsTestCase{float32(1099511627776), true, false, ""},
equalsTestCase{float64(1099511627776), true, false, ""},
equalsTestCase{complex64(1099511627776), true, false, ""},
@@ -1037,7 +1038,6 @@ func (t *EqualsTest) PositiveInt64() {
equalsTestCase{complex128(1099511627776 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -1159,6 +1159,7 @@ func (t *EqualsTest) SmallUint() {
equalsTestCase{uint16(kExpected), true, false, ""},
equalsTestCase{uint32(kExpected), true, false, ""},
equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
equalsTestCase{float32(kExpected), true, false, ""},
equalsTestCase{float64(kExpected), true, false, ""},
equalsTestCase{complex64(kExpected), true, false, ""},
@@ -1176,6 +1177,7 @@ func (t *EqualsTest) SmallUint() {
equalsTestCase{uint16(kExpected + 1), false, false, ""},
equalsTestCase{uint32(kExpected + 1), false, false, ""},
equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
equalsTestCase{float32(kExpected + 1), false, false, ""},
equalsTestCase{float64(kExpected + 1), false, false, ""},
equalsTestCase{complex64(kExpected + 2i), false, false, ""},
@@ -1184,7 +1186,6 @@ func (t *EqualsTest) SmallUint() {
equalsTestCase{complex128(kExpected + 1), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -1303,6 +1304,7 @@ func (t *EqualsTest) SmallUint8() {
equalsTestCase{uint16(kExpected), true, false, ""},
equalsTestCase{uint32(kExpected), true, false, ""},
equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
equalsTestCase{float32(kExpected), true, false, ""},
equalsTestCase{float64(kExpected), true, false, ""},
equalsTestCase{complex64(kExpected), true, false, ""},
@@ -1320,6 +1322,7 @@ func (t *EqualsTest) SmallUint8() {
equalsTestCase{uint16(kExpected + 1), false, false, ""},
equalsTestCase{uint32(kExpected + 1), false, false, ""},
equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
equalsTestCase{float32(kExpected + 1), false, false, ""},
equalsTestCase{float64(kExpected + 1), false, false, ""},
equalsTestCase{complex64(kExpected + 2i), false, false, ""},
@@ -1328,7 +1331,6 @@ func (t *EqualsTest) SmallUint8() {
equalsTestCase{complex128(kExpected + 1), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -1367,6 +1369,7 @@ func (t *EqualsTest) SmallUint16() {
equalsTestCase{uint16(kExpected), true, false, ""},
equalsTestCase{uint32(kExpected), true, false, ""},
equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
equalsTestCase{float32(kExpected), true, false, ""},
equalsTestCase{float64(kExpected), true, false, ""},
equalsTestCase{complex64(kExpected), true, false, ""},
@@ -1384,6 +1387,7 @@ func (t *EqualsTest) SmallUint16() {
equalsTestCase{uint16(kExpected + 1), false, false, ""},
equalsTestCase{uint32(kExpected + 1), false, false, ""},
equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
equalsTestCase{float32(kExpected + 1), false, false, ""},
equalsTestCase{float64(kExpected + 1), false, false, ""},
equalsTestCase{complex64(kExpected + 2i), false, false, ""},
@@ -1392,7 +1396,6 @@ func (t *EqualsTest) SmallUint16() {
equalsTestCase{complex128(kExpected + 1), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -1469,6 +1472,7 @@ func (t *EqualsTest) SmallUint32() {
equalsTestCase{uint16(kExpected), true, false, ""},
equalsTestCase{uint32(kExpected), true, false, ""},
equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
equalsTestCase{float32(kExpected), true, false, ""},
equalsTestCase{float64(kExpected), true, false, ""},
equalsTestCase{complex64(kExpected), true, false, ""},
@@ -1486,6 +1490,7 @@ func (t *EqualsTest) SmallUint32() {
equalsTestCase{uint16(kExpected + 1), false, false, ""},
equalsTestCase{uint32(kExpected + 1), false, false, ""},
equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
equalsTestCase{float32(kExpected + 1), false, false, ""},
equalsTestCase{float64(kExpected + 1), false, false, ""},
equalsTestCase{complex64(kExpected + 2i), false, false, ""},
@@ -1494,7 +1499,6 @@ func (t *EqualsTest) SmallUint32() {
equalsTestCase{complex128(kExpected + 1), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -1613,6 +1617,7 @@ func (t *EqualsTest) SmallUint64() {
equalsTestCase{uint16(kExpected), true, false, ""},
equalsTestCase{uint32(kExpected), true, false, ""},
equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
equalsTestCase{float32(kExpected), true, false, ""},
equalsTestCase{float64(kExpected), true, false, ""},
equalsTestCase{complex64(kExpected), true, false, ""},
@@ -1630,6 +1635,7 @@ func (t *EqualsTest) SmallUint64() {
equalsTestCase{uint16(kExpected + 1), false, false, ""},
equalsTestCase{uint32(kExpected + 1), false, false, ""},
equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
equalsTestCase{float32(kExpected + 1), false, false, ""},
equalsTestCase{float64(kExpected + 1), false, false, ""},
equalsTestCase{complex64(kExpected + 2i), false, false, ""},
@@ -1638,7 +1644,6 @@ func (t *EqualsTest) SmallUint64() {
equalsTestCase{complex128(kExpected + 1), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -1771,79 +1776,95 @@ func (t *EqualsTest) Uint64NotExactlyRepresentableByDoublePrecision() {
// uintptr
////////////////////////////////////////////////////////////////////////
-func (t *EqualsTest) NilUintptr() {
- var ptr1 uintptr
- var ptr2 uintptr
-
- matcher := Equals(ptr1)
- ExpectEq("0", matcher.Description())
+func (t *EqualsTest) SmallUintptr() {
+ const kExpected = 17
+ matcher := Equals(uintptr(kExpected))
+ ExpectEq("17", matcher.Description())
cases := []equalsTestCase{
- // uintptrs
- equalsTestCase{ptr1, true, false, ""},
- equalsTestCase{ptr2, true, false, ""},
- equalsTestCase{uintptr(0), true, false, ""},
- equalsTestCase{uintptr(17), false, false, ""},
+ // Various types of the expected value.
+ equalsTestCase{17, true, false, ""},
+ equalsTestCase{17.0, true, false, ""},
+ equalsTestCase{17 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int8(kExpected), true, false, ""},
+ equalsTestCase{int16(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint(kExpected), true, false, ""},
+ equalsTestCase{uint8(kExpected), true, false, ""},
+ equalsTestCase{uint16(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
- // Other types.
- equalsTestCase{0, false, true, "which is not a uintptr"},
- equalsTestCase{bool(false), false, true, "which is not a uintptr"},
- equalsTestCase{int(0), false, true, "which is not a uintptr"},
- equalsTestCase{int8(0), false, true, "which is not a uintptr"},
- equalsTestCase{int16(0), false, true, "which is not a uintptr"},
- equalsTestCase{int32(0), false, true, "which is not a uintptr"},
- equalsTestCase{int64(0), false, true, "which is not a uintptr"},
- equalsTestCase{uint(0), false, true, "which is not a uintptr"},
- equalsTestCase{uint8(0), false, true, "which is not a uintptr"},
- equalsTestCase{uint16(0), false, true, "which is not a uintptr"},
- equalsTestCase{uint32(0), false, true, "which is not a uintptr"},
- equalsTestCase{uint64(0), false, true, "which is not a uintptr"},
- equalsTestCase{true, false, true, "which is not a uintptr"},
- equalsTestCase{[...]int{}, false, true, "which is not a uintptr"},
- equalsTestCase{make(chan int), false, true, "which is not a uintptr"},
- equalsTestCase{func() {}, false, true, "which is not a uintptr"},
- equalsTestCase{map[int]int{}, false, true, "which is not a uintptr"},
- equalsTestCase{&someInt, false, true, "which is not a uintptr"},
- equalsTestCase{[]int{}, false, true, "which is not a uintptr"},
- equalsTestCase{"taco", false, true, "which is not a uintptr"},
- equalsTestCase{equalsTestCase{}, false, true, "which is not a uintptr"},
- }
-
- t.checkTestCases(matcher, cases)
-}
-
-func (t *EqualsTest) NonNilUintptr() {
- matcher := Equals(uintptr(17))
- ExpectEq("17", matcher.Description())
+ // Non-equal values of numeric types.
+ equalsTestCase{kExpected + 1, false, false, ""},
+ equalsTestCase{int(kExpected + 1), false, false, ""},
+ equalsTestCase{int8(kExpected + 1), false, false, ""},
+ equalsTestCase{int16(kExpected + 1), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(kExpected + 1), false, false, ""},
+ equalsTestCase{uint8(kExpected + 1), false, false, ""},
+ equalsTestCase{uint16(kExpected + 1), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUintptr() {
+ const kExpected = (1 << 32) + 17
+ matcher := Equals(uintptr(kExpected))
+ ExpectEq("4294967313", matcher.Description())
cases := []equalsTestCase{
- // uintptrs
- equalsTestCase{uintptr(17), true, false, ""},
- equalsTestCase{uintptr(16), false, false, ""},
- equalsTestCase{uintptr(0), false, false, ""},
+ // Various types of the expected value.
+ equalsTestCase{4294967313.0, true, false, ""},
+ equalsTestCase{4294967313 + 0i, true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
- // Other types.
- equalsTestCase{0, false, true, "which is not a uintptr"},
- equalsTestCase{bool(false), false, true, "which is not a uintptr"},
- equalsTestCase{int(0), false, true, "which is not a uintptr"},
- equalsTestCase{int8(0), false, true, "which is not a uintptr"},
- equalsTestCase{int16(0), false, true, "which is not a uintptr"},
- equalsTestCase{int32(0), false, true, "which is not a uintptr"},
- equalsTestCase{int64(0), false, true, "which is not a uintptr"},
- equalsTestCase{uint(0), false, true, "which is not a uintptr"},
- equalsTestCase{uint8(0), false, true, "which is not a uintptr"},
- equalsTestCase{uint16(0), false, true, "which is not a uintptr"},
- equalsTestCase{uint32(0), false, true, "which is not a uintptr"},
- equalsTestCase{uint64(0), false, true, "which is not a uintptr"},
- equalsTestCase{true, false, true, "which is not a uintptr"},
- equalsTestCase{[...]int{}, false, true, "which is not a uintptr"},
- equalsTestCase{make(chan int), false, true, "which is not a uintptr"},
- equalsTestCase{func() {}, false, true, "which is not a uintptr"},
- equalsTestCase{map[int]int{}, false, true, "which is not a uintptr"},
- equalsTestCase{&someInt, false, true, "which is not a uintptr"},
- equalsTestCase{[]int{}, false, true, "which is not a uintptr"},
- equalsTestCase{"taco", false, true, "which is not a uintptr"},
- equalsTestCase{equalsTestCase{}, false, true, "which is not a uintptr"},
+ // Non-equal values of numeric types.
+ equalsTestCase{int(17), false, false, ""},
+ equalsTestCase{int32(17), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(17), false, false, ""},
+ equalsTestCase{uint32(17), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
}
t.checkTestCases(matcher, cases)
@@ -1872,6 +1893,7 @@ func (t *EqualsTest) NegativeIntegralFloat32() {
// Values that would be -32769 in two's complement.
equalsTestCase{uint64((1 << 64) - 32769), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 32769), false, false, ""},
// Non-equal values of numeric type.
equalsTestCase{int64(-32770), false, false, ""},
@@ -1883,7 +1905,6 @@ func (t *EqualsTest) NegativeIntegralFloat32() {
equalsTestCase{complex128(-32769 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -1972,6 +1993,7 @@ func (t *EqualsTest) ZeroFloat32() {
equalsTestCase{uint16(0), true, false, ""},
equalsTestCase{uint32(0), true, false, ""},
equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
equalsTestCase{float32(0), true, false, ""},
equalsTestCase{float64(0), true, false, ""},
equalsTestCase{complex64(0), true, false, ""},
@@ -1986,7 +2008,6 @@ func (t *EqualsTest) ZeroFloat32() {
equalsTestCase{complex128(0 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -2015,6 +2036,7 @@ func (t *EqualsTest) PositiveIntegralFloat32() {
equalsTestCase{uint(32769), true, false, ""},
equalsTestCase{uint32(32769), true, false, ""},
equalsTestCase{uint64(32769), true, false, ""},
+ equalsTestCase{uintptr(32769), true, false, ""},
equalsTestCase{float32(32769), true, false, ""},
equalsTestCase{float64(32769), true, false, ""},
equalsTestCase{complex64(32769), true, false, ""},
@@ -2032,7 +2054,6 @@ func (t *EqualsTest) PositiveIntegralFloat32() {
equalsTestCase{complex128(32769 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -2196,7 +2217,6 @@ func (t *EqualsTest) NegativeIntegralFloat64() {
equalsTestCase{complex128(kExpected + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -2286,6 +2306,7 @@ func (t *EqualsTest) ZeroFloat64() {
equalsTestCase{uint16(0), true, false, ""},
equalsTestCase{uint32(0), true, false, ""},
equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
equalsTestCase{float32(0), true, false, ""},
equalsTestCase{float64(0), true, false, ""},
equalsTestCase{complex64(0), true, false, ""},
@@ -2300,7 +2321,6 @@ func (t *EqualsTest) ZeroFloat64() {
equalsTestCase{complex128(0 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -2326,6 +2346,7 @@ func (t *EqualsTest) PositiveIntegralFloat64() {
equalsTestCase{1125899906842624.0 + 0i, true, false, ""},
equalsTestCase{int64(kExpected), true, false, ""},
equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
equalsTestCase{float32(kExpected), true, false, ""},
equalsTestCase{float64(kExpected), true, false, ""},
equalsTestCase{complex64(kExpected), true, false, ""},
@@ -2335,6 +2356,7 @@ func (t *EqualsTest) PositiveIntegralFloat64() {
// Non-equal values of numeric type.
equalsTestCase{int64(kExpected + 1), false, false, ""},
equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
equalsTestCase{float64(kExpected - 0.5), false, false, ""},
@@ -2343,7 +2365,6 @@ func (t *EqualsTest) PositiveIntegralFloat64() {
equalsTestCase{complex128(kExpected + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -2483,6 +2504,7 @@ func (t *EqualsTest) NegativeIntegralComplex64() {
// Values that would be kExpected in two's complement.
equalsTestCase{uint32((1 << 32) + kExpected), false, false, ""},
equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) + kExpected), false, false, ""},
// Non-equal values of numeric type.
equalsTestCase{int64(kExpected + 1), false, false, ""},
@@ -2496,7 +2518,6 @@ func (t *EqualsTest) NegativeIntegralComplex64() {
equalsTestCase{complex128(kExpected + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -2594,6 +2615,7 @@ func (t *EqualsTest) ZeroComplex64() {
equalsTestCase{uint16(0), true, false, ""},
equalsTestCase{uint32(0), true, false, ""},
equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
equalsTestCase{float32(0), true, false, ""},
equalsTestCase{float64(0), true, false, ""},
equalsTestCase{complex64(0), true, false, ""},
@@ -2611,7 +2633,6 @@ func (t *EqualsTest) ZeroComplex64() {
equalsTestCase{complex128(0 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -2641,6 +2662,7 @@ func (t *EqualsTest) PositiveIntegralComplex64() {
equalsTestCase{uint(kExpected), true, false, ""},
equalsTestCase{uint32(kExpected), true, false, ""},
equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
equalsTestCase{float32(kExpected), true, false, ""},
equalsTestCase{float64(kExpected), true, false, ""},
equalsTestCase{complex64(kExpected), true, false, ""},
@@ -2654,6 +2676,7 @@ func (t *EqualsTest) PositiveIntegralComplex64() {
equalsTestCase{uint(kExpected + 1), false, false, ""},
equalsTestCase{uint32(kExpected + 1), false, false, ""},
equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
equalsTestCase{float64(kExpected - 0.5), false, false, ""},
@@ -2662,7 +2685,6 @@ func (t *EqualsTest) PositiveIntegralComplex64() {
equalsTestCase{complex128(kExpected + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -2862,6 +2884,7 @@ func (t *EqualsTest) NegativeIntegralComplex128() {
// Values that would be kExpected in two's complement.
equalsTestCase{uint32((1 << 32) + kExpected), false, false, ""},
equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) + kExpected), false, false, ""},
// Non-equal values of numeric type.
equalsTestCase{int64(kExpected + 1), false, false, ""},
@@ -2875,7 +2898,6 @@ func (t *EqualsTest) NegativeIntegralComplex128() {
equalsTestCase{complex128(kExpected + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -2973,6 +2995,7 @@ func (t *EqualsTest) ZeroComplex128() {
equalsTestCase{uint16(0), true, false, ""},
equalsTestCase{uint32(0), true, false, ""},
equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
equalsTestCase{float32(0), true, false, ""},
equalsTestCase{float64(0), true, false, ""},
equalsTestCase{complex64(0), true, false, ""},
@@ -2990,7 +3013,6 @@ func (t *EqualsTest) ZeroComplex128() {
equalsTestCase{complex128(0 + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -3020,6 +3042,7 @@ func (t *EqualsTest) PositiveIntegralComplex128() {
equalsTestCase{uint(kExpected), true, false, ""},
equalsTestCase{uint32(kExpected), true, false, ""},
equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
equalsTestCase{float32(kExpected), true, false, ""},
equalsTestCase{float64(kExpected), true, false, ""},
equalsTestCase{complex64(kExpected), true, false, ""},
@@ -3033,6 +3056,7 @@ func (t *EqualsTest) PositiveIntegralComplex128() {
equalsTestCase{uint(kExpected + 1), false, false, ""},
equalsTestCase{uint32(kExpected + 1), false, false, ""},
equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
equalsTestCase{float64(kExpected - 0.5), false, false, ""},
@@ -3041,7 +3065,6 @@ func (t *EqualsTest) PositiveIntegralComplex128() {
equalsTestCase{complex128(kExpected + 2i), false, false, ""},
// Non-numeric types.
- equalsTestCase{uintptr(0), false, true, "which is not numeric"},
equalsTestCase{true, false, true, "which is not numeric"},
equalsTestCase{[...]int{}, false, true, "which is not numeric"},
equalsTestCase{make(chan int), false, true, "which is not numeric"},
@@ -3212,7 +3235,7 @@ func (t *EqualsTest) ArrayOfComparableType() {
ExpectEq("[17 19 23]", matcher.Description())
// To defeat constant de-duping by the compiler.
- makeArray := func(i, j, k uint) [3]uint { return [3]uint{ i, j, k} }
+ makeArray := func(i, j, k uint) [3]uint { return [3]uint{i, j, k} }
type arrayAlias [3]uint
type uintAlias uint
@@ -3782,7 +3805,6 @@ func (t *EqualsTest) NilUnsafePointer() {
equalsTestCase{uint16(0), false, true, "which is not a unsafe.Pointer"},
equalsTestCase{uint32(0), false, true, "which is not a unsafe.Pointer"},
equalsTestCase{uint64(0), false, true, "which is not a unsafe.Pointer"},
- equalsTestCase{uintptr(0), false, true, "which is not a unsafe.Pointer"},
equalsTestCase{true, false, true, "which is not a unsafe.Pointer"},
equalsTestCase{[...]int{}, false, true, "which is not a unsafe.Pointer"},
equalsTestCase{make(chan int), false, true, "which is not a unsafe.Pointer"},
@@ -3827,7 +3849,6 @@ func (t *EqualsTest) NonNilUnsafePointer() {
equalsTestCase{uint16(0), false, true, "which is not a unsafe.Pointer"},
equalsTestCase{uint32(0), false, true, "which is not a unsafe.Pointer"},
equalsTestCase{uint64(0), false, true, "which is not a unsafe.Pointer"},
- equalsTestCase{uintptr(0), false, true, "which is not a unsafe.Pointer"},
equalsTestCase{true, false, true, "which is not a unsafe.Pointer"},
equalsTestCase{[...]int{}, false, true, "which is not a unsafe.Pointer"},
equalsTestCase{make(chan int), false, true, "which is not a unsafe.Pointer"},
diff --git a/greater_or_equal_test.go b/greater_or_equal_test.go
index 639f0e0..3f37f08 100644
--- a/greater_or_equal_test.go
+++ b/greater_or_equal_test.go
@@ -16,9 +16,10 @@
package oglematchers_test
import (
+ "math"
+
. "github.com/jacobsa/oglematchers"
. "github.com/jacobsa/ogletest"
- "math"
)
////////////////////////////////////////////////////////////////////////
@@ -78,7 +79,6 @@ func (t *GreaterOrEqualTest) IntegerCandidateBadTypes() {
cases := []geTestCase{
geTestCase{true, false, true, "which is not comparable"},
- geTestCase{uintptr(17), false, true, "which is not comparable"},
geTestCase{complex64(-151), false, true, "which is not comparable"},
geTestCase{complex128(-151), false, true, "which is not comparable"},
geTestCase{[...]int{-151}, false, true, "which is not comparable"},
@@ -99,7 +99,6 @@ func (t *GreaterOrEqualTest) FloatCandidateBadTypes() {
cases := []geTestCase{
geTestCase{true, false, true, "which is not comparable"},
- geTestCase{uintptr(17), false, true, "which is not comparable"},
geTestCase{complex64(-151), false, true, "which is not comparable"},
geTestCase{complex128(-151), false, true, "which is not comparable"},
geTestCase{[...]int{-151}, false, true, "which is not comparable"},
@@ -130,7 +129,6 @@ func (t *GreaterOrEqualTest) StringCandidateBadTypes() {
geTestCase{uint16(0), false, true, "which is not comparable"},
geTestCase{uint32(0), false, true, "which is not comparable"},
geTestCase{uint64(0), false, true, "which is not comparable"},
- geTestCase{uintptr(17), false, true, "which is not comparable"},
geTestCase{float32(0), false, true, "which is not comparable"},
geTestCase{float64(0), false, true, "which is not comparable"},
geTestCase{complex64(-151), false, true, "which is not comparable"},
@@ -231,6 +229,10 @@ func (t *GreaterOrEqualTest) NegativeIntegerLiteral() {
geTestCase{uint64(0), true, false, ""},
geTestCase{uint64(17), true, false, ""},
+ geTestCase{uintptr((1 << 64) - 151), true, false, ""},
+ geTestCase{uintptr(0), true, false, ""},
+ geTestCase{uintptr(17), true, false, ""},
+
// Floating point.
geTestCase{float32(-(1 << 30)), false, false, ""},
geTestCase{float32(-151), false, false, ""},
@@ -319,6 +321,10 @@ func (t *GreaterOrEqualTest) ZeroIntegerLiteral() {
geTestCase{uint64(0), true, false, ""},
geTestCase{uint64(17), true, false, ""},
+ geTestCase{uintptr((1 << 64) - 1), true, false, ""},
+ geTestCase{uintptr(0), true, false, ""},
+ geTestCase{uintptr(17), true, false, ""},
+
// Floating point.
geTestCase{float32(-(1 << 30)), false, false, ""},
geTestCase{float32(-1), false, false, ""},
@@ -404,6 +410,11 @@ func (t *GreaterOrEqualTest) PositiveIntegerLiteral() {
geTestCase{uint64(150), true, false, ""},
geTestCase{uint64(151), true, false, ""},
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(149), false, false, ""},
+ geTestCase{uintptr(150), true, false, ""},
+ geTestCase{uintptr(151), true, false, ""},
+
// Floating point.
geTestCase{float32(-1), false, false, ""},
geTestCase{float32(149), false, false, ""},
@@ -491,6 +502,10 @@ func (t *GreaterOrEqualTest) NegativeFloatLiteral() {
geTestCase{uint64(0), true, false, ""},
geTestCase{uint64(17), true, false, ""},
+ geTestCase{uintptr((1 << 64) - 151), true, false, ""},
+ geTestCase{uintptr(0), true, false, ""},
+ geTestCase{uintptr(17), true, false, ""},
+
// Floating point.
geTestCase{float32(-(1 << 30)), false, false, ""},
geTestCase{float32(-151), false, false, ""},
@@ -577,6 +592,11 @@ func (t *GreaterOrEqualTest) PositiveFloatLiteral() {
geTestCase{uint64(150), true, false, ""},
geTestCase{uint64(151), true, false, ""},
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(149), false, false, ""},
+ geTestCase{uintptr(150), true, false, ""},
+ geTestCase{uintptr(151), true, false, ""},
+
// Floating point.
geTestCase{float32(-1), false, false, ""},
geTestCase{float32(149), false, false, ""},
@@ -663,6 +683,11 @@ func (t *GreaterOrEqualTest) Int64NotExactlyRepresentableBySinglePrecision() {
geTestCase{uint64(kTwoTo25 + 1), true, false, ""},
geTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 0), false, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 2), true, false, ""},
+
// Floating point.
geTestCase{float32(-1), false, false, ""},
geTestCase{float32(kTwoTo25 - 2), false, false, ""},
@@ -739,6 +764,12 @@ func (t *GreaterOrEqualTest) Int64NotExactlyRepresentableByDoublePrecision() {
geTestCase{uint64(kTwoTo54 + 1), true, false, ""},
geTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 - 1), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 0), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 1), true, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 2), true, false, ""},
+
// Floating point.
geTestCase{float64(-1), false, false, ""},
geTestCase{float64(kTwoTo54 - 2), false, false, ""},
@@ -815,6 +846,11 @@ func (t *GreaterOrEqualTest) Uint64NotExactlyRepresentableBySinglePrecision() {
geTestCase{uint64(kTwoTo25 + 1), true, false, ""},
geTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 0), false, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 2), true, false, ""},
+
// Floating point.
geTestCase{float32(-1), false, false, ""},
geTestCase{float32(kTwoTo25 - 2), false, false, ""},
@@ -891,6 +927,12 @@ func (t *GreaterOrEqualTest) Uint64NotExactlyRepresentableByDoublePrecision() {
geTestCase{uint64(kTwoTo54 + 1), true, false, ""},
geTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 - 1), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 0), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 1), true, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 2), true, false, ""},
+
// Floating point.
geTestCase{float64(-1), false, false, ""},
geTestCase{float64(kTwoTo54 - 2), false, false, ""},
diff --git a/greater_than_test.go b/greater_than_test.go
index 7846925..eb995a0 100644
--- a/greater_than_test.go
+++ b/greater_than_test.go
@@ -16,9 +16,10 @@
package oglematchers_test
import (
+ "math"
+
. "github.com/jacobsa/oglematchers"
. "github.com/jacobsa/ogletest"
- "math"
)
////////////////////////////////////////////////////////////////////////
@@ -78,7 +79,6 @@ func (t *GreaterThanTest) IntegerCandidateBadTypes() {
cases := []gtTestCase{
gtTestCase{true, false, true, "which is not comparable"},
- gtTestCase{uintptr(17), false, true, "which is not comparable"},
gtTestCase{complex64(-151), false, true, "which is not comparable"},
gtTestCase{complex128(-151), false, true, "which is not comparable"},
gtTestCase{[...]int{-151}, false, true, "which is not comparable"},
@@ -99,7 +99,6 @@ func (t *GreaterThanTest) FloatCandidateBadTypes() {
cases := []gtTestCase{
gtTestCase{true, false, true, "which is not comparable"},
- gtTestCase{uintptr(17), false, true, "which is not comparable"},
gtTestCase{complex64(-151), false, true, "which is not comparable"},
gtTestCase{complex128(-151), false, true, "which is not comparable"},
gtTestCase{[...]int{-151}, false, true, "which is not comparable"},
@@ -130,7 +129,6 @@ func (t *GreaterThanTest) StringCandidateBadTypes() {
gtTestCase{uint16(0), false, true, "which is not comparable"},
gtTestCase{uint32(0), false, true, "which is not comparable"},
gtTestCase{uint64(0), false, true, "which is not comparable"},
- gtTestCase{uintptr(17), false, true, "which is not comparable"},
gtTestCase{float32(0), false, true, "which is not comparable"},
gtTestCase{float64(0), false, true, "which is not comparable"},
gtTestCase{complex64(-151), false, true, "which is not comparable"},
diff --git a/less_or_equal_test.go b/less_or_equal_test.go
index bdb4a88..87132ce 100644
--- a/less_or_equal_test.go
+++ b/less_or_equal_test.go
@@ -16,9 +16,10 @@
package oglematchers_test
import (
+ "math"
+
. "github.com/jacobsa/oglematchers"
. "github.com/jacobsa/ogletest"
- "math"
)
////////////////////////////////////////////////////////////////////////
@@ -78,7 +79,6 @@ func (t *LessOrEqualTest) IntegerCandidateBadTypes() {
cases := []leTestCase{
leTestCase{true, false, true, "which is not comparable"},
- leTestCase{uintptr(17), false, true, "which is not comparable"},
leTestCase{complex64(-151), false, true, "which is not comparable"},
leTestCase{complex128(-151), false, true, "which is not comparable"},
leTestCase{[...]int{-151}, false, true, "which is not comparable"},
@@ -99,7 +99,6 @@ func (t *LessOrEqualTest) FloatCandidateBadTypes() {
cases := []leTestCase{
leTestCase{true, false, true, "which is not comparable"},
- leTestCase{uintptr(17), false, true, "which is not comparable"},
leTestCase{complex64(-151), false, true, "which is not comparable"},
leTestCase{complex128(-151), false, true, "which is not comparable"},
leTestCase{[...]int{-151}, false, true, "which is not comparable"},
@@ -130,7 +129,6 @@ func (t *LessOrEqualTest) StringCandidateBadTypes() {
leTestCase{uint16(0), false, true, "which is not comparable"},
leTestCase{uint32(0), false, true, "which is not comparable"},
leTestCase{uint64(0), false, true, "which is not comparable"},
- leTestCase{uintptr(17), false, true, "which is not comparable"},
leTestCase{float32(0), false, true, "which is not comparable"},
leTestCase{float64(0), false, true, "which is not comparable"},
leTestCase{complex64(-151), false, true, "which is not comparable"},
diff --git a/less_than_test.go b/less_than_test.go
index 6ee6e9f..baca4a1 100644
--- a/less_than_test.go
+++ b/less_than_test.go
@@ -16,9 +16,10 @@
package oglematchers_test
import (
+ "math"
+
. "github.com/jacobsa/oglematchers"
. "github.com/jacobsa/ogletest"
- "math"
)
////////////////////////////////////////////////////////////////////////
@@ -78,7 +79,6 @@ func (t *LessThanTest) IntegerCandidateBadTypes() {
cases := []ltTestCase{
ltTestCase{true, false, true, "which is not comparable"},
- ltTestCase{uintptr(17), false, true, "which is not comparable"},
ltTestCase{complex64(-151), false, true, "which is not comparable"},
ltTestCase{complex128(-151), false, true, "which is not comparable"},
ltTestCase{[...]int{-151}, false, true, "which is not comparable"},
@@ -99,7 +99,6 @@ func (t *LessThanTest) FloatCandidateBadTypes() {
cases := []ltTestCase{
ltTestCase{true, false, true, "which is not comparable"},
- ltTestCase{uintptr(17), false, true, "which is not comparable"},
ltTestCase{complex64(-151), false, true, "which is not comparable"},
ltTestCase{complex128(-151), false, true, "which is not comparable"},
ltTestCase{[...]int{-151}, false, true, "which is not comparable"},
@@ -130,7 +129,6 @@ func (t *LessThanTest) StringCandidateBadTypes() {
ltTestCase{uint16(0), false, true, "which is not comparable"},
ltTestCase{uint32(0), false, true, "which is not comparable"},
ltTestCase{uint64(0), false, true, "which is not comparable"},
- ltTestCase{uintptr(17), false, true, "which is not comparable"},
ltTestCase{float32(0), false, true, "which is not comparable"},
ltTestCase{float64(0), false, true, "which is not comparable"},
ltTestCase{complex64(-151), false, true, "which is not comparable"},
Debdiff
File lists identical (after any substitutions)
No differences were encountered in the control files