vendor/github.com/spf13/pflag/int_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         "strconv"
  10         "strings"
  11         "testing"
  12 )
  13
  14 func setUpISFlagSet(isp *[]int) *FlagSet {
  15         f := NewFlagSet("test", ContinueOnError)
  16         f.IntSliceVar(isp, "is", []int{}, "Command separated list!")
  17         return f
  18 }
  19
  20 func setUpISFlagSetWithDefault(isp *[]int) *FlagSet {
  21         f := NewFlagSet("test", ContinueOnError)
  22         f.IntSliceVar(isp, "is", []int{0, 1}, "Command separated list!")
  23         return f
  24 }
  25
  26 func TestEmptyIS(t *testing.T) {
  27         var is []int
  28         f := setUpISFlagSet(&is)
  29         err := f.Parse([]string{})
  30         if err != nil {
  31                 t.Fatal("expected no error; got", err)
  32         }
  33
  34         getIS, err := f.GetIntSlice("is")
  35         if err != nil {
  36                 t.Fatal("got an error from GetIntSlice():", err)
  37         }
  38         if len(getIS) != 0 {
  39                 t.Fatalf("got is %v with len=%d but expected length=0", getIS, len(getIS))
  40         }
  41 }
  42
  43 func TestIS(t *testing.T) {
  44         var is []int
  45         f := setUpISFlagSet(&is)
  46
  47         vals := []string{"1", "2", "4", "3"}
  48         arg := fmt.Sprintf("--is=%s", strings.Join(vals, ","))
  49         err := f.Parse([]string{arg})
  50         if err != nil {
  51                 t.Fatal("expected no error; got", err)
  52         }
  53         for i, v := range is {
  54                 d, err := strconv.Atoi(vals[i])
  55                 if err != nil {
  56                         t.Fatalf("got error: %v", err)
  57                 }
  58                 if d != v {
  59                         t.Fatalf("expected is[%d] to be %s but got: %d", i, vals[i], v)
  60                 }
  61         }
  62         getIS, err := f.GetIntSlice("is")
  63         if err != nil {
  64                 t.Fatalf("got error: %v", err)
  65         }
  66         for i, v := range getIS {
  67                 d, err := strconv.Atoi(vals[i])
  68                 if err != nil {
  69                         t.Fatalf("got error: %v", err)
  70                 }
  71                 if d != v {
  72                         t.Fatalf("expected is[%d] to be %s but got: %d from GetIntSlice", i, vals[i], v)
  73                 }
  74         }
  75 }
  76
  77 func TestISDefault(t *testing.T) {
  78         var is []int
  79         f := setUpISFlagSetWithDefault(&is)
  80
  81         vals := []string{"0", "1"}
  82
  83         err := f.Parse([]string{})
  84         if err != nil {
  85                 t.Fatal("expected no error; got", err)
  86         }
  87         for i, v := range is {
  88                 d, err := strconv.Atoi(vals[i])
  89                 if err != nil {
  90                         t.Fatalf("got error: %v", err)
  91                 }
  92                 if d != v {
  93                         t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
  94                 }
  95         }
  96
  97         getIS, err := f.GetIntSlice("is")
  98         if err != nil {
  99                 t.Fatal("got an error from GetIntSlice():", err)
 100         }
 101         for i, v := range getIS {
 102                 d, err := strconv.Atoi(vals[i])
 103                 if err != nil {
 104                         t.Fatal("got an error from GetIntSlice():", err)
 105                 }
 106                 if d != v {
 107                         t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v)
 108                 }
 109         }
 110 }
 111
 112 func TestISWithDefault(t *testing.T) {
 113         var is []int
 114         f := setUpISFlagSetWithDefault(&is)
 115
 116         vals := []string{"1", "2"}
 117         arg := fmt.Sprintf("--is=%s", strings.Join(vals, ","))
 118         err := f.Parse([]string{arg})
 119         if err != nil {
 120                 t.Fatal("expected no error; got", err)
 121         }
 122         for i, v := range is {
 123                 d, err := strconv.Atoi(vals[i])
 124                 if err != nil {
 125                         t.Fatalf("got error: %v", err)
 126                 }
 127                 if d != v {
 128                         t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
 129                 }
 130         }
 131
 132         getIS, err := f.GetIntSlice("is")
 133         if err != nil {
 134                 t.Fatal("got an error from GetIntSlice():", err)
 135         }
 136         for i, v := range getIS {
 137                 d, err := strconv.Atoi(vals[i])
 138                 if err != nil {
 139                         t.Fatalf("got error: %v", err)
 140                 }
 141                 if d != v {
 142                         t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v)
 143                 }
 144         }
 145 }
 146
 147 func TestISCalledTwice(t *testing.T) {
 148         var is []int
 149         f := setUpISFlagSet(&is)
 150
 151         in := []string{"1,2", "3"}
 152         expected := []int{1, 2, 3}
 153         argfmt := "--is=%s"
 154         arg1 := fmt.Sprintf(argfmt, in[0])
 155         arg2 := fmt.Sprintf(argfmt, in[1])
 156         err := f.Parse([]string{arg1, arg2})
 157         if err != nil {
 158                 t.Fatal("expected no error; got", err)
 159         }
 160         for i, v := range is {
 161                 if expected[i] != v {
 162                         t.Fatalf("expected is[%d] to be %d but got: %d", i, expected[i], v)
 163                 }
 164         }
 165 }