Vendor cleanup

Signed-off-by: Madhu Rajanna <mrajanna@redhat.com>

vendor/k8s.io/apimachinery/pkg/api/resource/OWNERS

@@ -1,16 +0,0 @@
-reviewers:
-- thockin
-- lavalamp
-- smarterclayton
-- wojtek-t
-- derekwaynecarr
-- mikedanese
-- saad-ali
-- janetkuo
-- tallclair
-- eparis
-- jbeda
-- xiang90
-- mbohlool
-- david-mcmahon
-- goltermann

vendor/k8s.io/apimachinery/pkg/api/resource/amount_test.go

@@ -1,162 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors.
-
-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.
-*/
-
-package resource
-
-import (
-	"testing"
-)
-
-func TestInt64AmountAsInt64(t *testing.T) {
-	for _, test := range []struct {
-		value  int64
-		scale  Scale
-		result int64
-		ok     bool
-	}{
-		{100, 0, 100, true},
-		{100, 1, 1000, true},
-		{100, -5, 0, false},
-		{100, 100, 0, false},
-	} {
-		r, ok := int64Amount{value: test.value, scale: test.scale}.AsInt64()
-		if r != test.result {
-			t.Errorf("%v: unexpected result: %d", test, r)
-		}
-		if ok != test.ok {
-			t.Errorf("%v: unexpected ok: %t", test, ok)
-		}
-	}
-}
-
-func TestInt64AmountAdd(t *testing.T) {
-	for _, test := range []struct {
-		a, b, c int64Amount
-		ok      bool
-	}{
-		{int64Amount{value: 100, scale: 1}, int64Amount{value: 10, scale: 2}, int64Amount{value: 200, scale: 1}, true},
-		{int64Amount{value: 100, scale: 1}, int64Amount{value: 1, scale: 2}, int64Amount{value: 110, scale: 1}, true},
-		{int64Amount{value: 100, scale: 1}, int64Amount{value: 1, scale: 100}, int64Amount{value: 1, scale: 100}, false},
-		{int64Amount{value: -5, scale: 2}, int64Amount{value: 50, scale: 1}, int64Amount{value: 0, scale: 1}, true},
-		{int64Amount{value: -5, scale: 2}, int64Amount{value: 5, scale: 2}, int64Amount{value: 0, scale: 2}, true},
-
-		{int64Amount{value: mostPositive, scale: -1}, int64Amount{value: 1, scale: -1}, int64Amount{value: 0, scale: -1}, false},
-		{int64Amount{value: mostPositive, scale: -1}, int64Amount{value: 0, scale: -1}, int64Amount{value: mostPositive, scale: -1}, true},
-		{int64Amount{value: mostPositive / 10, scale: 1}, int64Amount{value: 10, scale: 0}, int64Amount{value: mostPositive, scale: -1}, false},
-	} {
-		c := test.a
-		ok := c.Add(test.b)
-		if ok != test.ok {
-			t.Errorf("%v: unexpected ok: %t", test, ok)
-		}
-		if ok {
-			if c != test.c {
-				t.Errorf("%v: unexpected result: %d", test, c)
-			}
-		} else {
-			if c != test.a {
-				t.Errorf("%v: overflow addition mutated source: %d", test, c)
-			}
-		}
-
-		// addition is commutative
-		c = test.b
-		if ok := c.Add(test.a); ok != test.ok {
-			t.Errorf("%v: unexpected ok: %t", test, ok)
-		}
-		if ok {
-			if c != test.c {
-				t.Errorf("%v: unexpected result: %d", test, c)
-			}
-		} else {
-			if c != test.b {
-				t.Errorf("%v: overflow addition mutated source: %d", test, c)
-			}
-		}
-	}
-}
-func TestInt64AsCanonicalString(t *testing.T) {
-	for _, test := range []struct {
-		value    int64
-		scale    Scale
-		result   string
-		exponent int32
-	}{
-		{100, 0, "100", 0},
-		{100, 1, "1", 3},
-		{100, -1, "10", 0},
-		{10800, -10, "1080", -9},
-	} {
-		r, exp := int64Amount{value: test.value, scale: test.scale}.AsCanonicalBytes(nil)
-		if string(r) != test.result {
-			t.Errorf("%v: unexpected result: %s", test, r)
-		}
-		if exp != test.exponent {
-			t.Errorf("%v: unexpected exponent: %d", test, exp)
-		}
-	}
-}
-
-func TestAmountSign(t *testing.T) {
-	table := []struct {
-		i      int64Amount
-		expect int
-	}{
-		{int64Amount{value: -50, scale: 1}, -1},
-		{int64Amount{value: 0, scale: 1}, 0},
-		{int64Amount{value: 300, scale: 1}, 1},
-		{int64Amount{value: -50, scale: -8}, -1},
-		{int64Amount{value: 50, scale: -8}, 1},
-		{int64Amount{value: 0, scale: -8}, 0},
-		{int64Amount{value: -50, scale: 0}, -1},
-		{int64Amount{value: 50, scale: 0}, 1},
-		{int64Amount{value: 0, scale: 0}, 0},
-	}
-	for _, testCase := range table {
-		if result := testCase.i.Sign(); result != testCase.expect {
-			t.Errorf("i: %v, Expected: %v, Actual: %v", testCase.i, testCase.expect, result)
-		}
-	}
-}
-
-func TestInt64AmountAsScaledInt64(t *testing.T) {
-	for _, test := range []struct {
-		name   string
-		i      int64Amount
-		scaled Scale
-		result int64
-		ok     bool
-	}{
-		{"test when i.scale < scaled ", int64Amount{value: 100, scale: 0}, 5, 1, true},
-		{"test when i.scale = scaled", int64Amount{value: 100, scale: 1}, 1, 100, true},
-		{"test when i.scale > scaled and result doesn't overflow", int64Amount{value: 100, scale: 5}, 2, 100000, true},
-		{"test when i.scale > scaled and result overflows", int64Amount{value: 876, scale: 30}, 4, 0, false},
-		{"test when i.scale < 0 and fraction exists", int64Amount{value: 93, scale: -1}, 0, 10, true},
-		{"test when i.scale < 0 and fraction doesn't exist", int64Amount{value: 100, scale: -1}, 0, 10, true},
-		{"test when i.value < 0 and fraction exists", int64Amount{value: -1932, scale: 2}, 4, -20, true},
-		{"test when i.value < 0 and fraction doesn't exists", int64Amount{value: -1900, scale: 2}, 4, -19, true},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			r, ok := test.i.AsScaledInt64(test.scaled)
-			if r != test.result {
-				t.Errorf("%v: expected result: %d, got result: %d", test.name, test.result, r)
-			}
-			if ok != test.ok {
-				t.Errorf("%v: expected ok: %t, got ok: %t", test.name, test.ok, ok)
-			}
-		})
-	}
-}

vendor/k8s.io/apimachinery/pkg/api/resource/generated.proto

@@ -1,88 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-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.
-*/
-
-
-// This file was autogenerated by go-to-protobuf. Do not edit it manually!
-
-syntax = 'proto2';
-
-package k8s.io.apimachinery.pkg.api.resource;
-
-// Package-wide variables from generator "generated".
-option go_package = "resource";
-
-// Quantity is a fixed-point representation of a number.
-// It provides convenient marshaling/unmarshaling in JSON and YAML,
-// in addition to String() and Int64() accessors.
-//
-// The serialization format is:
-//
-// <quantity>        ::= <signedNumber><suffix>
-//   (Note that <suffix> may be empty, from the "" case in <decimalSI>.)
-// <digit>           ::= 0 | 1 | ... | 9
-// <digits>          ::= <digit> | <digit><digits>
-// <number>          ::= <digits> | <digits>.<digits> | <digits>. | .<digits>
-// <sign>            ::= "+" | "-"
-// <signedNumber>    ::= <number> | <sign><number>
-// <suffix>          ::= <binarySI> | <decimalExponent> | <decimalSI>
-// <binarySI>        ::= Ki | Mi | Gi | Ti | Pi | Ei
-//   (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)
-// <decimalSI>       ::= m | "" | k | M | G | T | P | E
-//   (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)
-// <decimalExponent> ::= "e" <signedNumber> | "E" <signedNumber>
-//
-// No matter which of the three exponent forms is used, no quantity may represent
-// a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal
-// places. Numbers larger or more precise will be capped or rounded up.
-// (E.g.: 0.1m will rounded up to 1m.)
-// This may be extended in the future if we require larger or smaller quantities.
-//
-// When a Quantity is parsed from a string, it will remember the type of suffix
-// it had, and will use the same type again when it is serialized.
-//
-// Before serializing, Quantity will be put in "canonical form".
-// This means that Exponent/suffix will be adjusted up or down (with a
-// corresponding increase or decrease in Mantissa) such that:
-//   a. No precision is lost
-//   b. No fractional digits will be emitted
-//   c. The exponent (or suffix) is as large as possible.
-// The sign will be omitted unless the number is negative.
-//
-// Examples:
-//   1.5 will be serialized as "1500m"
-//   1.5Gi will be serialized as "1536Mi"
-//
-// Note that the quantity will NEVER be internally represented by a
-// floating point number. That is the whole point of this exercise.
-//
-// Non-canonical values will still parse as long as they are well formed,
-// but will be re-emitted in their canonical form. (So always use canonical
-// form, or don't diff.)
-//
-// This format is intended to make it difficult to use these numbers without
-// writing some sort of special handling code in the hopes that that will
-// cause implementors to also use a fixed point implementation.
-//
-// +protobuf=true
-// +protobuf.embed=string
-// +protobuf.options.marshal=false
-// +protobuf.options.(gogoproto.goproto_stringer)=false
-// +k8s:deepcopy-gen=true
-// +k8s:openapi-gen=true
-message Quantity {
-  optional string string = 1;
-}
-

vendor/k8s.io/apimachinery/pkg/api/resource/math_test.go

@@ -1,211 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors.
-
-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.
-*/
-
-package resource
-
-import (
-	"testing"
-)
-
-func TestDetectOverflowAdd(t *testing.T) {
-	for _, test := range []struct {
-		a, b int64
-		c    int64
-		ok   bool
-	}{
-		{0, 0, 0, true},
-		{-1, 1, 0, true},
-		{0, 1, 1, true},
-		{2, 2, 4, true},
-		{2, -2, 0, true},
-		{-2, -2, -4, true},
-
-		{mostNegative, -1, 0, false},
-		{mostNegative, 1, mostNegative + 1, true},
-		{mostPositive, -1, mostPositive - 1, true},
-		{mostPositive, 1, 0, false},
-
-		{mostNegative, mostPositive, -1, true},
-		{mostPositive, mostNegative, -1, true},
-		{mostPositive, mostPositive, 0, false},
-		{mostNegative, mostNegative, 0, false},
-
-		{-mostPositive, mostNegative, 0, false},
-		{mostNegative, -mostPositive, 0, false},
-		{-mostPositive, -mostPositive, 0, false},
-	} {
-		c, ok := int64Add(test.a, test.b)
-		if c != test.c {
-			t.Errorf("%v: unexpected result: %d", test, c)
-		}
-		if ok != test.ok {
-			t.Errorf("%v: unexpected overflow: %t", test, ok)
-		}
-		// addition is commutative
-		d, ok2 := int64Add(test.b, test.a)
-		if c != d || ok != ok2 {
-			t.Errorf("%v: not commutative: %d %t", test, d, ok2)
-		}
-	}
-}
-
-func TestDetectOverflowMultiply(t *testing.T) {
-	for _, test := range []struct {
-		a, b int64
-		c    int64
-		ok   bool
-	}{
-		{0, 0, 0, true},
-		{-1, 1, -1, true},
-		{-1, -1, 1, true},
-		{1, 1, 1, true},
-		{0, 1, 0, true},
-		{1, 0, 0, true},
-		{2, 2, 4, true},
-		{2, -2, -4, true},
-		{-2, -2, 4, true},
-
-		{mostNegative, -1, 0, false},
-		{mostNegative, 1, mostNegative, true},
-		{mostPositive, -1, -mostPositive, true},
-		{mostPositive, 1, mostPositive, true},
-
-		{mostNegative, mostPositive, 0, false},
-		{mostPositive, mostNegative, 0, false},
-		{mostPositive, mostPositive, 1, false},
-		{mostNegative, mostNegative, 0, false},
-
-		{-mostPositive, mostNegative, 0, false},
-		{mostNegative, -mostPositive, 0, false},
-		{-mostPositive, -mostPositive, 1, false},
-	} {
-		c, ok := int64Multiply(test.a, test.b)
-		if c != test.c {
-			t.Errorf("%v: unexpected result: %d", test, c)
-		}
-		if ok != test.ok {
-			t.Errorf("%v: unexpected overflow: %t", test, ok)
-		}
-		// multiplication is commutative
-		d, ok2 := int64Multiply(test.b, test.a)
-		if c != d || ok != ok2 {
-			t.Errorf("%v: not commutative: %d %t", test, d, ok2)
-		}
-	}
-}
-
-func TestDetectOverflowScale(t *testing.T) {
-	for _, a := range []int64{0, -1, 1, 10, -10, mostPositive, mostNegative, -mostPositive} {
-		for _, b := range []int64{1, 2, 10, 100, 1000, mostPositive} {
-			expect, expectOk := int64Multiply(a, b)
-
-			c, ok := int64MultiplyScale(a, b)
-			if c != expect {
-				t.Errorf("%d*%d: unexpected result: %d", a, b, c)
-			}
-			if ok != expectOk {
-				t.Errorf("%d*%d: unexpected overflow: %t", a, b, ok)
-			}
-		}
-		for _, test := range []struct {
-			base int64
-			fn   func(a int64) (int64, bool)
-		}{
-			{10, int64MultiplyScale10},
-			{100, int64MultiplyScale100},
-			{1000, int64MultiplyScale1000},
-		} {
-			expect, expectOk := int64Multiply(a, test.base)
-			c, ok := test.fn(a)
-			if c != expect {
-				t.Errorf("%d*%d: unexpected result: %d", a, test.base, c)
-			}
-			if ok != expectOk {
-				t.Errorf("%d*%d: unexpected overflow: %t", a, test.base, ok)
-			}
-		}
-	}
-}
-
-func TestRemoveInt64Factors(t *testing.T) {
-	for _, test := range []struct {
-		value  int64
-		max    int64
-		result int64
-		scale  int32
-	}{
-		{100, 10, 1, 2},
-		{100, 10, 1, 2},
-		{100, 100, 1, 1},
-		{1, 10, 1, 0},
-	} {
-		r, s := removeInt64Factors(test.value, test.max)
-		if r != test.result {
-			t.Errorf("%v: unexpected result: %d", test, r)
-		}
-		if s != test.scale {
-			t.Errorf("%v: unexpected scale: %d", test, s)
-		}
-	}
-}
-
-func TestNegativeScaleInt64(t *testing.T) {
-	for _, test := range []struct {
-		base   int64
-		scale  Scale
-		result int64
-		exact  bool
-	}{
-		{1234567, 0, 1234567, true},
-		{1234567, 1, 123457, false},
-		{1234567, 2, 12346, false},
-		{1234567, 3, 1235, false},
-		{1234567, 4, 124, false},
-
-		{-1234567, 0, -1234567, true},
-		{-1234567, 1, -123457, false},
-		{-1234567, 2, -12346, false},
-		{-1234567, 3, -1235, false},
-		{-1234567, 4, -124, false},
-
-		{1000, 0, 1000, true},
-		{1000, 1, 100, true},
-		{1000, 2, 10, true},
-		{1000, 3, 1, true},
-		{1000, 4, 1, false},
-
-		{-1000, 0, -1000, true},
-		{-1000, 1, -100, true},
-		{-1000, 2, -10, true},
-		{-1000, 3, -1, true},
-		{-1000, 4, -1, false},
-
-		{0, 0, 0, true},
-		{0, 1, 0, true},
-		{0, 2, 0, true},
-
-		// negative scale is undefined behavior
-		{1000, -1, 1000, true},
-	} {
-		result, exact := negativeScaleInt64(test.base, test.scale)
-		if result != test.result {
-			t.Errorf("%v: unexpected result: %d", test, result)
-		}
-		if exact != test.exact {
-			t.Errorf("%v: unexpected exact: %t", test, exact)
-		}
-	}
-}

vendor/k8s.io/apimachinery/pkg/api/resource/quantity_example_test.go

@@ -1,59 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors.
-
-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.
-*/
-
-package resource_test
-
-import (
-	"fmt"
-
-	"k8s.io/apimachinery/pkg/api/resource"
-)
-
-func ExampleFormat() {
-	memorySize := resource.NewQuantity(5*1024*1024*1024, resource.BinarySI)
-	fmt.Printf("memorySize = %v\n", memorySize)
-
-	diskSize := resource.NewQuantity(5*1000*1000*1000, resource.DecimalSI)
-	fmt.Printf("diskSize = %v\n", diskSize)
-
-	cores := resource.NewMilliQuantity(5300, resource.DecimalSI)
-	fmt.Printf("cores = %v\n", cores)
-
-	// Output:
-	// memorySize = 5Gi
-	// diskSize = 5G
-	// cores = 5300m
-}
-
-func ExampleMustParse() {
-	memorySize := resource.MustParse("5Gi")
-	fmt.Printf("memorySize = %v (%v)\n", memorySize.Value(), memorySize.Format)
-
-	diskSize := resource.MustParse("5G")
-	fmt.Printf("diskSize = %v (%v)\n", diskSize.Value(), diskSize.Format)
-
-	cores := resource.MustParse("5300m")
-	fmt.Printf("milliCores = %v (%v)\n", cores.MilliValue(), cores.Format)
-
-	cores2 := resource.MustParse("5.4")
-	fmt.Printf("milliCores = %v (%v)\n", cores2.MilliValue(), cores2.Format)
-
-	// Output:
-	// memorySize = 5368709120 (BinarySI)
-	// diskSize = 5000000000 (DecimalSI)
-	// milliCores = 5300 (DecimalSI)
-	// milliCores = 5400 (DecimalSI)
-}

vendor/k8s.io/apimachinery/pkg/api/resource/quantity_proto_test.go

@@ -1,103 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-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.
-*/
-
-package resource
-
-import (
-	"testing"
-
-	inf "gopkg.in/inf.v0"
-)
-
-func TestQuantityProtoMarshal(t *testing.T) {
-	// Test when d is nil
-	table := []struct {
-		quantity string
-		expect   Quantity
-	}{
-		{"0", Quantity{i: int64Amount{value: 0, scale: 0}, s: "0", Format: DecimalSI}},
-		{"100m", Quantity{i: int64Amount{value: 100, scale: -3}, s: "100m", Format: DecimalSI}},
-		{"50m", Quantity{i: int64Amount{value: 50, scale: -3}, s: "50m", Format: DecimalSI}},
-		{"10000T", Quantity{i: int64Amount{value: 10000, scale: 12}, s: "10000T", Format: DecimalSI}},
-	}
-	for _, testCase := range table {
-		q := MustParse(testCase.quantity)
-		// Won't currently get an error as MarshalTo can't return one
-		result, _ := q.Marshal()
-		q.MarshalTo(result)
-		if q.Cmp(testCase.expect) != 0 {
-			t.Errorf("Expected: %v, Actual: %v", testCase.expect, q)
-		}
-	}
-	// Test when i is {0,0}
-	table2 := []struct {
-		dec    *inf.Dec
-		expect Quantity
-	}{
-		{dec(0, 0).Dec, Quantity{i: int64Amount{value: 0, scale: 0}, d: infDecAmount{dec(0, 0).Dec}, s: "0", Format: DecimalSI}},
-		{dec(10, 0).Dec, Quantity{i: int64Amount{value: 0, scale: 0}, d: infDecAmount{dec(10, 0).Dec}, s: "10", Format: DecimalSI}},
-		{dec(-10, 0).Dec, Quantity{i: int64Amount{value: 0, scale: 0}, d: infDecAmount{dec(-10, 0).Dec}, s: "-10", Format: DecimalSI}},
-	}
-	for _, testCase := range table2 {
-		q := Quantity{d: infDecAmount{testCase.dec}, Format: DecimalSI}
-		// Won't currently get an error as MarshalTo can't return one
-		result, _ := q.Marshal()
-		q.Unmarshal(result)
-		if q.Cmp(testCase.expect) != 0 {
-			t.Errorf("Expected: %v, Actual: %v", testCase.expect, q)
-		}
-	}
-}
-
-func TestQuantityProtoUnmarshal(t *testing.T) {
-	// Test when d is nil
-	table := []struct {
-		input  Quantity
-		expect string
-	}{
-		{Quantity{i: int64Amount{value: 0, scale: 0}, s: "0", Format: DecimalSI}, "0"},
-		{Quantity{i: int64Amount{value: 100, scale: -3}, s: "100m", Format: DecimalSI}, "100m"},
-		{Quantity{i: int64Amount{value: 50, scale: -3}, s: "50m", Format: DecimalSI}, "50m"},
-		{Quantity{i: int64Amount{value: 10000, scale: 12}, s: "10000T", Format: DecimalSI}, "10000T"},
-	}
-	for _, testCase := range table {
-		var inputQ Quantity
-		expectQ := MustParse(testCase.expect)
-		inputByteArray, _ := testCase.input.Marshal()
-		inputQ.Unmarshal(inputByteArray)
-		if inputQ.Cmp(expectQ) != 0 {
-			t.Errorf("Expected: %v, Actual: %v", inputQ, expectQ)
-		}
-	}
-	// Test when i is {0,0}
-	table2 := []struct {
-		input  Quantity
-		expect *inf.Dec
-	}{
-		{Quantity{i: int64Amount{value: 0, scale: 0}, d: infDecAmount{dec(0, 0).Dec}, s: "0", Format: DecimalSI}, dec(0, 0).Dec},
-		{Quantity{i: int64Amount{value: 0, scale: 0}, d: infDecAmount{dec(10, 0).Dec}, s: "10", Format: DecimalSI}, dec(10, 0).Dec},
-		{Quantity{i: int64Amount{value: 0, scale: 0}, d: infDecAmount{dec(-10, 0).Dec}, s: "-10", Format: DecimalSI}, dec(-10, 0).Dec},
-	}
-	for _, testCase := range table2 {
-		var inputQ Quantity
-		expectQ := Quantity{d: infDecAmount{testCase.expect}, Format: DecimalSI}
-		inputByteArray, _ := testCase.input.Marshal()
-		inputQ.Unmarshal(inputByteArray)
-		if inputQ.Cmp(expectQ) != 0 {
-			t.Errorf("Expected: %v, Actual: %v", inputQ, expectQ)
-		}
-	}
-}

vendor/k8s.io/apimachinery/pkg/api/resource/scale_int_test.go

@@ -1,85 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors.
-
-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.
-*/
-
-package resource
-
-import (
-	"math"
-	"math/big"
-	"testing"
-)
-
-func TestScaledValueInternal(t *testing.T) {
-	tests := []struct {
-		unscaled *big.Int
-		scale    int
-		newScale int
-
-		want int64
-	}{
-		// remain scale
-		{big.NewInt(1000), 0, 0, 1000},
-
-		// scale down
-		{big.NewInt(1000), 0, -3, 1},
-		{big.NewInt(1000), 3, 0, 1},
-		{big.NewInt(0), 3, 0, 0},
-
-		// always round up
-		{big.NewInt(999), 3, 0, 1},
-		{big.NewInt(500), 3, 0, 1},
-		{big.NewInt(499), 3, 0, 1},
-		{big.NewInt(1), 3, 0, 1},
-		// large scaled value does not lose precision
-		{big.NewInt(0).Sub(maxInt64, bigOne), 1, 0, (math.MaxInt64-1)/10 + 1},
-		// large intermediate result.
-		{big.NewInt(1).Exp(big.NewInt(10), big.NewInt(100), nil), 100, 0, 1},
-
-		// scale up
-		{big.NewInt(0), 0, 3, 0},
-		{big.NewInt(1), 0, 3, 1000},
-		{big.NewInt(1), -3, 0, 1000},
-		{big.NewInt(1000), -3, 2, 100000000},
-		{big.NewInt(0).Div(big.NewInt(math.MaxInt64), bigThousand), 0, 3,
-			(math.MaxInt64 / 1000) * 1000},
-	}
-
-	for i, tt := range tests {
-		old := (&big.Int{}).Set(tt.unscaled)
-		got := scaledValue(tt.unscaled, tt.scale, tt.newScale)
-		if got != tt.want {
-			t.Errorf("#%d: got = %v, want %v", i, got, tt.want)
-		}
-		if tt.unscaled.Cmp(old) != 0 {
-			t.Errorf("#%d: unscaled = %v, want %v", i, tt.unscaled, old)
-		}
-	}
-}
-
-func BenchmarkScaledValueSmall(b *testing.B) {
-	s := big.NewInt(1000)
-	for i := 0; i < b.N; i++ {
-		scaledValue(s, 3, 0)
-	}
-}
-
-func BenchmarkScaledValueLarge(b *testing.B) {
-	s := big.NewInt(math.MaxInt64)
-	s.Mul(s, big.NewInt(1000))
-	for i := 0; i < b.N; i++ {
-		scaledValue(s, 10, 0)
-	}
-}