github.com/searKing/golang/go@v1.2.74/flag/flag_test.go (about)

     1  // Copyright 2020 The searKing Author. 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 flag_test
     6  
     7  import (
     8  	"flag"
     9  	"fmt"
    10  	"sort"
    11  	"testing"
    12  
    13  	flag_ "github.com/searKing/golang/go/flag"
    14  	"github.com/searKing/golang/go/util/object"
    15  )
    16  
    17  func TestEverything(t *testing.T) {
    18  	ResetForTesting(nil)
    19  	flag_.StringSlice("test_[]string", nil, "[]string value")
    20  
    21  	m := make(map[string]*flag.Flag)
    22  	desired := "0"
    23  	desiredStringSlice := ""
    24  	visitor := func(f *flag.Flag) {
    25  		if len(f.Name) > 5 && f.Name[0:5] == "test_" {
    26  			m[f.Name] = f
    27  			ok := false
    28  			switch {
    29  			case f.Value.String() == desired:
    30  				ok = true
    31  			case f.Name == "test_[]string" && f.Value.String() == fmt.Sprintf("[%s]", desiredStringSlice):
    32  				ok = true
    33  			}
    34  			if !ok {
    35  				t.Error("Visit: bad value", f.Value.String(), "for", f.Name)
    36  			}
    37  		}
    38  	}
    39  	flag.VisitAll(visitor)
    40  	if len(m) != 1 {
    41  		t.Error("VisitAll misses some flags")
    42  		for k, v := range m {
    43  			t.Log(k, *v)
    44  		}
    45  	}
    46  	m = make(map[string]*flag.Flag)
    47  	flag.Visit(visitor)
    48  	if len(m) != 0 {
    49  		t.Errorf("Visit sees unset flags")
    50  		for k, v := range m {
    51  			t.Log(k, *v)
    52  		}
    53  	}
    54  	// Now set all flags
    55  	flag.Set("test_[]string", "one")
    56  	flag.Set("test_[]string", "two")
    57  	desiredStringSlice = `"one" "two"`
    58  	flag.Visit(visitor)
    59  	if len(m) != 1 {
    60  		t.Error("Visit fails after set")
    61  		for k, v := range m {
    62  			t.Log(k, *v)
    63  		}
    64  	}
    65  	// Now test they're visited in sort order.
    66  	var flagNames []string
    67  	flag.Visit(func(f *flag.Flag) { flagNames = append(flagNames, f.Name) })
    68  	if !sort.StringsAreSorted(flagNames) {
    69  		t.Errorf("flag names not sorted: %v", flagNames)
    70  	}
    71  }
    72  
    73  func TestGet(t *testing.T) {
    74  	ResetForTesting(nil)
    75  	flag_.StringSlice("test_[]string", []string{"one", "two"}, "[]string value")
    76  
    77  	visitor := func(f *flag.Flag) {
    78  		if len(f.Name) > 5 && f.Name[0:5] == "test_" {
    79  			g, ok := f.Value.(flag.Getter)
    80  			if !ok {
    81  				t.Errorf("Visit: value does not satisfy Getter: %T", f.Value)
    82  				return
    83  			}
    84  			switch f.Name {
    85  			case "test_[]string":
    86  				ok = object.DeepEquals(g.Get(), []string{"one", "two"})
    87  			}
    88  			if !ok {
    89  				t.Errorf("Visit: bad value %T(%v) for %s", g.Get(), g.Get(), f.Name)
    90  			}
    91  		}
    92  	}
    93  	flag.VisitAll(visitor)
    94  }
    95  
    96  func testParse(f *flag.FlagSet, t *testing.T) {
    97  	if f.Parsed() {
    98  		t.Error("f.Parse() = true before Parse")
    99  	}
   100  	stringSliceFlag := flag_.StringSliceWithFlagSet(f, "test_[]string", []string{"one", "two"}, "[]string value")
   101  	stringSlice2Flag := flag_.StringSliceWithFlagSet(f, "test_[]string2", nil, "[]string value")
   102  	stringSlice3Flag := flag_.StringSliceWithFlagSet(f, "test_[]string3", nil, "[]string value")
   103  	extra := "one-extra-argument"
   104  	args := []string{
   105  		"-test_[]string", "1",
   106  		"-test_[]string", "2",
   107  		"-test_[]string", "3",
   108  		"--test_[]string2", "one",
   109  		extra,
   110  	}
   111  	if err := f.Parse(args); err != nil {
   112  		t.Fatal(err)
   113  	}
   114  	if !f.Parsed() {
   115  		t.Error("f.Parse() = false after Parse")
   116  	}
   117  	if !object.DeepEquals(*stringSliceFlag, []string{"1", "2", "3"}) {
   118  		t.Error("[]string flag should be [1 2 3], is ", *stringSliceFlag)
   119  	}
   120  	if !object.DeepEquals(*stringSlice2Flag, []string{"one"}) {
   121  		t.Error("[]string flag should be [one], is ", *stringSlice2Flag)
   122  	}
   123  	if object.IsNil(stringSlice3Flag) {
   124  		t.Error("[]string flag should be [], is ", *stringSlice3Flag)
   125  	}
   126  	if len(f.Args()) != 1 {
   127  		t.Error("expected one argument, got", len(f.Args()))
   128  	} else if f.Args()[0] != extra {
   129  		t.Errorf("expected argument %q got %q", extra, f.Args()[0])
   130  	}
   131  }
   132  
   133  func TestParse(t *testing.T) {
   134  	ResetForTesting(func() { t.Error("bad parse") })
   135  	testParse(flag.CommandLine, t)
   136  }
   137  
   138  func TestFlagSetParse(t *testing.T) {
   139  	testParse(flag.NewFlagSet("test", flag.ContinueOnError), t)
   140  }