use dep as denpendency managment tool
This commit is contained in:
jeff
95
vendor/github.com/docker/go-units/duration_test.go
generated
vendored
95
vendor/github.com/docker/go-units/duration_test.go
generated
vendored
@@ -1,95 +0,0 @@
|
||||
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, "1 second", HumanDuration(1*time.Second))
|
||||
assertEquals(t, "45 seconds", HumanDuration(45*time.Second))
|
||||
assertEquals(t, "46 seconds", HumanDuration(46*time.Second))
|
||||
assertEquals(t, "59 seconds", HumanDuration(59*time.Second))
|
||||
assertEquals(t, "About a minute", HumanDuration(60*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, "45 minutes", HumanDuration(45*time.Minute))
|
||||
assertEquals(t, "45 minutes", HumanDuration(45*time.Minute+40*time.Second))
|
||||
assertEquals(t, "About an hour", HumanDuration(46*time.Minute))
|
||||
assertEquals(t, "About an hour", HumanDuration(59*time.Minute))
|
||||
assertEquals(t, "About an hour", HumanDuration(1*time.Hour))
|
||||
assertEquals(t, "About an hour", HumanDuration(1*time.Hour+29*time.Minute))
|
||||
assertEquals(t, "2 hours", HumanDuration(1*time.Hour+31*time.Minute))
|
||||
assertEquals(t, "2 hours", HumanDuration(1*time.Hour+59*time.Minute))
|
||||
assertEquals(t, "3 hours", HumanDuration(3*time.Hour))
|
||||
assertEquals(t, "3 hours", HumanDuration(3*time.Hour+29*time.Minute))
|
||||
assertEquals(t, "4 hours", HumanDuration(3*time.Hour+31*time.Minute))
|
||||
assertEquals(t, "4 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, "2 months", HumanDuration(2*month))
|
||||
assertEquals(t, "2 months", HumanDuration(2*month+2*week))
|
||||
assertEquals(t, "3 months", HumanDuration(3*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))
|
||||
}
|
||||
167
vendor/github.com/docker/go-units/size_test.go
generated
vendored
167
vendor/github.com/docker/go-units/size_test.go
generated
vendored
@@ -1,167 +0,0 @@
|
||||
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, "1KiB", BytesSize(1024))
|
||||
assertEquals(t, "1MiB", BytesSize(1024*1024))
|
||||
assertEquals(t, "1MiB", BytesSize(1048576))
|
||||
assertEquals(t, "2MiB", BytesSize(2*MiB))
|
||||
assertEquals(t, "3.42GiB", BytesSize(3.42*GiB))
|
||||
assertEquals(t, "5.372TiB", BytesSize(5.372*TiB))
|
||||
assertEquals(t, "2.22PiB", BytesSize(2.22*PiB))
|
||||
assertEquals(t, "1.049e+06YiB", BytesSize(KiB*KiB*KiB*KiB*KiB*PiB))
|
||||
}
|
||||
|
||||
func TestHumanSize(t *testing.T) {
|
||||
assertEquals(t, "1kB", HumanSize(1000))
|
||||
assertEquals(t, "1.024kB", HumanSize(1024))
|
||||
assertEquals(t, "1MB", HumanSize(1000000))
|
||||
assertEquals(t, "1.049MB", HumanSize(1048576))
|
||||
assertEquals(t, "2MB", HumanSize(2*MB))
|
||||
assertEquals(t, "3.42GB", HumanSize(float64(3.42*GB)))
|
||||
assertEquals(t, "5.372TB", HumanSize(float64(5.372*TB)))
|
||||
assertEquals(t, "2.22PB", HumanSize(float64(2.22*PB)))
|
||||
assertEquals(t, "1e+04YB", 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*KiB, RAMInBytes, "32Kib")
|
||||
assertSuccessEquals(t, 32*KiB, RAMInBytes, "32KIB")
|
||||
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)
|
||||
}
|
||||
}
|
||||
131
vendor/github.com/docker/go-units/ulimit_test.go
generated
vendored
131
vendor/github.com/docker/go-units/ulimit_test.go
generated
vendored
@@ -1,131 +0,0 @@
|
||||
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 TestParseUlimitTooManyValueArgs(t *testing.T) {
|
||||
if _, err := ParseUlimit("nofile=1024:1:50"); err == nil {
|
||||
t.Fatalf("expected error on more than two value arguments")
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRlimit(t *testing.T) {
|
||||
tt := []struct {
|
||||
ulimit Ulimit
|
||||
rlimit Rlimit
|
||||
}{
|
||||
{Ulimit{"core", 10, 12}, Rlimit{rlimitCore, 10, 12}},
|
||||
{Ulimit{"cpu", 1, 10}, Rlimit{rlimitCPU, 1, 10}},
|
||||
{Ulimit{"data", 5, 0}, Rlimit{rlimitData, 5, 0}},
|
||||
{Ulimit{"fsize", 2, 2}, Rlimit{rlimitFsize, 2, 2}},
|
||||
{Ulimit{"locks", 0, 0}, Rlimit{rlimitLocks, 0, 0}},
|
||||
{Ulimit{"memlock", 10, 10}, Rlimit{rlimitMemlock, 10, 10}},
|
||||
{Ulimit{"msgqueue", 9, 1}, Rlimit{rlimitMsgqueue, 9, 1}},
|
||||
{Ulimit{"nice", 9, 9}, Rlimit{rlimitNice, 9, 9}},
|
||||
{Ulimit{"nofile", 4, 100}, Rlimit{rlimitNofile, 4, 100}},
|
||||
{Ulimit{"nproc", 5, 5}, Rlimit{rlimitNproc, 5, 5}},
|
||||
{Ulimit{"rss", 0, 5}, Rlimit{rlimitRss, 0, 5}},
|
||||
{Ulimit{"rtprio", 100, 65}, Rlimit{rlimitRtprio, 100, 65}},
|
||||
{Ulimit{"rttime", 55, 102}, Rlimit{rlimitRttime, 55, 102}},
|
||||
{Ulimit{"sigpending", 14, 20}, Rlimit{rlimitSigpending, 14, 20}},
|
||||
{Ulimit{"stack", 1, 1}, Rlimit{rlimitStack, 1, 1}},
|
||||
}
|
||||
|
||||
for _, te := range tt {
|
||||
res, err := te.ulimit.GetRlimit()
|
||||
if err != nil {
|
||||
t.Errorf("expected not to fail: %s", err)
|
||||
}
|
||||
if res.Type != te.rlimit.Type {
|
||||
t.Errorf("expected Type to be %d but got %d",
|
||||
te.rlimit.Type, res.Type)
|
||||
}
|
||||
if res.Soft != te.rlimit.Soft {
|
||||
t.Errorf("expected Soft to be %d but got %d",
|
||||
te.rlimit.Soft, res.Soft)
|
||||
}
|
||||
if res.Hard != te.rlimit.Hard {
|
||||
t.Errorf("expected Hard to be %d but got %d",
|
||||
te.rlimit.Hard, res.Hard)
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRlimitBadUlimitName(t *testing.T) {
|
||||
name := "bla"
|
||||
uLimit := Ulimit{name, 0, 0}
|
||||
if _, err := uLimit.GetRlimit(); err == nil {
|
||||
t.Error("expected error on bad Ulimit name")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user