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

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package pflag
   6
   7 import (
   8         "fmt"
   9         "testing"
  10 )
  11
  12 func setUpSAFlagSet(sap *[]string) *FlagSet {
  13         f := NewFlagSet("test", ContinueOnError)
  14         f.StringArrayVar(sap, "sa", []string{}, "Command separated list!")
  15         return f
  16 }
  17
  18 func setUpSAFlagSetWithDefault(sap *[]string) *FlagSet {
  19         f := NewFlagSet("test", ContinueOnError)
  20         f.StringArrayVar(sap, "sa", []string{"default", "values"}, "Command separated list!")
  21         return f
  22 }
  23
  24 func TestEmptySA(t *testing.T) {
  25         var sa []string
  26         f := setUpSAFlagSet(&sa)
  27         err := f.Parse([]string{})
  28         if err != nil {
  29                 t.Fatal("expected no error; got", err)
  30         }
  31
  32         getSA, err := f.GetStringArray("sa")
  33         if err != nil {
  34                 t.Fatal("got an error from GetStringArray():", err)
  35         }
  36         if len(getSA) != 0 {
  37                 t.Fatalf("got sa %v with len=%d but expected length=0", getSA, len(getSA))
  38         }
  39 }
  40
  41 func TestEmptySAValue(t *testing.T) {
  42         var sa []string
  43         f := setUpSAFlagSet(&sa)
  44         err := f.Parse([]string{"--sa="})
  45         if err != nil {
  46                 t.Fatal("expected no error; got", err)
  47         }
  48
  49         getSA, err := f.GetStringArray("sa")
  50         if err != nil {
  51                 t.Fatal("got an error from GetStringArray():", err)
  52         }
  53         if len(getSA) != 0 {
  54                 t.Fatalf("got sa %v with len=%d but expected length=0", getSA, len(getSA))
  55         }
  56 }
  57
  58 func TestSADefault(t *testing.T) {
  59         var sa []string
  60         f := setUpSAFlagSetWithDefault(&sa)
  61
  62         vals := []string{"default", "values"}
  63
  64         err := f.Parse([]string{})
  65         if err != nil {
  66                 t.Fatal("expected no error; got", err)
  67         }
  68         for i, v := range sa {
  69                 if vals[i] != v {
  70                         t.Fatalf("expected sa[%d] to be %s but got: %s", i, vals[i], v)
  71                 }
  72         }
  73
  74         getSA, err := f.GetStringArray("sa")
  75         if err != nil {
  76                 t.Fatal("got an error from GetStringArray():", err)
  77         }
  78         for i, v := range getSA {
  79                 if vals[i] != v {
  80                         t.Fatalf("expected sa[%d] to be %s from GetStringArray but got: %s", i, vals[i], v)
  81                 }
  82         }
  83 }
  84
  85 func TestSAWithDefault(t *testing.T) {
  86         var sa []string
  87         f := setUpSAFlagSetWithDefault(&sa)
  88
  89         val := "one"
  90         arg := fmt.Sprintf("--sa=%s", val)
  91         err := f.Parse([]string{arg})
  92         if err != nil {
  93                 t.Fatal("expected no error; got", err)
  94         }
  95
  96         if len(sa) != 1 {
  97                 t.Fatalf("expected number of values to be %d but %d", 1, len(sa))
  98         }
  99
 100         if sa[0] != val {
 101                 t.Fatalf("expected value to be %s but got: %s", sa[0], val)
 102         }
 103
 104         getSA, err := f.GetStringArray("sa")
 105         if err != nil {
 106                 t.Fatal("got an error from GetStringArray():", err)
 107         }
 108
 109         if len(getSA) != 1 {
 110                 t.Fatalf("expected number of values to be %d but %d", 1, len(getSA))
 111         }
 112
 113         if getSA[0] != val {
 114                 t.Fatalf("expected value to be %s but got: %s", getSA[0], val)
 115         }
 116 }
 117
 118 func TestSACalledTwice(t *testing.T) {
 119         var sa []string
 120         f := setUpSAFlagSet(&sa)
 121
 122         in := []string{"one", "two"}
 123         expected := []string{"one", "two"}
 124         argfmt := "--sa=%s"
 125         arg1 := fmt.Sprintf(argfmt, in[0])
 126         arg2 := fmt.Sprintf(argfmt, in[1])
 127         err := f.Parse([]string{arg1, arg2})
 128         if err != nil {
 129                 t.Fatal("expected no error; got", err)
 130         }
 131
 132         if len(expected) != len(sa) {
 133                 t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
 134         }
 135         for i, v := range sa {
 136                 if expected[i] != v {
 137                         t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
 138                 }
 139         }
 140
 141         values, err := f.GetStringArray("sa")
 142         if err != nil {
 143                 t.Fatal("expected no error; got", err)
 144         }
 145
 146         if len(expected) != len(values) {
 147                 t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(sa))
 148         }
 149         for i, v := range values {
 150                 if expected[i] != v {
 151                         t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
 152                 }
 153         }
 154 }
 155
 156 func TestSAWithSpecialChar(t *testing.T) {
 157         var sa []string
 158         f := setUpSAFlagSet(&sa)
 159
 160         in := []string{"one,two", `"three"`, `"four,five",six`, "seven eight"}
 161         expected := []string{"one,two", `"three"`, `"four,five",six`, "seven eight"}
 162         argfmt := "--sa=%s"
 163         arg1 := fmt.Sprintf(argfmt, in[0])
 164         arg2 := fmt.Sprintf(argfmt, in[1])
 165         arg3 := fmt.Sprintf(argfmt, in[2])
 166         arg4 := fmt.Sprintf(argfmt, in[3])
 167         err := f.Parse([]string{arg1, arg2, arg3, arg4})
 168         if err != nil {
 169                 t.Fatal("expected no error; got", err)
 170         }
 171
 172         if len(expected) != len(sa) {
 173                 t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
 174         }
 175         for i, v := range sa {
 176                 if expected[i] != v {
 177                         t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
 178                 }
 179         }
 180
 181         values, err := f.GetStringArray("sa")
 182         if err != nil {
 183                 t.Fatal("expected no error; got", err)
 184         }
 185
 186         if len(expected) != len(values) {
 187                 t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
 188         }
 189         for i, v := range values {
 190                 if expected[i] != v {
 191                         t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
 192                 }
 193         }
 194 }
 195
 196 func TestSAWithSquareBrackets(t *testing.T) {
 197         var sa []string
 198         f := setUpSAFlagSet(&sa)
 199
 200         in := []string{"][]-[", "[a-z]", "[a-z]+"}
 201         expected := []string{"][]-[", "[a-z]", "[a-z]+"}
 202         argfmt := "--sa=%s"
 203         arg1 := fmt.Sprintf(argfmt, in[0])
 204         arg2 := fmt.Sprintf(argfmt, in[1])
 205         arg3 := fmt.Sprintf(argfmt, in[2])
 206         err := f.Parse([]string{arg1, arg2, arg3})
 207         if err != nil {
 208                 t.Fatal("expected no error; got", err)
 209         }
 210
 211         if len(expected) != len(sa) {
 212                 t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
 213         }
 214         for i, v := range sa {
 215                 if expected[i] != v {
 216                         t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
 217                 }
 218         }
 219
 220         values, err := f.GetStringArray("sa")
 221         if err != nil {
 222                 t.Fatal("expected no error; got", err)
 223         }
 224
 225         if len(expected) != len(values) {
 226                 t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
 227         }
 228         for i, v := range values {
 229                 if expected[i] != v {
 230                         t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
 231                 }
 232         }
 233 }