github.com/kekek/gb@v0.4.5-0.20170222120241-d4ba64b0b297/cmd/gb/stringset_test.go (about)

     1  package main
     2  
     3  import "testing"
     4  import "reflect"
     5  
     6  func set(args ...string) map[string]bool {
     7  	r := make(map[string]bool)
     8  	for _, a := range args {
     9  		r[a] = true
    10  	}
    11  	return r
    12  }
    13  
    14  func TestUnion(t *testing.T) {
    15  	tests := []struct {
    16  		a, b map[string]bool
    17  		want map[string]bool
    18  	}{{
    19  		a: nil, b: nil,
    20  		want: set(),
    21  	}, {
    22  		a: nil, b: set("b"),
    23  		want: set("b"),
    24  	}, {
    25  		a: set("a"), b: nil,
    26  		want: set("a"),
    27  	}, {
    28  		a: set("a"), b: set("b"),
    29  		want: set("b", "a"),
    30  	}, {
    31  		a: set("c"), b: set("c"),
    32  		want: set("c"),
    33  	}}
    34  
    35  	for _, tt := range tests {
    36  		got := union(tt.a, tt.b)
    37  		if !reflect.DeepEqual(tt.want, got) {
    38  			t.Errorf("union(%v, %v) want: %v, got %v", tt.a, tt.b, tt.want, got)
    39  		}
    40  	}
    41  }
    42  
    43  func TestIntersection(t *testing.T) {
    44  	tests := []struct {
    45  		a, b map[string]bool
    46  		want map[string]bool
    47  	}{{
    48  		a: nil, b: nil,
    49  		want: set(),
    50  	}, {
    51  		a: nil, b: set("b"),
    52  		want: set(),
    53  	}, {
    54  		a: set("a"), b: nil,
    55  		want: set(),
    56  	}, {
    57  		a: set("a"), b: set("b"),
    58  		want: set(),
    59  	}, {
    60  		a: set("c"), b: set("c"),
    61  		want: set("c"),
    62  	}, {
    63  		a: set("a", "c"), b: set("b", "c"),
    64  		want: set("c"),
    65  	}}
    66  
    67  	for _, tt := range tests {
    68  		got := intersection(tt.a, tt.b)
    69  		if !reflect.DeepEqual(tt.want, got) {
    70  			t.Errorf("intersection(%v, %v) want: %v, got %v", tt.a, tt.b, tt.want, got)
    71  		}
    72  	}
    73  }
    74  
    75  func TestDifference(t *testing.T) {
    76  	tests := []struct {
    77  		a, b map[string]bool
    78  		want map[string]bool
    79  	}{{
    80  		a: nil, b: nil,
    81  		want: set(),
    82  	}, {
    83  		a: nil, b: set("b"),
    84  		want: set("b"),
    85  	}, {
    86  		a: set("a"), b: nil,
    87  		want: set("a"),
    88  	}, {
    89  		a: set("a"), b: set("b"),
    90  		want: set("a", "b"),
    91  	}, {
    92  		a: set("c"), b: set("c"),
    93  		want: set(),
    94  	}, {
    95  		a: set("a", "c"), b: set("b", "c"),
    96  		want: set("a", "b"),
    97  	}}
    98  
    99  	for _, tt := range tests {
   100  		got := difference(tt.a, tt.b)
   101  		if !reflect.DeepEqual(tt.want, got) {
   102  			t.Errorf("difference(%v, %v) want: %v, got %v", tt.a, tt.b, tt.want, got)
   103  		}
   104  	}
   105  }
   106  
   107  func TestContains(t *testing.T) {
   108  	tests := []struct {
   109  		a    map[string]bool
   110  		s    []string
   111  		want bool
   112  	}{{
   113  		a: nil, s: nil,
   114  		want: false,
   115  	}, {
   116  		a: set("a"), s: nil,
   117  		want: false,
   118  	}, {
   119  		a: set("a"), s: []string{"a"},
   120  		want: true,
   121  	}, {
   122  		a: set("a"), s: []string{"b"},
   123  		want: false,
   124  	}, {
   125  		a: set("a", "b"), s: []string{"b"},
   126  		want: true,
   127  	}, {
   128  		a: set("a"), s: []string{"a", "b"},
   129  		want: false,
   130  	}, {
   131  		a: set("a", "b", "c"), s: []string{"a", "b"},
   132  		want: true,
   133  	}, {
   134  		a: set("a", "b", "c"), s: []string{"x", "b"},
   135  		want: false,
   136  	}, {
   137  		a: set("a", "b", "c"), s: []string{"b", "c", "d"},
   138  		want: false,
   139  	}}
   140  
   141  	for _, tt := range tests {
   142  		got := contains(tt.a, tt.s...)
   143  		if !reflect.DeepEqual(tt.want, got) {
   144  			t.Errorf("contains(%v, %v) want: %v, got %v", tt.a, tt.s, tt.want, got)
   145  		}
   146  	}
   147  }