vendor/github.com/spf13/pflag/bool_slice_test.go

   1 package pflag
   2
   3 import (
   4         "fmt"
   5         "strconv"
   6         "strings"
   7         "testing"
   8 )
   9
  10 func setUpBSFlagSet(bsp *[]bool) *FlagSet {
  11         f := NewFlagSet("test", ContinueOnError)
  12         f.BoolSliceVar(bsp, "bs", []bool{}, "Command separated list!")
  13         return f
  14 }
  15
  16 func setUpBSFlagSetWithDefault(bsp *[]bool) *FlagSet {
  17         f := NewFlagSet("test", ContinueOnError)
  18         f.BoolSliceVar(bsp, "bs", []bool{false, true}, "Command separated list!")
  19         return f
  20 }
  21
  22 func TestEmptyBS(t *testing.T) {
  23         var bs []bool
  24         f := setUpBSFlagSet(&bs)
  25         err := f.Parse([]string{})
  26         if err != nil {
  27                 t.Fatal("expected no error; got", err)
  28         }
  29
  30         getBS, err := f.GetBoolSlice("bs")
  31         if err != nil {
  32                 t.Fatal("got an error from GetBoolSlice():", err)
  33         }
  34         if len(getBS) != 0 {
  35                 t.Fatalf("got bs %v with len=%d but expected length=0", getBS, len(getBS))
  36         }
  37 }
  38
  39 func TestBS(t *testing.T) {
  40         var bs []bool
  41         f := setUpBSFlagSet(&bs)
  42
  43         vals := []string{"1", "F", "TRUE", "0"}
  44         arg := fmt.Sprintf("--bs=%s", strings.Join(vals, ","))
  45         err := f.Parse([]string{arg})
  46         if err != nil {
  47                 t.Fatal("expected no error; got", err)
  48         }
  49         for i, v := range bs {
  50                 b, err := strconv.ParseBool(vals[i])
  51                 if err != nil {
  52                         t.Fatalf("got error: %v", err)
  53                 }
  54                 if b != v {
  55                         t.Fatalf("expected is[%d] to be %s but got: %t", i, vals[i], v)
  56                 }
  57         }
  58         getBS, err := f.GetBoolSlice("bs")
  59         if err != nil {
  60                 t.Fatalf("got error: %v", err)
  61         }
  62         for i, v := range getBS {
  63                 b, err := strconv.ParseBool(vals[i])
  64                 if err != nil {
  65                         t.Fatalf("got error: %v", err)
  66                 }
  67                 if b != v {
  68                         t.Fatalf("expected bs[%d] to be %s but got: %t from GetBoolSlice", i, vals[i], v)
  69                 }
  70         }
  71 }
  72
  73 func TestBSDefault(t *testing.T) {
  74         var bs []bool
  75         f := setUpBSFlagSetWithDefault(&bs)
  76
  77         vals := []string{"false", "T"}
  78
  79         err := f.Parse([]string{})
  80         if err != nil {
  81                 t.Fatal("expected no error; got", err)
  82         }
  83         for i, v := range bs {
  84                 b, err := strconv.ParseBool(vals[i])
  85                 if err != nil {
  86                         t.Fatalf("got error: %v", err)
  87                 }
  88                 if b != v {
  89                         t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
  90                 }
  91         }
  92
  93         getBS, err := f.GetBoolSlice("bs")
  94         if err != nil {
  95                 t.Fatal("got an error from GetBoolSlice():", err)
  96         }
  97         for i, v := range getBS {
  98                 b, err := strconv.ParseBool(vals[i])
  99                 if err != nil {
 100                         t.Fatal("got an error from GetBoolSlice():", err)
 101                 }
 102                 if b != v {
 103                         t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
 104                 }
 105         }
 106 }
 107
 108 func TestBSWithDefault(t *testing.T) {
 109         var bs []bool
 110         f := setUpBSFlagSetWithDefault(&bs)
 111
 112         vals := []string{"FALSE", "1"}
 113         arg := fmt.Sprintf("--bs=%s", strings.Join(vals, ","))
 114         err := f.Parse([]string{arg})
 115         if err != nil {
 116                 t.Fatal("expected no error; got", err)
 117         }
 118         for i, v := range bs {
 119                 b, err := strconv.ParseBool(vals[i])
 120                 if err != nil {
 121                         t.Fatalf("got error: %v", err)
 122                 }
 123                 if b != v {
 124                         t.Fatalf("expected bs[%d] to be %t but got: %t", i, b, v)
 125                 }
 126         }
 127
 128         getBS, err := f.GetBoolSlice("bs")
 129         if err != nil {
 130                 t.Fatal("got an error from GetBoolSlice():", err)
 131         }
 132         for i, v := range getBS {
 133                 b, err := strconv.ParseBool(vals[i])
 134                 if err != nil {
 135                         t.Fatalf("got error: %v", err)
 136                 }
 137                 if b != v {
 138                         t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
 139                 }
 140         }
 141 }
 142
 143 func TestBSCalledTwice(t *testing.T) {
 144         var bs []bool
 145         f := setUpBSFlagSet(&bs)
 146
 147         in := []string{"T,F", "T"}
 148         expected := []bool{true, false, true}
 149         argfmt := "--bs=%s"
 150         arg1 := fmt.Sprintf(argfmt, in[0])
 151         arg2 := fmt.Sprintf(argfmt, in[1])
 152         err := f.Parse([]string{arg1, arg2})
 153         if err != nil {
 154                 t.Fatal("expected no error; got", err)
 155         }
 156         for i, v := range bs {
 157                 if expected[i] != v {
 158                         t.Fatalf("expected bs[%d] to be %t but got %t", i, expected[i], v)
 159                 }
 160         }
 161 }
 162
 163 func TestBSBadQuoting(t *testing.T) {
 164
 165         tests := []struct {
 166                 Want    []bool
 167                 FlagArg []string
 168         }{
 169                 {
 170                         Want:    []bool{true, false, true},
 171                         FlagArg: []string{"1", "0", "true"},
 172                 },
 173                 {
 174                         Want:    []bool{true, false},
 175                         FlagArg: []string{"True", "F"},
 176                 },
 177                 {
 178                         Want:    []bool{true, false},
 179                         FlagArg: []string{"T", "0"},
 180                 },
 181                 {
 182                         Want:    []bool{true, false},
 183                         FlagArg: []string{"1", "0"},
 184                 },
 185                 {
 186                         Want:    []bool{true, false, false},
 187                         FlagArg: []string{"true,false", "false"},
 188                 },
 189                 {
 190                         Want:    []bool{true, false, false, true, false, true, false},
 191                         FlagArg: []string{`"true,false,false,1,0,     T"`, " false "},
 192                 },
 193                 {
 194                         Want:    []bool{false, false, true, false, true, false, true},
 195                         FlagArg: []string{`"0, False,  T,false  , true,F"`, "true"},
 196                 },
 197         }
 198
 199         for i, test := range tests {
 200
 201                 var bs []bool
 202                 f := setUpBSFlagSet(&bs)
 203
 204                 if err := f.Parse([]string{fmt.Sprintf("--bs=%s", strings.Join(test.FlagArg, ","))}); err != nil {
 205                         t.Fatalf("flag parsing failed with error: %s\nparsing:\t%#v\nwant:\t\t%#v",
 206                                 err, test.FlagArg, test.Want[i])
 207                 }
 208
 209                 for j, b := range bs {
 210                         if b != test.Want[j] {
 211                                 t.Fatalf("bad value parsed for test %d on bool %d:\nwant:\t%t\ngot:\t%t", i, j, test.Want[j], b)
 212                         }
 213                 }
 214         }
 215 }