Switch to github.com/golang/dep for vendoring
Signed-off-by: Mrunal Patel <mrunalp@gmail.com>
This commit is contained in:
Mrunal Patel
parent
d6ab91be27
commit
8e5b17cf13
15431 changed files with 3971413 additions and 8881 deletions
2
vendor/github.com/docker/go-units/duration.go
generated
vendored
2
vendor/github.com/docker/go-units/duration.go
generated
vendored
|
|
@ -12,8 +12,6 @@ import (
|
|||
func HumanDuration(d time.Duration) string {
|
||||
if seconds := int(d.Seconds()); seconds < 1 {
|
||||
return "Less than a second"
|
||||
} else if seconds == 1 {
|
||||
return "1 second"
|
||||
} else if seconds < 60 {
|
||||
return fmt.Sprintf("%d seconds", seconds)
|
||||
} else if minutes := int(d.Minutes()); minutes == 1 {
|
||||
|
|
|
|||
81
vendor/github.com/docker/go-units/duration_test.go
generated
vendored
Normal file
81
vendor/github.com/docker/go-units/duration_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
package units
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func ExampleHumanDuration() {
|
||||
fmt.Println(HumanDuration(450 * time.Millisecond))
|
||||
fmt.Println(HumanDuration(47 * time.Second))
|
||||
fmt.Println(HumanDuration(1 * time.Minute))
|
||||
fmt.Println(HumanDuration(3 * time.Minute))
|
||||
fmt.Println(HumanDuration(35 * time.Minute))
|
||||
fmt.Println(HumanDuration(35*time.Minute + 40*time.Second))
|
||||
fmt.Println(HumanDuration(1 * time.Hour))
|
||||
fmt.Println(HumanDuration(1*time.Hour + 45*time.Minute))
|
||||
fmt.Println(HumanDuration(3 * time.Hour))
|
||||
fmt.Println(HumanDuration(3*time.Hour + 59*time.Minute))
|
||||
fmt.Println(HumanDuration(3*time.Hour + 60*time.Minute))
|
||||
fmt.Println(HumanDuration(24 * time.Hour))
|
||||
fmt.Println(HumanDuration(24*time.Hour + 12*time.Hour))
|
||||
fmt.Println(HumanDuration(2 * 24 * time.Hour))
|
||||
fmt.Println(HumanDuration(7 * 24 * time.Hour))
|
||||
fmt.Println(HumanDuration(13*24*time.Hour + 5*time.Hour))
|
||||
fmt.Println(HumanDuration(2 * 7 * 24 * time.Hour))
|
||||
fmt.Println(HumanDuration(2*7*24*time.Hour + 4*24*time.Hour))
|
||||
fmt.Println(HumanDuration(3 * 7 * 24 * time.Hour))
|
||||
fmt.Println(HumanDuration(4 * 7 * 24 * time.Hour))
|
||||
fmt.Println(HumanDuration(4*7*24*time.Hour + 3*24*time.Hour))
|
||||
fmt.Println(HumanDuration(1 * 30 * 24 * time.Hour))
|
||||
fmt.Println(HumanDuration(1*30*24*time.Hour + 2*7*24*time.Hour))
|
||||
fmt.Println(HumanDuration(2 * 30 * 24 * time.Hour))
|
||||
fmt.Println(HumanDuration(3*30*24*time.Hour + 1*7*24*time.Hour))
|
||||
fmt.Println(HumanDuration(5*30*24*time.Hour + 2*7*24*time.Hour))
|
||||
fmt.Println(HumanDuration(13 * 30 * 24 * time.Hour))
|
||||
fmt.Println(HumanDuration(23 * 30 * 24 * time.Hour))
|
||||
fmt.Println(HumanDuration(24 * 30 * 24 * time.Hour))
|
||||
fmt.Println(HumanDuration(24*30*24*time.Hour + 2*7*24*time.Hour))
|
||||
fmt.Println(HumanDuration(3*365*24*time.Hour + 2*30*24*time.Hour))
|
||||
}
|
||||
|
||||
func TestHumanDuration(t *testing.T) {
|
||||
// Useful duration abstractions
|
||||
day := 24 * time.Hour
|
||||
week := 7 * day
|
||||
month := 30 * day
|
||||
year := 365 * day
|
||||
|
||||
assertEquals(t, "Less than a second", HumanDuration(450*time.Millisecond))
|
||||
assertEquals(t, "47 seconds", HumanDuration(47*time.Second))
|
||||
assertEquals(t, "About a minute", HumanDuration(1*time.Minute))
|
||||
assertEquals(t, "3 minutes", HumanDuration(3*time.Minute))
|
||||
assertEquals(t, "35 minutes", HumanDuration(35*time.Minute))
|
||||
assertEquals(t, "35 minutes", HumanDuration(35*time.Minute+40*time.Second))
|
||||
assertEquals(t, "About an hour", HumanDuration(1*time.Hour))
|
||||
assertEquals(t, "About an hour", HumanDuration(1*time.Hour+45*time.Minute))
|
||||
assertEquals(t, "3 hours", HumanDuration(3*time.Hour))
|
||||
assertEquals(t, "3 hours", HumanDuration(3*time.Hour+59*time.Minute))
|
||||
assertEquals(t, "4 hours", HumanDuration(3*time.Hour+60*time.Minute))
|
||||
assertEquals(t, "24 hours", HumanDuration(24*time.Hour))
|
||||
assertEquals(t, "36 hours", HumanDuration(1*day+12*time.Hour))
|
||||
assertEquals(t, "2 days", HumanDuration(2*day))
|
||||
assertEquals(t, "7 days", HumanDuration(7*day))
|
||||
assertEquals(t, "13 days", HumanDuration(13*day+5*time.Hour))
|
||||
assertEquals(t, "2 weeks", HumanDuration(2*week))
|
||||
assertEquals(t, "2 weeks", HumanDuration(2*week+4*day))
|
||||
assertEquals(t, "3 weeks", HumanDuration(3*week))
|
||||
assertEquals(t, "4 weeks", HumanDuration(4*week))
|
||||
assertEquals(t, "4 weeks", HumanDuration(4*week+3*day))
|
||||
assertEquals(t, "4 weeks", HumanDuration(1*month))
|
||||
assertEquals(t, "6 weeks", HumanDuration(1*month+2*week))
|
||||
assertEquals(t, "8 weeks", HumanDuration(2*month))
|
||||
assertEquals(t, "3 months", HumanDuration(3*month+1*week))
|
||||
assertEquals(t, "5 months", HumanDuration(5*month+2*week))
|
||||
assertEquals(t, "13 months", HumanDuration(13*month))
|
||||
assertEquals(t, "23 months", HumanDuration(23*month))
|
||||
assertEquals(t, "24 months", HumanDuration(24*month))
|
||||
assertEquals(t, "2 years", HumanDuration(24*month+2*week))
|
||||
assertEquals(t, "3 years", HumanDuration(3*year+2*month))
|
||||
}
|
||||
22
vendor/github.com/docker/go-units/size.go
generated
vendored
22
vendor/github.com/docker/go-units/size.go
generated
vendored
|
|
@ -37,34 +37,22 @@ var (
|
|||
var decimapAbbrs = []string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"}
|
||||
var binaryAbbrs = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"}
|
||||
|
||||
func getSizeAndUnit(size float64, base float64, _map []string) (float64, string) {
|
||||
// CustomSize returns a human-readable approximation of a size
|
||||
// using custom format.
|
||||
func CustomSize(format string, size float64, base float64, _map []string) string {
|
||||
i := 0
|
||||
unitsLimit := len(_map) - 1
|
||||
for size >= base && i < unitsLimit {
|
||||
size = size / base
|
||||
i++
|
||||
}
|
||||
return size, _map[i]
|
||||
}
|
||||
|
||||
// CustomSize returns a human-readable approximation of a size
|
||||
// using custom format.
|
||||
func CustomSize(format string, size float64, base float64, _map []string) string {
|
||||
size, unit := getSizeAndUnit(size, base, _map)
|
||||
return fmt.Sprintf(format, size, unit)
|
||||
}
|
||||
|
||||
// HumanSizeWithPrecision allows the size to be in any precision,
|
||||
// instead of 4 digit precision used in units.HumanSize.
|
||||
func HumanSizeWithPrecision(size float64, precision int) string {
|
||||
size, unit := getSizeAndUnit(size, 1000.0, decimapAbbrs)
|
||||
return fmt.Sprintf("%.*g %s", precision, size, unit)
|
||||
return fmt.Sprintf(format, size, _map[i])
|
||||
}
|
||||
|
||||
// HumanSize returns a human-readable approximation of a size
|
||||
// capped at 4 valid numbers (eg. "2.746 MB", "796 KB").
|
||||
func HumanSize(size float64) string {
|
||||
return HumanSizeWithPrecision(size, 4)
|
||||
return CustomSize("%.4g %s", size, 1000.0, decimapAbbrs)
|
||||
}
|
||||
|
||||
// BytesSize returns a human-readable size in bytes, kibibytes,
|
||||
|
|
|
|||
165
vendor/github.com/docker/go-units/size_test.go
generated
vendored
Normal file
165
vendor/github.com/docker/go-units/size_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,165 @@
|
|||
package units
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func ExampleBytesSize() {
|
||||
fmt.Println(BytesSize(1024))
|
||||
fmt.Println(BytesSize(1024 * 1024))
|
||||
fmt.Println(BytesSize(1048576))
|
||||
fmt.Println(BytesSize(2 * MiB))
|
||||
fmt.Println(BytesSize(3.42 * GiB))
|
||||
fmt.Println(BytesSize(5.372 * TiB))
|
||||
fmt.Println(BytesSize(2.22 * PiB))
|
||||
}
|
||||
|
||||
func ExampleHumanSize() {
|
||||
fmt.Println(HumanSize(1000))
|
||||
fmt.Println(HumanSize(1024))
|
||||
fmt.Println(HumanSize(1000000))
|
||||
fmt.Println(HumanSize(1048576))
|
||||
fmt.Println(HumanSize(2 * MB))
|
||||
fmt.Println(HumanSize(float64(3.42 * GB)))
|
||||
fmt.Println(HumanSize(float64(5.372 * TB)))
|
||||
fmt.Println(HumanSize(float64(2.22 * PB)))
|
||||
}
|
||||
|
||||
func ExampleFromHumanSize() {
|
||||
fmt.Println(FromHumanSize("32"))
|
||||
fmt.Println(FromHumanSize("32b"))
|
||||
fmt.Println(FromHumanSize("32B"))
|
||||
fmt.Println(FromHumanSize("32k"))
|
||||
fmt.Println(FromHumanSize("32K"))
|
||||
fmt.Println(FromHumanSize("32kb"))
|
||||
fmt.Println(FromHumanSize("32Kb"))
|
||||
fmt.Println(FromHumanSize("32Mb"))
|
||||
fmt.Println(FromHumanSize("32Gb"))
|
||||
fmt.Println(FromHumanSize("32Tb"))
|
||||
fmt.Println(FromHumanSize("32Pb"))
|
||||
}
|
||||
|
||||
func ExampleRAMInBytes() {
|
||||
fmt.Println(RAMInBytes("32"))
|
||||
fmt.Println(RAMInBytes("32b"))
|
||||
fmt.Println(RAMInBytes("32B"))
|
||||
fmt.Println(RAMInBytes("32k"))
|
||||
fmt.Println(RAMInBytes("32K"))
|
||||
fmt.Println(RAMInBytes("32kb"))
|
||||
fmt.Println(RAMInBytes("32Kb"))
|
||||
fmt.Println(RAMInBytes("32Mb"))
|
||||
fmt.Println(RAMInBytes("32Gb"))
|
||||
fmt.Println(RAMInBytes("32Tb"))
|
||||
fmt.Println(RAMInBytes("32Pb"))
|
||||
fmt.Println(RAMInBytes("32PB"))
|
||||
fmt.Println(RAMInBytes("32P"))
|
||||
}
|
||||
|
||||
func TestBytesSize(t *testing.T) {
|
||||
assertEquals(t, "1 KiB", BytesSize(1024))
|
||||
assertEquals(t, "1 MiB", BytesSize(1024*1024))
|
||||
assertEquals(t, "1 MiB", BytesSize(1048576))
|
||||
assertEquals(t, "2 MiB", BytesSize(2*MiB))
|
||||
assertEquals(t, "3.42 GiB", BytesSize(3.42*GiB))
|
||||
assertEquals(t, "5.372 TiB", BytesSize(5.372*TiB))
|
||||
assertEquals(t, "2.22 PiB", BytesSize(2.22*PiB))
|
||||
assertEquals(t, "1.049e+06 YiB", BytesSize(KiB*KiB*KiB*KiB*KiB*PiB))
|
||||
}
|
||||
|
||||
func TestHumanSize(t *testing.T) {
|
||||
assertEquals(t, "1 kB", HumanSize(1000))
|
||||
assertEquals(t, "1.024 kB", HumanSize(1024))
|
||||
assertEquals(t, "1 MB", HumanSize(1000000))
|
||||
assertEquals(t, "1.049 MB", HumanSize(1048576))
|
||||
assertEquals(t, "2 MB", HumanSize(2*MB))
|
||||
assertEquals(t, "3.42 GB", HumanSize(float64(3.42*GB)))
|
||||
assertEquals(t, "5.372 TB", HumanSize(float64(5.372*TB)))
|
||||
assertEquals(t, "2.22 PB", HumanSize(float64(2.22*PB)))
|
||||
assertEquals(t, "1e+04 YB", HumanSize(float64(10000000000000*PB)))
|
||||
}
|
||||
|
||||
func TestFromHumanSize(t *testing.T) {
|
||||
assertSuccessEquals(t, 32, FromHumanSize, "32")
|
||||
assertSuccessEquals(t, 32, FromHumanSize, "32b")
|
||||
assertSuccessEquals(t, 32, FromHumanSize, "32B")
|
||||
assertSuccessEquals(t, 32*KB, FromHumanSize, "32k")
|
||||
assertSuccessEquals(t, 32*KB, FromHumanSize, "32K")
|
||||
assertSuccessEquals(t, 32*KB, FromHumanSize, "32kb")
|
||||
assertSuccessEquals(t, 32*KB, FromHumanSize, "32Kb")
|
||||
assertSuccessEquals(t, 32*MB, FromHumanSize, "32Mb")
|
||||
assertSuccessEquals(t, 32*GB, FromHumanSize, "32Gb")
|
||||
assertSuccessEquals(t, 32*TB, FromHumanSize, "32Tb")
|
||||
assertSuccessEquals(t, 32*PB, FromHumanSize, "32Pb")
|
||||
|
||||
assertSuccessEquals(t, 32.5*KB, FromHumanSize, "32.5kB")
|
||||
assertSuccessEquals(t, 32.5*KB, FromHumanSize, "32.5 kB")
|
||||
assertSuccessEquals(t, 32, FromHumanSize, "32.5 B")
|
||||
|
||||
assertError(t, FromHumanSize, "")
|
||||
assertError(t, FromHumanSize, "hello")
|
||||
assertError(t, FromHumanSize, "-32")
|
||||
assertError(t, FromHumanSize, ".3kB")
|
||||
assertError(t, FromHumanSize, " 32 ")
|
||||
assertError(t, FromHumanSize, "32m b")
|
||||
assertError(t, FromHumanSize, "32bm")
|
||||
}
|
||||
|
||||
func TestRAMInBytes(t *testing.T) {
|
||||
assertSuccessEquals(t, 32, RAMInBytes, "32")
|
||||
assertSuccessEquals(t, 32, RAMInBytes, "32b")
|
||||
assertSuccessEquals(t, 32, RAMInBytes, "32B")
|
||||
assertSuccessEquals(t, 32*KiB, RAMInBytes, "32k")
|
||||
assertSuccessEquals(t, 32*KiB, RAMInBytes, "32K")
|
||||
assertSuccessEquals(t, 32*KiB, RAMInBytes, "32kb")
|
||||
assertSuccessEquals(t, 32*KiB, RAMInBytes, "32Kb")
|
||||
assertSuccessEquals(t, 32*MiB, RAMInBytes, "32Mb")
|
||||
assertSuccessEquals(t, 32*GiB, RAMInBytes, "32Gb")
|
||||
assertSuccessEquals(t, 32*TiB, RAMInBytes, "32Tb")
|
||||
assertSuccessEquals(t, 32*PiB, RAMInBytes, "32Pb")
|
||||
assertSuccessEquals(t, 32*PiB, RAMInBytes, "32PB")
|
||||
assertSuccessEquals(t, 32*PiB, RAMInBytes, "32P")
|
||||
|
||||
assertSuccessEquals(t, 32, RAMInBytes, "32.3")
|
||||
tmp := 32.3 * MiB
|
||||
assertSuccessEquals(t, int64(tmp), RAMInBytes, "32.3 mb")
|
||||
|
||||
assertError(t, RAMInBytes, "")
|
||||
assertError(t, RAMInBytes, "hello")
|
||||
assertError(t, RAMInBytes, "-32")
|
||||
assertError(t, RAMInBytes, " 32 ")
|
||||
assertError(t, RAMInBytes, "32m b")
|
||||
assertError(t, RAMInBytes, "32bm")
|
||||
}
|
||||
|
||||
func assertEquals(t *testing.T, expected, actual interface{}) {
|
||||
if expected != actual {
|
||||
t.Errorf("Expected '%v' but got '%v'", expected, actual)
|
||||
}
|
||||
}
|
||||
|
||||
// func that maps to the parse function signatures as testing abstraction
|
||||
type parseFn func(string) (int64, error)
|
||||
|
||||
// Define 'String()' for pretty-print
|
||||
func (fn parseFn) String() string {
|
||||
fnName := runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name()
|
||||
return fnName[strings.LastIndex(fnName, ".")+1:]
|
||||
}
|
||||
|
||||
func assertSuccessEquals(t *testing.T, expected int64, fn parseFn, arg string) {
|
||||
res, err := fn(arg)
|
||||
if err != nil || res != expected {
|
||||
t.Errorf("%s(\"%s\") -> expected '%d' but got '%d' with error '%v'", fn, arg, expected, res, err)
|
||||
}
|
||||
}
|
||||
|
||||
func assertError(t *testing.T, fn parseFn, arg string) {
|
||||
res, err := fn(arg)
|
||||
if err == nil && res != -1 {
|
||||
t.Errorf("%s(\"%s\") -> expected error but got '%d'", fn, arg, res)
|
||||
}
|
||||
}
|
||||
74
vendor/github.com/docker/go-units/ulimit_test.go
generated
vendored
Normal file
74
vendor/github.com/docker/go-units/ulimit_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
package units
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func ExampleParseUlimit() {
|
||||
fmt.Println(ParseUlimit("nofile=512:1024"))
|
||||
fmt.Println(ParseUlimit("nofile=1024"))
|
||||
fmt.Println(ParseUlimit("cpu=2:4"))
|
||||
fmt.Println(ParseUlimit("cpu=6"))
|
||||
}
|
||||
|
||||
func TestParseUlimitValid(t *testing.T) {
|
||||
u1 := &Ulimit{"nofile", 1024, 512}
|
||||
if u2, _ := ParseUlimit("nofile=512:1024"); *u1 != *u2 {
|
||||
t.Fatalf("expected %q, but got %q", u1, u2)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseUlimitInvalidLimitType(t *testing.T) {
|
||||
if _, err := ParseUlimit("notarealtype=1024:1024"); err == nil {
|
||||
t.Fatalf("expected error on invalid ulimit type")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseUlimitBadFormat(t *testing.T) {
|
||||
if _, err := ParseUlimit("nofile:1024:1024"); err == nil {
|
||||
t.Fatal("expected error on bad syntax")
|
||||
}
|
||||
|
||||
if _, err := ParseUlimit("nofile"); err == nil {
|
||||
t.Fatal("expected error on bad syntax")
|
||||
}
|
||||
|
||||
if _, err := ParseUlimit("nofile="); err == nil {
|
||||
t.Fatal("expected error on bad syntax")
|
||||
}
|
||||
if _, err := ParseUlimit("nofile=:"); err == nil {
|
||||
t.Fatal("expected error on bad syntax")
|
||||
}
|
||||
if _, err := ParseUlimit("nofile=:1024"); err == nil {
|
||||
t.Fatal("expected error on bad syntax")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseUlimitHardLessThanSoft(t *testing.T) {
|
||||
if _, err := ParseUlimit("nofile=1024:1"); err == nil {
|
||||
t.Fatal("expected error on hard limit less than soft limit")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseUlimitInvalidValueType(t *testing.T) {
|
||||
if _, err := ParseUlimit("nofile=asdf"); err == nil {
|
||||
t.Fatal("expected error on bad value type, but got no error")
|
||||
} else if _, ok := err.(*strconv.NumError); !ok {
|
||||
t.Fatalf("expected error on bad value type, but got `%s`", err)
|
||||
}
|
||||
|
||||
if _, err := ParseUlimit("nofile=1024:asdf"); err == nil {
|
||||
t.Fatal("expected error on bad value type, but got no error")
|
||||
} else if _, ok := err.(*strconv.NumError); !ok {
|
||||
t.Fatalf("expected error on bad value type, but got `%s`", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUlimitStringOutput(t *testing.T) {
|
||||
u := &Ulimit{"nofile", 1024, 512}
|
||||
if s := u.String(); s != "nofile=512:1024" {
|
||||
t.Fatal("expected String to return nofile=512:1024, but got", s)
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue