github.com/gopherjs/gopherjs@v1.19.0-beta1.0.20240506212314-27071a8796e4/internal/experiments/experiments_test.go (about)

     1  package experiments
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/google/go-cmp/cmp"
     8  )
     9  
    10  func TestParseFlags(t *testing.T) {
    11  	type testFlags struct {
    12  		Exp1     bool `flag:"exp1"`
    13  		Exp2     bool `flag:"exp2"`
    14  		Untagged bool
    15  	}
    16  
    17  	tests := []struct {
    18  		descr   string
    19  		raw     string
    20  		want    testFlags
    21  		wantErr error
    22  	}{{
    23  		descr: "default values",
    24  		raw:   "",
    25  		want: testFlags{
    26  			Exp1: false,
    27  			Exp2: false,
    28  		},
    29  	}, {
    30  		descr: "true flag",
    31  		raw:   "exp1=true",
    32  		want: testFlags{
    33  			Exp1: true,
    34  			Exp2: false,
    35  		},
    36  	}, {
    37  		descr: "false flag",
    38  		raw:   "exp1=false",
    39  		want: testFlags{
    40  			Exp1: false,
    41  			Exp2: false,
    42  		},
    43  	}, {
    44  		descr: "implicit value",
    45  		raw:   "exp1",
    46  		want: testFlags{
    47  			Exp1: true,
    48  			Exp2: false,
    49  		},
    50  	}, {
    51  		descr: "multiple flags",
    52  		raw:   "exp1=true,exp2=true",
    53  		want: testFlags{
    54  			Exp1: true,
    55  			Exp2: true,
    56  		},
    57  	}, {
    58  		descr: "repeated flag",
    59  		raw:   "exp1=false,exp1=true",
    60  		want: testFlags{
    61  			Exp1: true,
    62  			Exp2: false,
    63  		},
    64  	}, {
    65  		descr: "spaces",
    66  		raw:   " exp1 = true, exp2=true ",
    67  		want: testFlags{
    68  			Exp1: true,
    69  			Exp2: true,
    70  		},
    71  	}, {
    72  		descr: "unknown flags",
    73  		raw:   "Exp1=true,Untagged,Foo=true",
    74  		want: testFlags{
    75  			Exp1:     false,
    76  			Exp2:     false,
    77  			Untagged: false,
    78  		},
    79  	}, {
    80  		descr:   "empty flag name",
    81  		raw:     "=true",
    82  		wantErr: ErrInvalidFormat,
    83  	}, {
    84  		descr:   "invalid flag value",
    85  		raw:     "exp1=foo",
    86  		wantErr: ErrInvalidFormat,
    87  	}}
    88  
    89  	for _, test := range tests {
    90  		t.Run(test.descr, func(t *testing.T) {
    91  			got := testFlags{}
    92  			err := parseFlags(test.raw, &got)
    93  			if test.wantErr != nil {
    94  				if !errors.Is(err, test.wantErr) {
    95  					t.Errorf("Got: parseFlags(%q) returned error: %v. Want: %v.", test.raw, err, test.wantErr)
    96  				}
    97  			} else {
    98  				if err != nil {
    99  					t.Fatalf("Got: parseFlags(%q) returned error: %v. Want: no error.", test.raw, err)
   100  				}
   101  				if diff := cmp.Diff(test.want, got); diff != "" {
   102  					t.Fatalf("parseFlags(%q) returned diff (-want,+got):\n%s", test.raw, diff)
   103  				}
   104  			}
   105  		})
   106  	}
   107  
   108  	t.Run("invalid dest type", func(t *testing.T) {
   109  		var dest string
   110  		err := parseFlags("", &dest)
   111  		if !errors.Is(err, ErrInvalidDest) {
   112  			t.Fatalf("Got: parseFlags() returned error: %v. Want: %v.", err, ErrInvalidDest)
   113  		}
   114  	})
   115  
   116  	t.Run("nil dest", func(t *testing.T) {
   117  		err := parseFlags("", (*struct{})(nil))
   118  		if !errors.Is(err, ErrInvalidDest) {
   119  			t.Fatalf("Got: parseFlags() returned error: %v. Want: %v.", err, ErrInvalidDest)
   120  		}
   121  	})
   122  
   123  	t.Run("unsupported flag type", func(t *testing.T) {
   124  		var dest struct {
   125  			Foo string `flag:"foo"`
   126  		}
   127  		err := parseFlags("foo", &dest)
   128  		if !errors.Is(err, ErrInvalidDest) {
   129  			t.Fatalf("Got: parseFlags() returned error: %v. Want: %v.", err, ErrInvalidDest)
   130  		}
   131  	})
   132  }