Bump google.golang.org/api

vendor/github.com/google/go-cmp/cmp/internal/value/pointer_purego.go

@@ -0,0 +1,23 @@
+// Copyright 2018, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// +build purego
+
+package value
+
+import "reflect"
+
+// Pointer is an opaque typed pointer and is guaranteed to be comparable.
+type Pointer struct {
+	p uintptr
+	t reflect.Type
+}
+
+// PointerOf returns a Pointer from v, which must be a
+// reflect.Ptr, reflect.Slice, or reflect.Map.
+func PointerOf(v reflect.Value) Pointer {
+	// NOTE: Storing a pointer as an uintptr is technically incorrect as it
+	// assumes that the GC implementation does not use a moving collector.
+	return Pointer{v.Pointer(), v.Type()}
+}

vendor/github.com/google/go-cmp/cmp/internal/value/pointer_unsafe.go

@@ -0,0 +1,26 @@
+// Copyright 2018, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// +build !purego
+
+package value
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// Pointer is an opaque typed pointer and is guaranteed to be comparable.
+type Pointer struct {
+	p unsafe.Pointer
+	t reflect.Type
+}
+
+// PointerOf returns a Pointer from v, which must be a
+// reflect.Ptr, reflect.Slice, or reflect.Map.
+func PointerOf(v reflect.Value) Pointer {
+	// The proper representation of a pointer is unsafe.Pointer,
+	// which is necessary if the GC ever uses a moving collector.
+	return Pointer{unsafe.Pointer(v.Pointer()), v.Type()}
+}

vendor/github.com/google/go-cmp/cmp/internal/value/sort.go

@@ -0,0 +1,104 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package value
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"sort"
+)
+
+// SortKeys sorts a list of map keys, deduplicating keys if necessary.
+// The type of each value must be comparable.
+func SortKeys(vs []reflect.Value) []reflect.Value {
+	if len(vs) == 0 {
+		return vs
+	}
+
+	// Sort the map keys.
+	sort.Slice(vs, func(i, j int) bool { return isLess(vs[i], vs[j]) })
+
+	// Deduplicate keys (fails for NaNs).
+	vs2 := vs[:1]
+	for _, v := range vs[1:] {
+		if isLess(vs2[len(vs2)-1], v) {
+			vs2 = append(vs2, v)
+		}
+	}
+	return vs2
+}
+
+// isLess is a generic function for sorting arbitrary map keys.
+// The inputs must be of the same type and must be comparable.
+func isLess(x, y reflect.Value) bool {
+	switch x.Type().Kind() {
+	case reflect.Bool:
+		return !x.Bool() && y.Bool()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return x.Int() < y.Int()
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return x.Uint() < y.Uint()
+	case reflect.Float32, reflect.Float64:
+		fx, fy := x.Float(), y.Float()
+		return fx < fy || math.IsNaN(fx) && !math.IsNaN(fy)
+	case reflect.Complex64, reflect.Complex128:
+		cx, cy := x.Complex(), y.Complex()
+		rx, ix, ry, iy := real(cx), imag(cx), real(cy), imag(cy)
+		if rx == ry || (math.IsNaN(rx) && math.IsNaN(ry)) {
+			return ix < iy || math.IsNaN(ix) && !math.IsNaN(iy)
+		}
+		return rx < ry || math.IsNaN(rx) && !math.IsNaN(ry)
+	case reflect.Ptr, reflect.UnsafePointer, reflect.Chan:
+		return x.Pointer() < y.Pointer()
+	case reflect.String:
+		return x.String() < y.String()
+	case reflect.Array:
+		for i := 0; i < x.Len(); i++ {
+			if isLess(x.Index(i), y.Index(i)) {
+				return true
+			}
+			if isLess(y.Index(i), x.Index(i)) {
+				return false
+			}
+		}
+		return false
+	case reflect.Struct:
+		for i := 0; i < x.NumField(); i++ {
+			if isLess(x.Field(i), y.Field(i)) {
+				return true
+			}
+			if isLess(y.Field(i), x.Field(i)) {
+				return false
+			}
+		}
+		return false
+	case reflect.Interface:
+		vx, vy := x.Elem(), y.Elem()
+		if !vx.IsValid() || !vy.IsValid() {
+			return !vx.IsValid() && vy.IsValid()
+		}
+		tx, ty := vx.Type(), vy.Type()
+		if tx == ty {
+			return isLess(x.Elem(), y.Elem())
+		}
+		if tx.Kind() != ty.Kind() {
+			return vx.Kind() < vy.Kind()
+		}
+		if tx.String() != ty.String() {
+			return tx.String() < ty.String()
+		}
+		if tx.PkgPath() != ty.PkgPath() {
+			return tx.PkgPath() < ty.PkgPath()
+		}
+		// This can happen in rare situations, so we fallback to just comparing
+		// the unique pointer for a reflect.Type. This guarantees deterministic
+		// ordering within a program, but it is obviously not stable.
+		return reflect.ValueOf(vx.Type()).Pointer() < reflect.ValueOf(vy.Type()).Pointer()
+	default:
+		// Must be Func, Map, or Slice; which are not comparable.
+		panic(fmt.Sprintf("%T is not comparable", x.Type()))
+	}
+}

vendor/github.com/google/go-cmp/cmp/internal/value/sort_test.go

@@ -0,0 +1,159 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package value_test
+
+import (
+	"math"
+	"reflect"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/internal/value"
+)
+
+func TestSortKeys(t *testing.T) {
+	type (
+		MyString string
+		MyArray  [2]int
+		MyStruct struct {
+			A MyString
+			B MyArray
+			C chan float64
+		}
+		EmptyStruct struct{}
+	)
+
+	opts := []cmp.Option{
+		cmp.Comparer(func(x, y float64) bool {
+			if math.IsNaN(x) && math.IsNaN(y) {
+				return true
+			}
+			return x == y
+		}),
+		cmp.Comparer(func(x, y complex128) bool {
+			rx, ix, ry, iy := real(x), imag(x), real(y), imag(y)
+			if math.IsNaN(rx) && math.IsNaN(ry) {
+				rx, ry = 0, 0
+			}
+			if math.IsNaN(ix) && math.IsNaN(iy) {
+				ix, iy = 0, 0
+			}
+			return rx == ry && ix == iy
+		}),
+		cmp.Comparer(func(x, y chan bool) bool { return true }),
+		cmp.Comparer(func(x, y chan int) bool { return true }),
+		cmp.Comparer(func(x, y chan float64) bool { return true }),
+		cmp.Comparer(func(x, y chan interface{}) bool { return true }),
+		cmp.Comparer(func(x, y *int) bool { return true }),
+	}
+
+	tests := []struct {
+		in   map[interface{}]bool // Set of keys to sort
+		want []interface{}
+	}{{
+		in:   map[interface{}]bool{1: true, 2: true, 3: true},
+		want: []interface{}{1, 2, 3},
+	}, {
+		in: map[interface{}]bool{
+			nil:                    true,
+			true:                   true,
+			false:                  true,
+			-5:                     true,
+			-55:                    true,
+			-555:                   true,
+			uint(1):                true,
+			uint(11):               true,
+			uint(111):              true,
+			"abc":                  true,
+			"abcd":                 true,
+			"abcde":                true,
+			"foo":                  true,
+			"bar":                  true,
+			MyString("abc"):        true,
+			MyString("abcd"):       true,
+			MyString("abcde"):      true,
+			new(int):               true,
+			new(int):               true,
+			make(chan bool):        true,
+			make(chan bool):        true,
+			make(chan int):         true,
+			make(chan interface{}): true,
+			math.Inf(+1):           true,
+			math.Inf(-1):           true,
+			1.2345:                 true,
+			12.345:                 true,
+			123.45:                 true,
+			1234.5:                 true,
+			0 + 0i:                 true,
+			1 + 0i:                 true,
+			2 + 0i:                 true,
+			0 + 1i:                 true,
+			0 + 2i:                 true,
+			0 + 3i:                 true,
+			[2]int{2, 3}:           true,
+			[2]int{4, 0}:           true,
+			[2]int{2, 4}:           true,
+			MyArray([2]int{2, 4}):  true,
+			EmptyStruct{}:          true,
+			MyStruct{
+				"bravo", [2]int{2, 3}, make(chan float64),
+			}: true,
+			MyStruct{
+				"alpha", [2]int{3, 3}, make(chan float64),
+			}: true,
+		},
+		want: []interface{}{
+			nil, false, true,
+			-555, -55, -5, uint(1), uint(11), uint(111),
+			math.Inf(-1), 1.2345, 12.345, 123.45, 1234.5, math.Inf(+1),
+			(0 + 0i), (0 + 1i), (0 + 2i), (0 + 3i), (1 + 0i), (2 + 0i),
+			[2]int{2, 3}, [2]int{2, 4}, [2]int{4, 0}, MyArray([2]int{2, 4}),
+			make(chan bool), make(chan bool), make(chan int), make(chan interface{}),
+			new(int), new(int),
+			"abc", "abcd", "abcde", "bar", "foo",
+			MyString("abc"), MyString("abcd"), MyString("abcde"),
+			EmptyStruct{},
+			MyStruct{"alpha", [2]int{3, 3}, make(chan float64)},
+			MyStruct{"bravo", [2]int{2, 3}, make(chan float64)},
+		},
+	}, {
+		// NaN values cannot be properly deduplicated.
+		// This is okay since map entries with NaN in the keys cannot be
+		// retrieved anyways.
+		in: map[interface{}]bool{
+			math.NaN():                      true,
+			math.NaN():                      true,
+			complex(0, math.NaN()):          true,
+			complex(0, math.NaN()):          true,
+			complex(math.NaN(), 0):          true,
+			complex(math.NaN(), 0):          true,
+			complex(math.NaN(), math.NaN()): true,
+		},
+		want: []interface{}{
+			math.NaN(),
+			complex(math.NaN(), math.NaN()),
+			complex(math.NaN(), 0),
+			complex(0, math.NaN()),
+		},
+	}}
+
+	for i, tt := range tests {
+		// Intentionally pass the map via an unexported field to detect panics.
+		// Unfortunately, we cannot actually test the keys without using unsafe.
+		v := reflect.ValueOf(struct{ x map[interface{}]bool }{tt.in}).Field(0)
+		value.SortKeys(append(v.MapKeys(), v.MapKeys()...))
+
+		// Try again, with keys that have read-write access in reflect.
+		v = reflect.ValueOf(tt.in)
+		keys := append(v.MapKeys(), v.MapKeys()...)
+		var got []interface{}
+		for _, k := range value.SortKeys(keys) {
+			got = append(got, k.Interface())
+		}
+		if d := cmp.Diff(got, tt.want, opts...); d != "" {
+			t.Errorf("test %d, Sort() mismatch (-got +want):\n%s", i, d)
+		}
+	}
+}

vendor/github.com/google/go-cmp/cmp/internal/value/zero.go

@@ -0,0 +1,45 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package value
+
+import "reflect"
+
+// IsZero reports whether v is the zero value.
+// This does not rely on Interface and so can be used on unexported fields.
+func IsZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Bool:
+		return v.Bool() == false
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Complex64, reflect.Complex128:
+		return v.Complex() == 0
+	case reflect.String:
+		return v.String() == ""
+	case reflect.UnsafePointer:
+		return v.Pointer() == 0
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
+		return v.IsNil()
+	case reflect.Array:
+		for i := 0; i < v.Len(); i++ {
+			if !IsZero(v.Index(i)) {
+				return false
+			}
+		}
+		return true
+	case reflect.Struct:
+		for i := 0; i < v.NumField(); i++ {
+			if !IsZero(v.Field(i)) {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}

vendor/github.com/google/go-cmp/cmp/internal/value/zero_test.go

@@ -0,0 +1,45 @@
+// Copyright 2019, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package value
+
+import (
+	"archive/tar"
+	"reflect"
+	"testing"
+)
+
+func TestIsZero(t *testing.T) {
+	tests := []struct {
+		in   interface{}
+		want bool
+	}{
+		{0, true},
+		{1, false},
+		{"", true},
+		{"foo", false},
+		{[]byte(nil), true},
+		{[]byte{}, false},
+		{map[string]bool(nil), true},
+		{map[string]bool{}, false},
+		{tar.Header{}, true},
+		{&tar.Header{}, false},
+		{tar.Header{Name: "foo"}, false},
+		{(chan bool)(nil), true},
+		{make(chan bool), false},
+		{(func(*testing.T))(nil), true},
+		{TestIsZero, false},
+		{[...]int{0, 0, 0}, true},
+		{[...]int{0, 1, 0}, false},
+	}
+
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			got := IsZero(reflect.ValueOf(tt.in))
+			if got != tt.want {
+				t.Errorf("IsZero(%v) = %v, want %v", tt.in, got, tt.want)
+			}
+		})
+	}
+}