github.com/google/syzkaller@v0.0.0-20251211124644-a066d2bc4b02/pkg/tool/flags_test.go (about)

     1  // Copyright 2020 syzkaller project authors. All rights reserved.
     2  // Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
     3  
     4  package tool
     5  
     6  import (
     7  	"errors"
     8  	"flag"
     9  	"fmt"
    10  	"io"
    11  	"strings"
    12  	"testing"
    13  
    14  	"github.com/google/go-cmp/cmp"
    15  	"github.com/stretchr/testify/assert"
    16  )
    17  
    18  func TestParseFlags(t *testing.T) {
    19  	type Values struct {
    20  		Foo bool
    21  		Bar int
    22  		Baz string
    23  	}
    24  	type Test struct {
    25  		args string
    26  		vals *Values
    27  	}
    28  	tests := []Test{
    29  		{"", &Values{false, 1, "baz"}},
    30  		{"-foo -bar=2", &Values{true, 2, "baz"}},
    31  		{"-foo -bar=2 -qux", nil},
    32  		{"-foo -bar=2 " + OptionalFlags([]Flag{{"qux", ""}}), &Values{true, 2, "baz"}},
    33  	}
    34  	for i, test := range tests {
    35  		t.Run(fmt.Sprint(i), func(t *testing.T) {
    36  			vals := new(Values)
    37  			flags := flag.NewFlagSet("", flag.ContinueOnError)
    38  			flags.SetOutput(io.Discard)
    39  			flags.BoolVar(&vals.Foo, "foo", false, "")
    40  			flags.IntVar(&vals.Bar, "bar", 1, "")
    41  			flags.StringVar(&vals.Baz, "baz", "baz", "")
    42  			args := append(strings.Split(test.args, " "), "arg0", "arg1")
    43  			if args[0] == "" {
    44  				args = args[1:]
    45  			}
    46  			err := ParseFlags(flags, args)
    47  			if test.vals == nil {
    48  				if err == nil {
    49  					t.Fatalf("parsing did not fail")
    50  				}
    51  				return
    52  			}
    53  			if err != nil {
    54  				t.Fatalf("parsing failed: %v", err)
    55  			}
    56  			if diff := cmp.Diff(test.vals, vals); diff != "" {
    57  				t.Fatal(diff)
    58  			}
    59  			if flags.NArg() != 2 || flags.Arg(0) != "arg0" || flags.Arg(1) != "arg1" {
    60  				t.Fatalf("bad args: %q", flags.Args())
    61  			}
    62  		})
    63  	}
    64  }
    65  
    66  func TestCfgsFlagString(t *testing.T) {
    67  	cfgs := &CfgsFlag{"a", "b", "c"}
    68  	if got, want := cfgs.String(), "[a b c]"; got != want {
    69  		t.Errorf("cfgs.String got: %s, want: %s", got, want)
    70  	}
    71  }
    72  
    73  func TestCfgsFlagSet(t *testing.T) {
    74  	cfgs := &CfgsFlag{}
    75  	if err := cfgs.Set("a, b, c"); err != nil {
    76  		t.Fatalf("cfgs.Set got: %v, want: nil", err)
    77  	}
    78  	if diff := cmp.Diff(*cfgs, CfgsFlag{"a", "b", "c"}); diff != "" {
    79  		t.Errorf("*cfgs mismatch (-want +got):\n%s", diff)
    80  	}
    81  }
    82  
    83  func TestCfgsFlagAlreadySet(t *testing.T) {
    84  	cfgs := &CfgsFlag{"a", "b", "c"}
    85  	if err := cfgs.Set("a, b, c"); err == nil {
    86  		t.Errorf("cfgs.Set got: nil, want: error")
    87  	}
    88  }
    89  
    90  func TestParseArchList(t *testing.T) {
    91  	type Test struct {
    92  		OS  string
    93  		In  string
    94  		Out []string
    95  		Err error
    96  	}
    97  	tests := []Test{
    98  		{
    99  			OS:  "foo",
   100  			Err: errors.New(`bad OS "foo"`),
   101  		},
   102  		{
   103  			OS:  "linux",
   104  			In:  "amd64,bar",
   105  			Err: errors.New(`bad arch "bar" for OS "linux" in arches flag`),
   106  		},
   107  		{
   108  			OS:  "linux",
   109  			In:  "",
   110  			Out: []string{"386", "amd64", "arm", "arm64", "mips64le", "ppc64le", "riscv64", "s390x"},
   111  		},
   112  		{
   113  			OS:  "linux",
   114  			In:  "ppc64le,386",
   115  			Out: []string{"386", "ppc64le"},
   116  		},
   117  	}
   118  	for i, test := range tests {
   119  		t.Run(fmt.Sprint(i), func(t *testing.T) {
   120  			got, err := ParseArchList(test.OS, test.In)
   121  			assert.Equal(t, err, test.Err)
   122  			assert.Equal(t, got, test.Out)
   123  		})
   124  	}
   125  }