vendor: remove dep and use vndr
Signed-off-by: Antonio Murdaca <runcom@redhat.com>
This commit is contained in:
Antonio Murdaca
parent
16f44674a4
commit
148e72d81e
16131 changed files with 73815 additions and 4235138 deletions
2
vendor/github.com/spf13/pflag/.gitignore
generated
vendored
2
vendor/github.com/spf13/pflag/.gitignore
generated
vendored
|
|
@ -1,2 +0,0 @@
|
|||
.idea/*
|
||||
|
||||
20
vendor/github.com/spf13/pflag/.travis.yml
generated
vendored
20
vendor/github.com/spf13/pflag/.travis.yml
generated
vendored
|
|
@ -1,20 +0,0 @@
|
|||
sudo: false
|
||||
|
||||
language: go
|
||||
|
||||
go:
|
||||
- 1.6.3
|
||||
- 1.7.3
|
||||
- tip
|
||||
|
||||
matrix:
|
||||
allow_failures:
|
||||
- go: tip
|
||||
install:
|
||||
- go get github.com/golang/lint/golint
|
||||
- export PATH=$GOPATH/bin:$PATH
|
||||
- go install ./...
|
||||
|
||||
script:
|
||||
- verify/all.sh -v
|
||||
- go test ./...
|
||||
215
vendor/github.com/spf13/pflag/bool_slice_test.go
generated
vendored
215
vendor/github.com/spf13/pflag/bool_slice_test.go
generated
vendored
|
|
@ -1,215 +0,0 @@
|
|||
package pflag
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func setUpBSFlagSet(bsp *[]bool) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.BoolSliceVar(bsp, "bs", []bool{}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func setUpBSFlagSetWithDefault(bsp *[]bool) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.BoolSliceVar(bsp, "bs", []bool{false, true}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func TestEmptyBS(t *testing.T) {
|
||||
var bs []bool
|
||||
f := setUpBSFlagSet(&bs)
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
getBS, err := f.GetBoolSlice("bs")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetBoolSlice():", err)
|
||||
}
|
||||
if len(getBS) != 0 {
|
||||
t.Fatalf("got bs %v with len=%d but expected length=0", getBS, len(getBS))
|
||||
}
|
||||
}
|
||||
|
||||
func TestBS(t *testing.T) {
|
||||
var bs []bool
|
||||
f := setUpBSFlagSet(&bs)
|
||||
|
||||
vals := []string{"1", "F", "TRUE", "0"}
|
||||
arg := fmt.Sprintf("--bs=%s", strings.Join(vals, ","))
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range bs {
|
||||
b, err := strconv.ParseBool(vals[i])
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if b != v {
|
||||
t.Fatalf("expected is[%d] to be %s but got: %t", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
getBS, err := f.GetBoolSlice("bs")
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
for i, v := range getBS {
|
||||
b, err := strconv.ParseBool(vals[i])
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if b != v {
|
||||
t.Fatalf("expected bs[%d] to be %s but got: %t from GetBoolSlice", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBSDefault(t *testing.T) {
|
||||
var bs []bool
|
||||
f := setUpBSFlagSetWithDefault(&bs)
|
||||
|
||||
vals := []string{"false", "T"}
|
||||
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range bs {
|
||||
b, err := strconv.ParseBool(vals[i])
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if b != v {
|
||||
t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
|
||||
}
|
||||
}
|
||||
|
||||
getBS, err := f.GetBoolSlice("bs")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetBoolSlice():", err)
|
||||
}
|
||||
for i, v := range getBS {
|
||||
b, err := strconv.ParseBool(vals[i])
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetBoolSlice():", err)
|
||||
}
|
||||
if b != v {
|
||||
t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBSWithDefault(t *testing.T) {
|
||||
var bs []bool
|
||||
f := setUpBSFlagSetWithDefault(&bs)
|
||||
|
||||
vals := []string{"FALSE", "1"}
|
||||
arg := fmt.Sprintf("--bs=%s", strings.Join(vals, ","))
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range bs {
|
||||
b, err := strconv.ParseBool(vals[i])
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if b != v {
|
||||
t.Fatalf("expected bs[%d] to be %t but got: %t", i, b, v)
|
||||
}
|
||||
}
|
||||
|
||||
getBS, err := f.GetBoolSlice("bs")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetBoolSlice():", err)
|
||||
}
|
||||
for i, v := range getBS {
|
||||
b, err := strconv.ParseBool(vals[i])
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if b != v {
|
||||
t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBSCalledTwice(t *testing.T) {
|
||||
var bs []bool
|
||||
f := setUpBSFlagSet(&bs)
|
||||
|
||||
in := []string{"T,F", "T"}
|
||||
expected := []bool{true, false, true}
|
||||
argfmt := "--bs=%s"
|
||||
arg1 := fmt.Sprintf(argfmt, in[0])
|
||||
arg2 := fmt.Sprintf(argfmt, in[1])
|
||||
err := f.Parse([]string{arg1, arg2})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range bs {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected bs[%d] to be %t but got %t", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBSBadQuoting(t *testing.T) {
|
||||
|
||||
tests := []struct {
|
||||
Want []bool
|
||||
FlagArg []string
|
||||
}{
|
||||
{
|
||||
Want: []bool{true, false, true},
|
||||
FlagArg: []string{"1", "0", "true"},
|
||||
},
|
||||
{
|
||||
Want: []bool{true, false},
|
||||
FlagArg: []string{"True", "F"},
|
||||
},
|
||||
{
|
||||
Want: []bool{true, false},
|
||||
FlagArg: []string{"T", "0"},
|
||||
},
|
||||
{
|
||||
Want: []bool{true, false},
|
||||
FlagArg: []string{"1", "0"},
|
||||
},
|
||||
{
|
||||
Want: []bool{true, false, false},
|
||||
FlagArg: []string{"true,false", "false"},
|
||||
},
|
||||
{
|
||||
Want: []bool{true, false, false, true, false, true, false},
|
||||
FlagArg: []string{`"true,false,false,1,0, T"`, " false "},
|
||||
},
|
||||
{
|
||||
Want: []bool{false, false, true, false, true, false, true},
|
||||
FlagArg: []string{`"0, False, T,false , true,F"`, "true"},
|
||||
},
|
||||
}
|
||||
|
||||
for i, test := range tests {
|
||||
|
||||
var bs []bool
|
||||
f := setUpBSFlagSet(&bs)
|
||||
|
||||
if err := f.Parse([]string{fmt.Sprintf("--bs=%s", strings.Join(test.FlagArg, ","))}); err != nil {
|
||||
t.Fatalf("flag parsing failed with error: %s\nparsing:\t%#v\nwant:\t\t%#v",
|
||||
err, test.FlagArg, test.Want[i])
|
||||
}
|
||||
|
||||
for j, b := range bs {
|
||||
if b != test.Want[j] {
|
||||
t.Fatalf("bad value parsed for test %d on bool %d:\nwant:\t%t\ngot:\t%t", i, j, test.Want[j], b)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
179
vendor/github.com/spf13/pflag/bool_test.go
generated
vendored
179
vendor/github.com/spf13/pflag/bool_test.go
generated
vendored
|
|
@ -1,179 +0,0 @@
|
|||
// Copyright 2009 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 file.
|
||||
|
||||
package pflag
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"strconv"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// This value can be a boolean ("true", "false") or "maybe"
|
||||
type triStateValue int
|
||||
|
||||
const (
|
||||
triStateFalse triStateValue = 0
|
||||
triStateTrue triStateValue = 1
|
||||
triStateMaybe triStateValue = 2
|
||||
)
|
||||
|
||||
const strTriStateMaybe = "maybe"
|
||||
|
||||
func (v *triStateValue) IsBoolFlag() bool {
|
||||
return true
|
||||
}
|
||||
|
||||
func (v *triStateValue) Get() interface{} {
|
||||
return triStateValue(*v)
|
||||
}
|
||||
|
||||
func (v *triStateValue) Set(s string) error {
|
||||
if s == strTriStateMaybe {
|
||||
*v = triStateMaybe
|
||||
return nil
|
||||
}
|
||||
boolVal, err := strconv.ParseBool(s)
|
||||
if boolVal {
|
||||
*v = triStateTrue
|
||||
} else {
|
||||
*v = triStateFalse
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (v *triStateValue) String() string {
|
||||
if *v == triStateMaybe {
|
||||
return strTriStateMaybe
|
||||
}
|
||||
return strconv.FormatBool(*v == triStateTrue)
|
||||
}
|
||||
|
||||
// The type of the flag as required by the pflag.Value interface
|
||||
func (v *triStateValue) Type() string {
|
||||
return "version"
|
||||
}
|
||||
|
||||
func setUpFlagSet(tristate *triStateValue) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
*tristate = triStateFalse
|
||||
flag := f.VarPF(tristate, "tristate", "t", "tristate value (true, maybe or false)")
|
||||
flag.NoOptDefVal = "true"
|
||||
return f
|
||||
}
|
||||
|
||||
func TestExplicitTrue(t *testing.T) {
|
||||
var tristate triStateValue
|
||||
f := setUpFlagSet(&tristate)
|
||||
err := f.Parse([]string{"--tristate=true"})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
if tristate != triStateTrue {
|
||||
t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
|
||||
}
|
||||
}
|
||||
|
||||
func TestImplicitTrue(t *testing.T) {
|
||||
var tristate triStateValue
|
||||
f := setUpFlagSet(&tristate)
|
||||
err := f.Parse([]string{"--tristate"})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
if tristate != triStateTrue {
|
||||
t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
|
||||
}
|
||||
}
|
||||
|
||||
func TestShortFlag(t *testing.T) {
|
||||
var tristate triStateValue
|
||||
f := setUpFlagSet(&tristate)
|
||||
err := f.Parse([]string{"-t"})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
if tristate != triStateTrue {
|
||||
t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
|
||||
}
|
||||
}
|
||||
|
||||
func TestShortFlagExtraArgument(t *testing.T) {
|
||||
var tristate triStateValue
|
||||
f := setUpFlagSet(&tristate)
|
||||
// The"maybe"turns into an arg, since short boolean options will only do true/false
|
||||
err := f.Parse([]string{"-t", "maybe"})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
if tristate != triStateTrue {
|
||||
t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
|
||||
}
|
||||
args := f.Args()
|
||||
if len(args) != 1 || args[0] != "maybe" {
|
||||
t.Fatal("expected an extra 'maybe' argument to stick around")
|
||||
}
|
||||
}
|
||||
|
||||
func TestExplicitMaybe(t *testing.T) {
|
||||
var tristate triStateValue
|
||||
f := setUpFlagSet(&tristate)
|
||||
err := f.Parse([]string{"--tristate=maybe"})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
if tristate != triStateMaybe {
|
||||
t.Fatal("expected", triStateMaybe, "(triStateMaybe) but got", tristate, "instead")
|
||||
}
|
||||
}
|
||||
|
||||
func TestExplicitFalse(t *testing.T) {
|
||||
var tristate triStateValue
|
||||
f := setUpFlagSet(&tristate)
|
||||
err := f.Parse([]string{"--tristate=false"})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
if tristate != triStateFalse {
|
||||
t.Fatal("expected", triStateFalse, "(triStateFalse) but got", tristate, "instead")
|
||||
}
|
||||
}
|
||||
|
||||
func TestImplicitFalse(t *testing.T) {
|
||||
var tristate triStateValue
|
||||
f := setUpFlagSet(&tristate)
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
if tristate != triStateFalse {
|
||||
t.Fatal("expected", triStateFalse, "(triStateFalse) but got", tristate, "instead")
|
||||
}
|
||||
}
|
||||
|
||||
func TestInvalidValue(t *testing.T) {
|
||||
var tristate triStateValue
|
||||
f := setUpFlagSet(&tristate)
|
||||
var buf bytes.Buffer
|
||||
f.SetOutput(&buf)
|
||||
err := f.Parse([]string{"--tristate=invalid"})
|
||||
if err == nil {
|
||||
t.Fatal("expected an error but did not get any, tristate has value", tristate)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBoolP(t *testing.T) {
|
||||
b := BoolP("bool", "b", false, "bool value in CommandLine")
|
||||
c := BoolP("c", "c", false, "other bool value")
|
||||
args := []string{"--bool"}
|
||||
if err := CommandLine.Parse(args); err != nil {
|
||||
t.Error("expected no error, got ", err)
|
||||
}
|
||||
if *b != true {
|
||||
t.Errorf("expected b=true got b=%v", *b)
|
||||
}
|
||||
if *c != false {
|
||||
t.Errorf("expect c=false got c=%v", *c)
|
||||
}
|
||||
}
|
||||
52
vendor/github.com/spf13/pflag/count_test.go
generated
vendored
52
vendor/github.com/spf13/pflag/count_test.go
generated
vendored
|
|
@ -1,52 +0,0 @@
|
|||
package pflag
|
||||
|
||||
import (
|
||||
"os"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func setUpCount(c *int) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.CountVarP(c, "verbose", "v", "a counter")
|
||||
return f
|
||||
}
|
||||
|
||||
func TestCount(t *testing.T) {
|
||||
testCases := []struct {
|
||||
input []string
|
||||
success bool
|
||||
expected int
|
||||
}{
|
||||
{[]string{"-vvv"}, true, 3},
|
||||
{[]string{"-v", "-v", "-v"}, true, 3},
|
||||
{[]string{"-v", "--verbose", "-v"}, true, 3},
|
||||
{[]string{"-v=3", "-v"}, true, 4},
|
||||
{[]string{"-v=a"}, false, 0},
|
||||
}
|
||||
|
||||
devnull, _ := os.Open(os.DevNull)
|
||||
os.Stderr = devnull
|
||||
for i := range testCases {
|
||||
var count int
|
||||
f := setUpCount(&count)
|
||||
|
||||
tc := &testCases[i]
|
||||
|
||||
err := f.Parse(tc.input)
|
||||
if err != nil && tc.success == true {
|
||||
t.Errorf("expected success, got %q", err)
|
||||
continue
|
||||
} else if err == nil && tc.success == false {
|
||||
t.Errorf("expected failure, got success")
|
||||
continue
|
||||
} else if tc.success {
|
||||
c, err := f.GetCount("verbose")
|
||||
if err != nil {
|
||||
t.Errorf("Got error trying to fetch the counter flag")
|
||||
}
|
||||
if c != tc.expected {
|
||||
t.Errorf("expected %q, got %q", tc.expected, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
77
vendor/github.com/spf13/pflag/example_test.go
generated
vendored
77
vendor/github.com/spf13/pflag/example_test.go
generated
vendored
|
|
@ -1,77 +0,0 @@
|
|||
// Copyright 2012 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 file.
|
||||
|
||||
// These examples demonstrate more intricate uses of the flag package.
|
||||
package pflag_test
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
flag "github.com/spf13/pflag"
|
||||
)
|
||||
|
||||
// Example 1: A single string flag called "species" with default value "gopher".
|
||||
var species = flag.String("species", "gopher", "the species we are studying")
|
||||
|
||||
// Example 2: A flag with a shorthand letter.
|
||||
var gopherType = flag.StringP("gopher_type", "g", "pocket", "the variety of gopher")
|
||||
|
||||
// Example 3: A user-defined flag type, a slice of durations.
|
||||
type interval []time.Duration
|
||||
|
||||
// String is the method to format the flag's value, part of the flag.Value interface.
|
||||
// The String method's output will be used in diagnostics.
|
||||
func (i *interval) String() string {
|
||||
return fmt.Sprint(*i)
|
||||
}
|
||||
|
||||
func (i *interval) Type() string {
|
||||
return "interval"
|
||||
}
|
||||
|
||||
// Set is the method to set the flag value, part of the flag.Value interface.
|
||||
// Set's argument is a string to be parsed to set the flag.
|
||||
// It's a comma-separated list, so we split it.
|
||||
func (i *interval) Set(value string) error {
|
||||
// If we wanted to allow the flag to be set multiple times,
|
||||
// accumulating values, we would delete this if statement.
|
||||
// That would permit usages such as
|
||||
// -deltaT 10s -deltaT 15s
|
||||
// and other combinations.
|
||||
if len(*i) > 0 {
|
||||
return errors.New("interval flag already set")
|
||||
}
|
||||
for _, dt := range strings.Split(value, ",") {
|
||||
duration, err := time.ParseDuration(dt)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*i = append(*i, duration)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Define a flag to accumulate durations. Because it has a special type,
|
||||
// we need to use the Var function and therefore create the flag during
|
||||
// init.
|
||||
|
||||
var intervalFlag interval
|
||||
|
||||
func init() {
|
||||
// Tie the command-line flag to the intervalFlag variable and
|
||||
// set a usage message.
|
||||
flag.Var(&intervalFlag, "deltaT", "comma-separated list of intervals to use between events")
|
||||
}
|
||||
|
||||
func Example() {
|
||||
// All the interesting pieces are with the variables declared above, but
|
||||
// to enable the flag package to see the flags defined there, one must
|
||||
// execute, typically at the start of main (not init!):
|
||||
// flag.Parse()
|
||||
// We don't run it here because this is not a main function and
|
||||
// the testing suite has already parsed the flags.
|
||||
}
|
||||
29
vendor/github.com/spf13/pflag/export_test.go
generated
vendored
29
vendor/github.com/spf13/pflag/export_test.go
generated
vendored
|
|
@ -1,29 +0,0 @@
|
|||
// Copyright 2010 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 file.
|
||||
|
||||
package pflag
|
||||
|
||||
import (
|
||||
"io/ioutil"
|
||||
"os"
|
||||
)
|
||||
|
||||
// Additional routines compiled into the package only during testing.
|
||||
|
||||
// ResetForTesting clears all flag state and sets the usage function as directed.
|
||||
// After calling ResetForTesting, parse errors in flag handling will not
|
||||
// exit the program.
|
||||
func ResetForTesting(usage func()) {
|
||||
CommandLine = &FlagSet{
|
||||
name: os.Args[0],
|
||||
errorHandling: ContinueOnError,
|
||||
output: ioutil.Discard,
|
||||
}
|
||||
Usage = usage
|
||||
}
|
||||
|
||||
// GetCommandLine returns the default FlagSet.
|
||||
func GetCommandLine() *FlagSet {
|
||||
return CommandLine
|
||||
}
|
||||
1006
vendor/github.com/spf13/pflag/flag_test.go
generated
vendored
1006
vendor/github.com/spf13/pflag/flag_test.go
generated
vendored
File diff suppressed because it is too large
Load diff
39
vendor/github.com/spf13/pflag/golangflag_test.go
generated
vendored
39
vendor/github.com/spf13/pflag/golangflag_test.go
generated
vendored
|
|
@ -1,39 +0,0 @@
|
|||
// Copyright 2009 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 file.
|
||||
|
||||
package pflag
|
||||
|
||||
import (
|
||||
goflag "flag"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestGoflags(t *testing.T) {
|
||||
goflag.String("stringFlag", "stringFlag", "stringFlag")
|
||||
goflag.Bool("boolFlag", false, "boolFlag")
|
||||
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
|
||||
f.AddGoFlagSet(goflag.CommandLine)
|
||||
err := f.Parse([]string{"--stringFlag=bob", "--boolFlag"})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; get", err)
|
||||
}
|
||||
|
||||
getString, err := f.GetString("stringFlag")
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; get", err)
|
||||
}
|
||||
if getString != "bob" {
|
||||
t.Fatalf("expected getString=bob but got getString=%s", getString)
|
||||
}
|
||||
|
||||
getBool, err := f.GetBool("boolFlag")
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; get", err)
|
||||
}
|
||||
if getBool != true {
|
||||
t.Fatalf("expected getBool=true but got getBool=%v", getBool)
|
||||
}
|
||||
}
|
||||
165
vendor/github.com/spf13/pflag/int_slice_test.go
generated
vendored
165
vendor/github.com/spf13/pflag/int_slice_test.go
generated
vendored
|
|
@ -1,165 +0,0 @@
|
|||
// Copyright 2009 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 file.
|
||||
|
||||
package pflag
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func setUpISFlagSet(isp *[]int) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.IntSliceVar(isp, "is", []int{}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func setUpISFlagSetWithDefault(isp *[]int) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.IntSliceVar(isp, "is", []int{0, 1}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func TestEmptyIS(t *testing.T) {
|
||||
var is []int
|
||||
f := setUpISFlagSet(&is)
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
getIS, err := f.GetIntSlice("is")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetIntSlice():", err)
|
||||
}
|
||||
if len(getIS) != 0 {
|
||||
t.Fatalf("got is %v with len=%d but expected length=0", getIS, len(getIS))
|
||||
}
|
||||
}
|
||||
|
||||
func TestIS(t *testing.T) {
|
||||
var is []int
|
||||
f := setUpISFlagSet(&is)
|
||||
|
||||
vals := []string{"1", "2", "4", "3"}
|
||||
arg := fmt.Sprintf("--is=%s", strings.Join(vals, ","))
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range is {
|
||||
d, err := strconv.Atoi(vals[i])
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if d != v {
|
||||
t.Fatalf("expected is[%d] to be %s but got: %d", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
getIS, err := f.GetIntSlice("is")
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
for i, v := range getIS {
|
||||
d, err := strconv.Atoi(vals[i])
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if d != v {
|
||||
t.Fatalf("expected is[%d] to be %s but got: %d from GetIntSlice", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestISDefault(t *testing.T) {
|
||||
var is []int
|
||||
f := setUpISFlagSetWithDefault(&is)
|
||||
|
||||
vals := []string{"0", "1"}
|
||||
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range is {
|
||||
d, err := strconv.Atoi(vals[i])
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if d != v {
|
||||
t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
|
||||
}
|
||||
}
|
||||
|
||||
getIS, err := f.GetIntSlice("is")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetIntSlice():", err)
|
||||
}
|
||||
for i, v := range getIS {
|
||||
d, err := strconv.Atoi(vals[i])
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetIntSlice():", err)
|
||||
}
|
||||
if d != v {
|
||||
t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestISWithDefault(t *testing.T) {
|
||||
var is []int
|
||||
f := setUpISFlagSetWithDefault(&is)
|
||||
|
||||
vals := []string{"1", "2"}
|
||||
arg := fmt.Sprintf("--is=%s", strings.Join(vals, ","))
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range is {
|
||||
d, err := strconv.Atoi(vals[i])
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if d != v {
|
||||
t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
|
||||
}
|
||||
}
|
||||
|
||||
getIS, err := f.GetIntSlice("is")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetIntSlice():", err)
|
||||
}
|
||||
for i, v := range getIS {
|
||||
d, err := strconv.Atoi(vals[i])
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if d != v {
|
||||
t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestISCalledTwice(t *testing.T) {
|
||||
var is []int
|
||||
f := setUpISFlagSet(&is)
|
||||
|
||||
in := []string{"1,2", "3"}
|
||||
expected := []int{1, 2, 3}
|
||||
argfmt := "--is=%s"
|
||||
arg1 := fmt.Sprintf(argfmt, in[0])
|
||||
arg2 := fmt.Sprintf(argfmt, in[1])
|
||||
err := f.Parse([]string{arg1, arg2})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range is {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected is[%d] to be %d but got: %d", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
222
vendor/github.com/spf13/pflag/ip_slice_test.go
generated
vendored
222
vendor/github.com/spf13/pflag/ip_slice_test.go
generated
vendored
|
|
@ -1,222 +0,0 @@
|
|||
package pflag
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func setUpIPSFlagSet(ipsp *[]net.IP) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.IPSliceVar(ipsp, "ips", []net.IP{}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func setUpIPSFlagSetWithDefault(ipsp *[]net.IP) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.IPSliceVar(ipsp, "ips",
|
||||
[]net.IP{
|
||||
net.ParseIP("192.168.1.1"),
|
||||
net.ParseIP("0:0:0:0:0:0:0:1"),
|
||||
},
|
||||
"Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func TestEmptyIP(t *testing.T) {
|
||||
var ips []net.IP
|
||||
f := setUpIPSFlagSet(&ips)
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
getIPS, err := f.GetIPSlice("ips")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetIPSlice():", err)
|
||||
}
|
||||
if len(getIPS) != 0 {
|
||||
t.Fatalf("got ips %v with len=%d but expected length=0", getIPS, len(getIPS))
|
||||
}
|
||||
}
|
||||
|
||||
func TestIPS(t *testing.T) {
|
||||
var ips []net.IP
|
||||
f := setUpIPSFlagSet(&ips)
|
||||
|
||||
vals := []string{"192.168.1.1", "10.0.0.1", "0:0:0:0:0:0:0:2"}
|
||||
arg := fmt.Sprintf("--ips=%s", strings.Join(vals, ","))
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range ips {
|
||||
if ip := net.ParseIP(vals[i]); ip == nil {
|
||||
t.Fatalf("invalid string being converted to IP address: %s", vals[i])
|
||||
} else if !ip.Equal(v) {
|
||||
t.Fatalf("expected ips[%d] to be %s but got: %s from GetIPSlice", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestIPSDefault(t *testing.T) {
|
||||
var ips []net.IP
|
||||
f := setUpIPSFlagSetWithDefault(&ips)
|
||||
|
||||
vals := []string{"192.168.1.1", "0:0:0:0:0:0:0:1"}
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range ips {
|
||||
if ip := net.ParseIP(vals[i]); ip == nil {
|
||||
t.Fatalf("invalid string being converted to IP address: %s", vals[i])
|
||||
} else if !ip.Equal(v) {
|
||||
t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
getIPS, err := f.GetIPSlice("ips")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetIPSlice")
|
||||
}
|
||||
for i, v := range getIPS {
|
||||
if ip := net.ParseIP(vals[i]); ip == nil {
|
||||
t.Fatalf("invalid string being converted to IP address: %s", vals[i])
|
||||
} else if !ip.Equal(v) {
|
||||
t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestIPSWithDefault(t *testing.T) {
|
||||
var ips []net.IP
|
||||
f := setUpIPSFlagSetWithDefault(&ips)
|
||||
|
||||
vals := []string{"192.168.1.1", "0:0:0:0:0:0:0:1"}
|
||||
arg := fmt.Sprintf("--ips=%s", strings.Join(vals, ","))
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range ips {
|
||||
if ip := net.ParseIP(vals[i]); ip == nil {
|
||||
t.Fatalf("invalid string being converted to IP address: %s", vals[i])
|
||||
} else if !ip.Equal(v) {
|
||||
t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
getIPS, err := f.GetIPSlice("ips")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetIPSlice")
|
||||
}
|
||||
for i, v := range getIPS {
|
||||
if ip := net.ParseIP(vals[i]); ip == nil {
|
||||
t.Fatalf("invalid string being converted to IP address: %s", vals[i])
|
||||
} else if !ip.Equal(v) {
|
||||
t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestIPSCalledTwice(t *testing.T) {
|
||||
var ips []net.IP
|
||||
f := setUpIPSFlagSet(&ips)
|
||||
|
||||
in := []string{"192.168.1.2,0:0:0:0:0:0:0:1", "10.0.0.1"}
|
||||
expected := []net.IP{net.ParseIP("192.168.1.2"), net.ParseIP("0:0:0:0:0:0:0:1"), net.ParseIP("10.0.0.1")}
|
||||
argfmt := "ips=%s"
|
||||
arg1 := fmt.Sprintf(argfmt, in[0])
|
||||
arg2 := fmt.Sprintf(argfmt, in[1])
|
||||
err := f.Parse([]string{arg1, arg2})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range ips {
|
||||
if !expected[i].Equal(v) {
|
||||
t.Fatalf("expected ips[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestIPSBadQuoting(t *testing.T) {
|
||||
|
||||
tests := []struct {
|
||||
Want []net.IP
|
||||
FlagArg []string
|
||||
}{
|
||||
{
|
||||
Want: []net.IP{
|
||||
net.ParseIP("a4ab:61d:f03e:5d7d:fad7:d4c2:a1a5:568"),
|
||||
net.ParseIP("203.107.49.208"),
|
||||
net.ParseIP("14.57.204.90"),
|
||||
},
|
||||
FlagArg: []string{
|
||||
"a4ab:61d:f03e:5d7d:fad7:d4c2:a1a5:568",
|
||||
"203.107.49.208",
|
||||
"14.57.204.90",
|
||||
},
|
||||
},
|
||||
{
|
||||
Want: []net.IP{
|
||||
net.ParseIP("204.228.73.195"),
|
||||
net.ParseIP("86.141.15.94"),
|
||||
},
|
||||
FlagArg: []string{
|
||||
"204.228.73.195",
|
||||
"86.141.15.94",
|
||||
},
|
||||
},
|
||||
{
|
||||
Want: []net.IP{
|
||||
net.ParseIP("c70c:db36:3001:890f:c6ea:3f9b:7a39:cc3f"),
|
||||
net.ParseIP("4d17:1d6e:e699:bd7a:88c5:5e7e:ac6a:4472"),
|
||||
},
|
||||
FlagArg: []string{
|
||||
"c70c:db36:3001:890f:c6ea:3f9b:7a39:cc3f",
|
||||
"4d17:1d6e:e699:bd7a:88c5:5e7e:ac6a:4472",
|
||||
},
|
||||
},
|
||||
{
|
||||
Want: []net.IP{
|
||||
net.ParseIP("5170:f971:cfac:7be3:512a:af37:952c:bc33"),
|
||||
net.ParseIP("93.21.145.140"),
|
||||
net.ParseIP("2cac:61d3:c5ff:6caf:73e0:1b1a:c336:c1ca"),
|
||||
},
|
||||
FlagArg: []string{
|
||||
" 5170:f971:cfac:7be3:512a:af37:952c:bc33 , 93.21.145.140 ",
|
||||
"2cac:61d3:c5ff:6caf:73e0:1b1a:c336:c1ca",
|
||||
},
|
||||
},
|
||||
{
|
||||
Want: []net.IP{
|
||||
net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
|
||||
net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
|
||||
net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
|
||||
net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
|
||||
},
|
||||
FlagArg: []string{
|
||||
`"2e5e:66b2:6441:848:5b74:76ea:574c:3a7b, 2e5e:66b2:6441:848:5b74:76ea:574c:3a7b,2e5e:66b2:6441:848:5b74:76ea:574c:3a7b "`,
|
||||
" 2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"},
|
||||
},
|
||||
}
|
||||
|
||||
for i, test := range tests {
|
||||
|
||||
var ips []net.IP
|
||||
f := setUpIPSFlagSet(&ips)
|
||||
|
||||
if err := f.Parse([]string{fmt.Sprintf("--ips=%s", strings.Join(test.FlagArg, ","))}); err != nil {
|
||||
t.Fatalf("flag parsing failed with error: %s\nparsing:\t%#v\nwant:\t\t%s",
|
||||
err, test.FlagArg, test.Want[i])
|
||||
}
|
||||
|
||||
for j, b := range ips {
|
||||
if !b.Equal(test.Want[j]) {
|
||||
t.Fatalf("bad value parsed for test %d on net.IP %d:\nwant:\t%s\ngot:\t%s", i, j, test.Want[j], b)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
63
vendor/github.com/spf13/pflag/ip_test.go
generated
vendored
63
vendor/github.com/spf13/pflag/ip_test.go
generated
vendored
|
|
@ -1,63 +0,0 @@
|
|||
package pflag
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"os"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func setUpIP(ip *net.IP) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.IPVar(ip, "address", net.ParseIP("0.0.0.0"), "IP Address")
|
||||
return f
|
||||
}
|
||||
|
||||
func TestIP(t *testing.T) {
|
||||
testCases := []struct {
|
||||
input string
|
||||
success bool
|
||||
expected string
|
||||
}{
|
||||
{"0.0.0.0", true, "0.0.0.0"},
|
||||
{" 0.0.0.0 ", true, "0.0.0.0"},
|
||||
{"1.2.3.4", true, "1.2.3.4"},
|
||||
{"127.0.0.1", true, "127.0.0.1"},
|
||||
{"255.255.255.255", true, "255.255.255.255"},
|
||||
{"", false, ""},
|
||||
{"0", false, ""},
|
||||
{"localhost", false, ""},
|
||||
{"0.0.0", false, ""},
|
||||
{"0.0.0.", false, ""},
|
||||
{"0.0.0.0.", false, ""},
|
||||
{"0.0.0.256", false, ""},
|
||||
{"0 . 0 . 0 . 0", false, ""},
|
||||
}
|
||||
|
||||
devnull, _ := os.Open(os.DevNull)
|
||||
os.Stderr = devnull
|
||||
for i := range testCases {
|
||||
var addr net.IP
|
||||
f := setUpIP(&addr)
|
||||
|
||||
tc := &testCases[i]
|
||||
|
||||
arg := fmt.Sprintf("--address=%s", tc.input)
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil && tc.success == true {
|
||||
t.Errorf("expected success, got %q", err)
|
||||
continue
|
||||
} else if err == nil && tc.success == false {
|
||||
t.Errorf("expected failure")
|
||||
continue
|
||||
} else if tc.success {
|
||||
ip, err := f.GetIP("address")
|
||||
if err != nil {
|
||||
t.Errorf("Got error trying to fetch the IP flag: %v", err)
|
||||
}
|
||||
if ip.String() != tc.expected {
|
||||
t.Errorf("expected %q, got %q", tc.expected, ip.String())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
70
vendor/github.com/spf13/pflag/ipnet_test.go
generated
vendored
70
vendor/github.com/spf13/pflag/ipnet_test.go
generated
vendored
|
|
@ -1,70 +0,0 @@
|
|||
package pflag
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"os"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func setUpIPNet(ip *net.IPNet) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
_, def, _ := net.ParseCIDR("0.0.0.0/0")
|
||||
f.IPNetVar(ip, "address", *def, "IP Address")
|
||||
return f
|
||||
}
|
||||
|
||||
func TestIPNet(t *testing.T) {
|
||||
testCases := []struct {
|
||||
input string
|
||||
success bool
|
||||
expected string
|
||||
}{
|
||||
{"0.0.0.0/0", true, "0.0.0.0/0"},
|
||||
{" 0.0.0.0/0 ", true, "0.0.0.0/0"},
|
||||
{"1.2.3.4/8", true, "1.0.0.0/8"},
|
||||
{"127.0.0.1/16", true, "127.0.0.0/16"},
|
||||
{"255.255.255.255/19", true, "255.255.224.0/19"},
|
||||
{"255.255.255.255/32", true, "255.255.255.255/32"},
|
||||
{"", false, ""},
|
||||
{"/0", false, ""},
|
||||
{"0", false, ""},
|
||||
{"0/0", false, ""},
|
||||
{"localhost/0", false, ""},
|
||||
{"0.0.0/4", false, ""},
|
||||
{"0.0.0./8", false, ""},
|
||||
{"0.0.0.0./12", false, ""},
|
||||
{"0.0.0.256/16", false, ""},
|
||||
{"0.0.0.0 /20", false, ""},
|
||||
{"0.0.0.0/ 24", false, ""},
|
||||
{"0 . 0 . 0 . 0 / 28", false, ""},
|
||||
{"0.0.0.0/33", false, ""},
|
||||
}
|
||||
|
||||
devnull, _ := os.Open(os.DevNull)
|
||||
os.Stderr = devnull
|
||||
for i := range testCases {
|
||||
var addr net.IPNet
|
||||
f := setUpIPNet(&addr)
|
||||
|
||||
tc := &testCases[i]
|
||||
|
||||
arg := fmt.Sprintf("--address=%s", tc.input)
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil && tc.success == true {
|
||||
t.Errorf("expected success, got %q", err)
|
||||
continue
|
||||
} else if err == nil && tc.success == false {
|
||||
t.Errorf("expected failure")
|
||||
continue
|
||||
} else if tc.success {
|
||||
ip, err := f.GetIPNet("address")
|
||||
if err != nil {
|
||||
t.Errorf("Got error trying to fetch the IP flag: %v", err)
|
||||
}
|
||||
if ip.String() != tc.expected {
|
||||
t.Errorf("expected %q, got %q", tc.expected, ip.String())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
233
vendor/github.com/spf13/pflag/string_array_test.go
generated
vendored
233
vendor/github.com/spf13/pflag/string_array_test.go
generated
vendored
|
|
@ -1,233 +0,0 @@
|
|||
// Copyright 2009 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 file.
|
||||
|
||||
package pflag
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func setUpSAFlagSet(sap *[]string) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.StringArrayVar(sap, "sa", []string{}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func setUpSAFlagSetWithDefault(sap *[]string) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.StringArrayVar(sap, "sa", []string{"default", "values"}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func TestEmptySA(t *testing.T) {
|
||||
var sa []string
|
||||
f := setUpSAFlagSet(&sa)
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
getSA, err := f.GetStringArray("sa")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetStringArray():", err)
|
||||
}
|
||||
if len(getSA) != 0 {
|
||||
t.Fatalf("got sa %v with len=%d but expected length=0", getSA, len(getSA))
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmptySAValue(t *testing.T) {
|
||||
var sa []string
|
||||
f := setUpSAFlagSet(&sa)
|
||||
err := f.Parse([]string{"--sa="})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
getSA, err := f.GetStringArray("sa")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetStringArray():", err)
|
||||
}
|
||||
if len(getSA) != 0 {
|
||||
t.Fatalf("got sa %v with len=%d but expected length=0", getSA, len(getSA))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSADefault(t *testing.T) {
|
||||
var sa []string
|
||||
f := setUpSAFlagSetWithDefault(&sa)
|
||||
|
||||
vals := []string{"default", "values"}
|
||||
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range sa {
|
||||
if vals[i] != v {
|
||||
t.Fatalf("expected sa[%d] to be %s but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
getSA, err := f.GetStringArray("sa")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetStringArray():", err)
|
||||
}
|
||||
for i, v := range getSA {
|
||||
if vals[i] != v {
|
||||
t.Fatalf("expected sa[%d] to be %s from GetStringArray but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSAWithDefault(t *testing.T) {
|
||||
var sa []string
|
||||
f := setUpSAFlagSetWithDefault(&sa)
|
||||
|
||||
val := "one"
|
||||
arg := fmt.Sprintf("--sa=%s", val)
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(sa) != 1 {
|
||||
t.Fatalf("expected number of values to be %d but %d", 1, len(sa))
|
||||
}
|
||||
|
||||
if sa[0] != val {
|
||||
t.Fatalf("expected value to be %s but got: %s", sa[0], val)
|
||||
}
|
||||
|
||||
getSA, err := f.GetStringArray("sa")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetStringArray():", err)
|
||||
}
|
||||
|
||||
if len(getSA) != 1 {
|
||||
t.Fatalf("expected number of values to be %d but %d", 1, len(getSA))
|
||||
}
|
||||
|
||||
if getSA[0] != val {
|
||||
t.Fatalf("expected value to be %s but got: %s", getSA[0], val)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSACalledTwice(t *testing.T) {
|
||||
var sa []string
|
||||
f := setUpSAFlagSet(&sa)
|
||||
|
||||
in := []string{"one", "two"}
|
||||
expected := []string{"one", "two"}
|
||||
argfmt := "--sa=%s"
|
||||
arg1 := fmt.Sprintf(argfmt, in[0])
|
||||
arg2 := fmt.Sprintf(argfmt, in[1])
|
||||
err := f.Parse([]string{arg1, arg2})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(sa) {
|
||||
t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
|
||||
}
|
||||
for i, v := range sa {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
values, err := f.GetStringArray("sa")
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(values) {
|
||||
t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(sa))
|
||||
}
|
||||
for i, v := range values {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSAWithSpecialChar(t *testing.T) {
|
||||
var sa []string
|
||||
f := setUpSAFlagSet(&sa)
|
||||
|
||||
in := []string{"one,two", `"three"`, `"four,five",six`, "seven eight"}
|
||||
expected := []string{"one,two", `"three"`, `"four,five",six`, "seven eight"}
|
||||
argfmt := "--sa=%s"
|
||||
arg1 := fmt.Sprintf(argfmt, in[0])
|
||||
arg2 := fmt.Sprintf(argfmt, in[1])
|
||||
arg3 := fmt.Sprintf(argfmt, in[2])
|
||||
arg4 := fmt.Sprintf(argfmt, in[3])
|
||||
err := f.Parse([]string{arg1, arg2, arg3, arg4})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(sa) {
|
||||
t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
|
||||
}
|
||||
for i, v := range sa {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
values, err := f.GetStringArray("sa")
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(values) {
|
||||
t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
|
||||
}
|
||||
for i, v := range values {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSAWithSquareBrackets(t *testing.T) {
|
||||
var sa []string
|
||||
f := setUpSAFlagSet(&sa)
|
||||
|
||||
in := []string{"][]-[", "[a-z]", "[a-z]+"}
|
||||
expected := []string{"][]-[", "[a-z]", "[a-z]+"}
|
||||
argfmt := "--sa=%s"
|
||||
arg1 := fmt.Sprintf(argfmt, in[0])
|
||||
arg2 := fmt.Sprintf(argfmt, in[1])
|
||||
arg3 := fmt.Sprintf(argfmt, in[2])
|
||||
err := f.Parse([]string{arg1, arg2, arg3})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(sa) {
|
||||
t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
|
||||
}
|
||||
for i, v := range sa {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
values, err := f.GetStringArray("sa")
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(values) {
|
||||
t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
|
||||
}
|
||||
for i, v := range values {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
253
vendor/github.com/spf13/pflag/string_slice_test.go
generated
vendored
253
vendor/github.com/spf13/pflag/string_slice_test.go
generated
vendored
|
|
@ -1,253 +0,0 @@
|
|||
// Copyright 2009 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 file.
|
||||
|
||||
package pflag
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func setUpSSFlagSet(ssp *[]string) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.StringSliceVar(ssp, "ss", []string{}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func setUpSSFlagSetWithDefault(ssp *[]string) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.StringSliceVar(ssp, "ss", []string{"default", "values"}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func TestEmptySS(t *testing.T) {
|
||||
var ss []string
|
||||
f := setUpSSFlagSet(&ss)
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
getSS, err := f.GetStringSlice("ss")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetStringSlice():", err)
|
||||
}
|
||||
if len(getSS) != 0 {
|
||||
t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS))
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmptySSValue(t *testing.T) {
|
||||
var ss []string
|
||||
f := setUpSSFlagSet(&ss)
|
||||
err := f.Parse([]string{"--ss="})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
getSS, err := f.GetStringSlice("ss")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetStringSlice():", err)
|
||||
}
|
||||
if len(getSS) != 0 {
|
||||
t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSS(t *testing.T) {
|
||||
var ss []string
|
||||
f := setUpSSFlagSet(&ss)
|
||||
|
||||
vals := []string{"one", "two", "4", "3"}
|
||||
arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ","))
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range ss {
|
||||
if vals[i] != v {
|
||||
t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
getSS, err := f.GetStringSlice("ss")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetStringSlice():", err)
|
||||
}
|
||||
for i, v := range getSS {
|
||||
if vals[i] != v {
|
||||
t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSSDefault(t *testing.T) {
|
||||
var ss []string
|
||||
f := setUpSSFlagSetWithDefault(&ss)
|
||||
|
||||
vals := []string{"default", "values"}
|
||||
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range ss {
|
||||
if vals[i] != v {
|
||||
t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
getSS, err := f.GetStringSlice("ss")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetStringSlice():", err)
|
||||
}
|
||||
for i, v := range getSS {
|
||||
if vals[i] != v {
|
||||
t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSSWithDefault(t *testing.T) {
|
||||
var ss []string
|
||||
f := setUpSSFlagSetWithDefault(&ss)
|
||||
|
||||
vals := []string{"one", "two", "4", "3"}
|
||||
arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ","))
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range ss {
|
||||
if vals[i] != v {
|
||||
t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
getSS, err := f.GetStringSlice("ss")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetStringSlice():", err)
|
||||
}
|
||||
for i, v := range getSS {
|
||||
if vals[i] != v {
|
||||
t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSSCalledTwice(t *testing.T) {
|
||||
var ss []string
|
||||
f := setUpSSFlagSet(&ss)
|
||||
|
||||
in := []string{"one,two", "three"}
|
||||
expected := []string{"one", "two", "three"}
|
||||
argfmt := "--ss=%s"
|
||||
arg1 := fmt.Sprintf(argfmt, in[0])
|
||||
arg2 := fmt.Sprintf(argfmt, in[1])
|
||||
err := f.Parse([]string{arg1, arg2})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(ss) {
|
||||
t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
|
||||
}
|
||||
for i, v := range ss {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
values, err := f.GetStringSlice("ss")
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(values) {
|
||||
t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(ss))
|
||||
}
|
||||
for i, v := range values {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSSWithComma(t *testing.T) {
|
||||
var ss []string
|
||||
f := setUpSSFlagSet(&ss)
|
||||
|
||||
in := []string{`"one,two"`, `"three"`, `"four,five",six`}
|
||||
expected := []string{"one,two", "three", "four,five", "six"}
|
||||
argfmt := "--ss=%s"
|
||||
arg1 := fmt.Sprintf(argfmt, in[0])
|
||||
arg2 := fmt.Sprintf(argfmt, in[1])
|
||||
arg3 := fmt.Sprintf(argfmt, in[2])
|
||||
err := f.Parse([]string{arg1, arg2, arg3})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(ss) {
|
||||
t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
|
||||
}
|
||||
for i, v := range ss {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
values, err := f.GetStringSlice("ss")
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(values) {
|
||||
t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
|
||||
}
|
||||
for i, v := range values {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSSWithSquareBrackets(t *testing.T) {
|
||||
var ss []string
|
||||
f := setUpSSFlagSet(&ss)
|
||||
|
||||
in := []string{`"[a-z]"`, `"[a-z]+"`}
|
||||
expected := []string{"[a-z]", "[a-z]+"}
|
||||
argfmt := "--ss=%s"
|
||||
arg1 := fmt.Sprintf(argfmt, in[0])
|
||||
arg2 := fmt.Sprintf(argfmt, in[1])
|
||||
err := f.Parse([]string{arg1, arg2})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(ss) {
|
||||
t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
|
||||
}
|
||||
for i, v := range ss {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
|
||||
values, err := f.GetStringSlice("ss")
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
if len(expected) != len(values) {
|
||||
t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
|
||||
}
|
||||
for i, v := range values {
|
||||
if expected[i] != v {
|
||||
t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
161
vendor/github.com/spf13/pflag/uint_slice_test.go
generated
vendored
161
vendor/github.com/spf13/pflag/uint_slice_test.go
generated
vendored
|
|
@ -1,161 +0,0 @@
|
|||
package pflag
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func setUpUISFlagSet(uisp *[]uint) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.UintSliceVar(uisp, "uis", []uint{}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func setUpUISFlagSetWithDefault(uisp *[]uint) *FlagSet {
|
||||
f := NewFlagSet("test", ContinueOnError)
|
||||
f.UintSliceVar(uisp, "uis", []uint{0, 1}, "Command separated list!")
|
||||
return f
|
||||
}
|
||||
|
||||
func TestEmptyUIS(t *testing.T) {
|
||||
var uis []uint
|
||||
f := setUpUISFlagSet(&uis)
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
|
||||
getUIS, err := f.GetUintSlice("uis")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetUintSlice():", err)
|
||||
}
|
||||
if len(getUIS) != 0 {
|
||||
t.Fatalf("got is %v with len=%d but expected length=0", getUIS, len(getUIS))
|
||||
}
|
||||
}
|
||||
|
||||
func TestUIS(t *testing.T) {
|
||||
var uis []uint
|
||||
f := setUpUISFlagSet(&uis)
|
||||
|
||||
vals := []string{"1", "2", "4", "3"}
|
||||
arg := fmt.Sprintf("--uis=%s", strings.Join(vals, ","))
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range uis {
|
||||
u, err := strconv.ParseUint(vals[i], 10, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if uint(u) != v {
|
||||
t.Fatalf("expected uis[%d] to be %s but got %d", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
getUIS, err := f.GetUintSlice("uis")
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
for i, v := range getUIS {
|
||||
u, err := strconv.ParseUint(vals[i], 10, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if uint(u) != v {
|
||||
t.Fatalf("expected uis[%d] to be %s but got: %d from GetUintSlice", i, vals[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestUISDefault(t *testing.T) {
|
||||
var uis []uint
|
||||
f := setUpUISFlagSetWithDefault(&uis)
|
||||
|
||||
vals := []string{"0", "1"}
|
||||
|
||||
err := f.Parse([]string{})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range uis {
|
||||
u, err := strconv.ParseUint(vals[i], 10, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if uint(u) != v {
|
||||
t.Fatalf("expect uis[%d] to be %d but got: %d", i, u, v)
|
||||
}
|
||||
}
|
||||
|
||||
getUIS, err := f.GetUintSlice("uis")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetUintSlice():", err)
|
||||
}
|
||||
for i, v := range getUIS {
|
||||
u, err := strconv.ParseUint(vals[i], 10, 0)
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetIntSlice():", err)
|
||||
}
|
||||
if uint(u) != v {
|
||||
t.Fatalf("expected uis[%d] to be %d from GetUintSlice but got: %d", i, u, v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestUISWithDefault(t *testing.T) {
|
||||
var uis []uint
|
||||
f := setUpUISFlagSetWithDefault(&uis)
|
||||
|
||||
vals := []string{"1", "2"}
|
||||
arg := fmt.Sprintf("--uis=%s", strings.Join(vals, ","))
|
||||
err := f.Parse([]string{arg})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range uis {
|
||||
u, err := strconv.ParseUint(vals[i], 10, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if uint(u) != v {
|
||||
t.Fatalf("expected uis[%d] to be %d from GetUintSlice but got: %d", i, u, v)
|
||||
}
|
||||
}
|
||||
|
||||
getUIS, err := f.GetUintSlice("uis")
|
||||
if err != nil {
|
||||
t.Fatal("got an error from GetUintSlice():", err)
|
||||
}
|
||||
for i, v := range getUIS {
|
||||
u, err := strconv.ParseUint(vals[i], 10, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("got error: %v", err)
|
||||
}
|
||||
if uint(u) != v {
|
||||
t.Fatalf("expected uis[%d] to be %d from GetUintSlice but got: %d", i, u, v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestUISCalledTwice(t *testing.T) {
|
||||
var uis []uint
|
||||
f := setUpUISFlagSet(&uis)
|
||||
|
||||
in := []string{"1,2", "3"}
|
||||
expected := []int{1, 2, 3}
|
||||
argfmt := "--uis=%s"
|
||||
arg1 := fmt.Sprintf(argfmt, in[0])
|
||||
arg2 := fmt.Sprintf(argfmt, in[1])
|
||||
err := f.Parse([]string{arg1, arg2})
|
||||
if err != nil {
|
||||
t.Fatal("expected no error; got", err)
|
||||
}
|
||||
for i, v := range uis {
|
||||
if uint(expected[i]) != v {
|
||||
t.Fatalf("expected uis[%d] to be %d but got: %d", i, expected[i], v)
|
||||
}
|
||||
}
|
||||
}
|
||||
69
vendor/github.com/spf13/pflag/verify/all.sh
generated
vendored
69
vendor/github.com/spf13/pflag/verify/all.sh
generated
vendored
|
|
@ -1,69 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
|
||||
ROOT=$(dirname "${BASH_SOURCE}")/..
|
||||
|
||||
# Some useful colors.
|
||||
if [[ -z "${color_start-}" ]]; then
|
||||
declare -r color_start="\033["
|
||||
declare -r color_red="${color_start}0;31m"
|
||||
declare -r color_yellow="${color_start}0;33m"
|
||||
declare -r color_green="${color_start}0;32m"
|
||||
declare -r color_norm="${color_start}0m"
|
||||
fi
|
||||
|
||||
SILENT=true
|
||||
|
||||
function is-excluded {
|
||||
for e in $EXCLUDE; do
|
||||
if [[ $1 -ef ${BASH_SOURCE} ]]; then
|
||||
return
|
||||
fi
|
||||
if [[ $1 -ef "$ROOT/hack/$e" ]]; then
|
||||
return
|
||||
fi
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
while getopts ":v" opt; do
|
||||
case $opt in
|
||||
v)
|
||||
SILENT=false
|
||||
;;
|
||||
\?)
|
||||
echo "Invalid flag: -$OPTARG" >&2
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
if $SILENT ; then
|
||||
echo "Running in the silent mode, run with -v if you want to see script logs."
|
||||
fi
|
||||
|
||||
EXCLUDE="all.sh"
|
||||
|
||||
ret=0
|
||||
for t in `ls $ROOT/verify/*.sh`
|
||||
do
|
||||
if is-excluded $t ; then
|
||||
echo "Skipping $t"
|
||||
continue
|
||||
fi
|
||||
if $SILENT ; then
|
||||
echo -e "Verifying $t"
|
||||
if bash "$t" &> /dev/null; then
|
||||
echo -e "${color_green}SUCCESS${color_norm}"
|
||||
else
|
||||
echo -e "${color_red}FAILED${color_norm}"
|
||||
ret=1
|
||||
fi
|
||||
else
|
||||
bash "$t" || ret=1
|
||||
fi
|
||||
done
|
||||
exit $ret
|
||||
19
vendor/github.com/spf13/pflag/verify/gofmt.sh
generated
vendored
19
vendor/github.com/spf13/pflag/verify/gofmt.sh
generated
vendored
|
|
@ -1,19 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
|
||||
ROOT=$(dirname "${BASH_SOURCE}")/..
|
||||
|
||||
pushd "${ROOT}" > /dev/null
|
||||
|
||||
GOFMT=${GOFMT:-"gofmt"}
|
||||
bad_files=$(find . -name '*.go' | xargs $GOFMT -s -l)
|
||||
if [[ -n "${bad_files}" ]]; then
|
||||
echo "!!! '$GOFMT' needs to be run on the following files: "
|
||||
echo "${bad_files}"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# ex: ts=2 sw=2 et filetype=sh
|
||||
15
vendor/github.com/spf13/pflag/verify/golint.sh
generated
vendored
15
vendor/github.com/spf13/pflag/verify/golint.sh
generated
vendored
|
|
@ -1,15 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
ROOT=$(dirname "${BASH_SOURCE}")/..
|
||||
GOLINT=${GOLINT:-"golint"}
|
||||
|
||||
pushd "${ROOT}" > /dev/null
|
||||
bad_files=$($GOLINT -min_confidence=0.9 ./...)
|
||||
if [[ -n "${bad_files}" ]]; then
|
||||
echo "!!! '$GOLINT' problems: "
|
||||
echo "${bad_files}"
|
||||
exit 1
|
||||
fi
|
||||
popd > /dev/null
|
||||
|
||||
# ex: ts=2 sw=2 et filetype=sh
|
||||
Loading…
Add table
Add a link
Reference in a new issue