github.com/kevinklinger/open_terraform@v1.3.6/noninternal/dag/set_test.go (about)

     1  package dag
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  )
     7  
     8  func TestSetDifference(t *testing.T) {
     9  	cases := []struct {
    10  		Name     string
    11  		A, B     []interface{}
    12  		Expected []interface{}
    13  	}{
    14  		{
    15  			"same",
    16  			[]interface{}{1, 2, 3},
    17  			[]interface{}{3, 1, 2},
    18  			[]interface{}{},
    19  		},
    20  
    21  		{
    22  			"A has extra elements",
    23  			[]interface{}{1, 2, 3},
    24  			[]interface{}{3, 2},
    25  			[]interface{}{1},
    26  		},
    27  
    28  		{
    29  			"B has extra elements",
    30  			[]interface{}{1, 2, 3},
    31  			[]interface{}{3, 2, 1, 4},
    32  			[]interface{}{},
    33  		},
    34  		{
    35  			"B is nil",
    36  			[]interface{}{1, 2, 3},
    37  			nil,
    38  			[]interface{}{1, 2, 3},
    39  		},
    40  	}
    41  
    42  	for i, tc := range cases {
    43  		t.Run(fmt.Sprintf("%d-%s", i, tc.Name), func(t *testing.T) {
    44  			one := make(Set)
    45  			two := make(Set)
    46  			expected := make(Set)
    47  			for _, v := range tc.A {
    48  				one.Add(v)
    49  			}
    50  			for _, v := range tc.B {
    51  				two.Add(v)
    52  			}
    53  			if tc.B == nil {
    54  				two = nil
    55  			}
    56  			for _, v := range tc.Expected {
    57  				expected.Add(v)
    58  			}
    59  
    60  			actual := one.Difference(two)
    61  			match := actual.Intersection(expected)
    62  			if match.Len() != expected.Len() {
    63  				t.Fatalf("bad: %#v", actual.List())
    64  			}
    65  		})
    66  	}
    67  }
    68  
    69  func TestSetFilter(t *testing.T) {
    70  	cases := []struct {
    71  		Input    []interface{}
    72  		Expected []interface{}
    73  	}{
    74  		{
    75  			[]interface{}{1, 2, 3},
    76  			[]interface{}{1, 2, 3},
    77  		},
    78  
    79  		{
    80  			[]interface{}{4, 5, 6},
    81  			[]interface{}{4},
    82  		},
    83  
    84  		{
    85  			[]interface{}{7, 8, 9},
    86  			[]interface{}{},
    87  		},
    88  	}
    89  
    90  	for i, tc := range cases {
    91  		t.Run(fmt.Sprintf("%d-%#v", i, tc.Input), func(t *testing.T) {
    92  			input := make(Set)
    93  			expected := make(Set)
    94  			for _, v := range tc.Input {
    95  				input.Add(v)
    96  			}
    97  			for _, v := range tc.Expected {
    98  				expected.Add(v)
    99  			}
   100  
   101  			actual := input.Filter(func(v interface{}) bool {
   102  				return v.(int) < 5
   103  			})
   104  			match := actual.Intersection(expected)
   105  			if match.Len() != expected.Len() {
   106  				t.Fatalf("bad: %#v", actual.List())
   107  			}
   108  		})
   109  	}
   110  }
   111  
   112  func TestSetCopy(t *testing.T) {
   113  	a := make(Set)
   114  	a.Add(1)
   115  	a.Add(2)
   116  
   117  	b := a.Copy()
   118  	b.Add(3)
   119  
   120  	diff := b.Difference(a)
   121  
   122  	if diff.Len() != 1 {
   123  		t.Fatalf("expected single diff value, got %#v", diff)
   124  	}
   125  
   126  	if !diff.Include(3) {
   127  		t.Fatalf("diff does not contain 3, got %#v", diff)
   128  	}
   129  
   130  }
   131  
   132  func makeSet(n int) Set {
   133  	ret := make(Set, n)
   134  	for i := 0; i < n; i++ {
   135  		ret.Add(i)
   136  	}
   137  	return ret
   138  }
   139  
   140  func BenchmarkSetIntersection_100_100000(b *testing.B) {
   141  	small := makeSet(100)
   142  	large := makeSet(100000)
   143  
   144  	b.ResetTimer()
   145  	for n := 0; n < b.N; n++ {
   146  		small.Intersection(large)
   147  	}
   148  }
   149  
   150  func BenchmarkSetIntersection_100000_100(b *testing.B) {
   151  	small := makeSet(100)
   152  	large := makeSet(100000)
   153  
   154  	b.ResetTimer()
   155  	for n := 0; n < b.N; n++ {
   156  		large.Intersection(small)
   157  	}
   158  }