vendor/github.com/spf13/pflag/string_slice_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         "strings"
  10         "testing"
  11 )
  12
  13 func setUpSSFlagSet(ssp *[]string) *FlagSet {
  14         f := NewFlagSet("test", ContinueOnError)
  15         f.StringSliceVar(ssp, "ss", []string{}, "Command separated list!")
  16         return f
  17 }
  18
  19 func setUpSSFlagSetWithDefault(ssp *[]string) *FlagSet {
  20         f := NewFlagSet("test", ContinueOnError)
  21         f.StringSliceVar(ssp, "ss", []string{"default", "values"}, "Command separated list!")
  22         return f
  23 }
  24
  25 func TestEmptySS(t *testing.T) {
  26         var ss []string
  27         f := setUpSSFlagSet(&ss)
  28         err := f.Parse([]string{})
  29         if err != nil {
  30                 t.Fatal("expected no error; got", err)
  31         }
  32
  33         getSS, err := f.GetStringSlice("ss")
  34         if err != nil {
  35                 t.Fatal("got an error from GetStringSlice():", err)
  36         }
  37         if len(getSS) != 0 {
  38                 t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS))
  39         }
  40 }
  41
  42 func TestEmptySSValue(t *testing.T) {
  43         var ss []string
  44         f := setUpSSFlagSet(&ss)
  45         err := f.Parse([]string{"--ss="})
  46         if err != nil {
  47                 t.Fatal("expected no error; got", err)
  48         }
  49
  50         getSS, err := f.GetStringSlice("ss")
  51         if err != nil {
  52                 t.Fatal("got an error from GetStringSlice():", err)
  53         }
  54         if len(getSS) != 0 {
  55                 t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS))
  56         }
  57 }
  58
  59 func TestSS(t *testing.T) {
  60         var ss []string
  61         f := setUpSSFlagSet(&ss)
  62
  63         vals := []string{"one", "two", "4", "3"}
  64         arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ","))
  65         err := f.Parse([]string{arg})
  66         if err != nil {
  67                 t.Fatal("expected no error; got", err)
  68         }
  69         for i, v := range ss {
  70                 if vals[i] != v {
  71                         t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
  72                 }
  73         }
  74
  75         getSS, err := f.GetStringSlice("ss")
  76         if err != nil {
  77                 t.Fatal("got an error from GetStringSlice():", err)
  78         }
  79         for i, v := range getSS {
  80                 if vals[i] != v {
  81                         t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
  82                 }
  83         }
  84 }
  85
  86 func TestSSDefault(t *testing.T) {
  87         var ss []string
  88         f := setUpSSFlagSetWithDefault(&ss)
  89
  90         vals := []string{"default", "values"}
  91
  92         err := f.Parse([]string{})
  93         if err != nil {
  94                 t.Fatal("expected no error; got", err)
  95         }
  96         for i, v := range ss {
  97                 if vals[i] != v {
  98                         t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
  99                 }
 100         }
 101
 102         getSS, err := f.GetStringSlice("ss")
 103         if err != nil {
 104                 t.Fatal("got an error from GetStringSlice():", err)
 105         }
 106         for i, v := range getSS {
 107                 if vals[i] != v {
 108                         t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
 109                 }
 110         }
 111 }
 112
 113 func TestSSWithDefault(t *testing.T) {
 114         var ss []string
 115         f := setUpSSFlagSetWithDefault(&ss)
 116
 117         vals := []string{"one", "two", "4", "3"}
 118         arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ","))
 119         err := f.Parse([]string{arg})
 120         if err != nil {
 121                 t.Fatal("expected no error; got", err)
 122         }
 123         for i, v := range ss {
 124                 if vals[i] != v {
 125                         t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
 126                 }
 127         }
 128
 129         getSS, err := f.GetStringSlice("ss")
 130         if err != nil {
 131                 t.Fatal("got an error from GetStringSlice():", err)
 132         }
 133         for i, v := range getSS {
 134                 if vals[i] != v {
 135                         t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
 136                 }
 137         }
 138 }
 139
 140 func TestSSCalledTwice(t *testing.T) {
 141         var ss []string
 142         f := setUpSSFlagSet(&ss)
 143
 144         in := []string{"one,two", "three"}
 145         expected := []string{"one", "two", "three"}
 146         argfmt := "--ss=%s"
 147         arg1 := fmt.Sprintf(argfmt, in[0])
 148         arg2 := fmt.Sprintf(argfmt, in[1])
 149         err := f.Parse([]string{arg1, arg2})
 150         if err != nil {
 151                 t.Fatal("expected no error; got", err)
 152         }
 153
 154         if len(expected) != len(ss) {
 155                 t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
 156         }
 157         for i, v := range ss {
 158                 if expected[i] != v {
 159                         t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
 160                 }
 161         }
 162
 163         values, err := f.GetStringSlice("ss")
 164         if err != nil {
 165                 t.Fatal("expected no error; got", err)
 166         }
 167
 168         if len(expected) != len(values) {
 169                 t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(ss))
 170         }
 171         for i, v := range values {
 172                 if expected[i] != v {
 173                         t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
 174                 }
 175         }
 176 }
 177
 178 func TestSSWithComma(t *testing.T) {
 179         var ss []string
 180         f := setUpSSFlagSet(&ss)
 181
 182         in := []string{`"one,two"`, `"three"`, `"four,five",six`}
 183         expected := []string{"one,two", "three", "four,five", "six"}
 184         argfmt := "--ss=%s"
 185         arg1 := fmt.Sprintf(argfmt, in[0])
 186         arg2 := fmt.Sprintf(argfmt, in[1])
 187         arg3 := fmt.Sprintf(argfmt, in[2])
 188         err := f.Parse([]string{arg1, arg2, arg3})
 189         if err != nil {
 190                 t.Fatal("expected no error; got", err)
 191         }
 192
 193         if len(expected) != len(ss) {
 194                 t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
 195         }
 196         for i, v := range ss {
 197                 if expected[i] != v {
 198                         t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
 199                 }
 200         }
 201
 202         values, err := f.GetStringSlice("ss")
 203         if err != nil {
 204                 t.Fatal("expected no error; got", err)
 205         }
 206
 207         if len(expected) != len(values) {
 208                 t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
 209         }
 210         for i, v := range values {
 211                 if expected[i] != v {
 212                         t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
 213                 }
 214         }
 215 }
 216
 217 func TestSSWithSquareBrackets(t *testing.T) {
 218         var ss []string
 219         f := setUpSSFlagSet(&ss)
 220
 221         in := []string{`"[a-z]"`, `"[a-z]+"`}
 222         expected := []string{"[a-z]", "[a-z]+"}
 223         argfmt := "--ss=%s"
 224         arg1 := fmt.Sprintf(argfmt, in[0])
 225         arg2 := fmt.Sprintf(argfmt, in[1])
 226         err := f.Parse([]string{arg1, arg2})
 227         if err != nil {
 228                 t.Fatal("expected no error; got", err)
 229         }
 230
 231         if len(expected) != len(ss) {
 232                 t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
 233         }
 234         for i, v := range ss {
 235                 if expected[i] != v {
 236                         t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
 237                 }
 238         }
 239
 240         values, err := f.GetStringSlice("ss")
 241         if err != nil {
 242                 t.Fatal("expected no error; got", err)
 243         }
 244
 245         if len(expected) != len(values) {
 246                 t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
 247         }
 248         for i, v := range values {
 249                 if expected[i] != v {
 250                         t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
 251                 }
 252         }
 253 }