github.com/anchore/syft@v1.38.2/internal/set_test.go (about)

     1  package internal
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/stretchr/testify/require"
     8  )
     9  
    10  func TestNewSet(t *testing.T) {
    11  	tests := []struct {
    12  		name   string
    13  		start  []int
    14  		result Set[int]
    15  	}{
    16  		{"empty set", []int{}, NewSet[int]()},
    17  		{"non-empty set", []int{1, 2, 3}, NewSet(1, 2, 3)},
    18  	}
    19  
    20  	for _, tt := range tests {
    21  		t.Run(tt.name, func(t *testing.T) {
    22  			s := NewSet(tt.start...)
    23  			require.Equal(t, tt.result, s)
    24  		})
    25  	}
    26  }
    27  
    28  func TestAdd(t *testing.T) {
    29  	tests := []struct {
    30  		name   string
    31  		input  []int
    32  		add    []int
    33  		result Set[int]
    34  	}{
    35  		{"add to empty set", []int{}, []int{1, 2, 3}, NewSet(1, 2, 3)},
    36  		{"add to non-empty set", []int{1}, []int{2, 3}, NewSet(1, 2, 3)},
    37  		{"add existing elements", []int{1, 2}, []int{2, 3}, NewSet(1, 2, 3)},
    38  	}
    39  
    40  	for _, tt := range tests {
    41  		t.Run(tt.name, func(t *testing.T) {
    42  			s := NewSet(tt.input...)
    43  			s.Add(tt.add...)
    44  			assert.Equal(t, tt.result, s)
    45  		})
    46  	}
    47  }
    48  
    49  func TestRemove(t *testing.T) {
    50  	tests := []struct {
    51  		name   string
    52  		input  []int
    53  		remove int
    54  		result Set[int]
    55  	}{
    56  		{"remove from non-empty set", []int{1, 2, 3}, 2, NewSet(1, 3)},
    57  		{"remove non-existent element", []int{1, 2}, 3, NewSet(1, 2)},
    58  		{"remove from single-element set", []int{1}, 1, NewSet[int]()},
    59  	}
    60  
    61  	for _, tt := range tests {
    62  		t.Run(tt.name, func(t *testing.T) {
    63  			s := NewSet(tt.input...)
    64  			s.Remove(tt.remove)
    65  			assert.Equal(t, tt.result, s)
    66  		})
    67  	}
    68  }
    69  
    70  func TestContains(t *testing.T) {
    71  	tests := []struct {
    72  		name     string
    73  		input    []int
    74  		contains int
    75  		result   bool
    76  	}{
    77  		{"element in set", []int{1, 2, 3}, 2, true},
    78  		{"element not in set", []int{1, 2}, 3, false},
    79  		{"empty set", []int{}, 1, false},
    80  	}
    81  
    82  	for _, tt := range tests {
    83  		t.Run(tt.name, func(t *testing.T) {
    84  			s := NewSet(tt.input...)
    85  			assert.Equal(t, tt.result, s.Contains(tt.contains))
    86  		})
    87  	}
    88  }
    89  
    90  func TestToSlice(t *testing.T) {
    91  	tests := []struct {
    92  		name   string
    93  		input  []int
    94  		result []int
    95  	}{
    96  		{"non-empty set", []int{3, 1, 2}, []int{1, 2, 3}},
    97  		{"empty set", []int{}, []int{}},
    98  	}
    99  
   100  	for _, tt := range tests {
   101  		t.Run(tt.name, func(t *testing.T) {
   102  			s := NewSet(tt.input...)
   103  			assert.Equal(t, tt.result, s.ToSlice())
   104  		})
   105  	}
   106  }
   107  
   108  func TestEquals(t *testing.T) {
   109  	tests := []struct {
   110  		name   string
   111  		set1   []int
   112  		set2   []int
   113  		result bool
   114  	}{
   115  		{"equal sets", []int{1, 2, 3}, []int{3, 2, 1}, true},
   116  		{"different sets", []int{1, 2}, []int{2, 3}, false},
   117  		{"empty sets", []int{}, []int{}, true},
   118  		{"one empty set", []int{1, 2}, []int{}, false},
   119  	}
   120  
   121  	for _, tt := range tests {
   122  		t.Run(tt.name, func(t *testing.T) {
   123  			s1 := NewSet(tt.set1...)
   124  			s2 := NewSet(tt.set2...)
   125  			assert.Equal(t, tt.result, s1.Equals(s2))
   126  		})
   127  	}
   128  }
   129  
   130  func TestEmpty(t *testing.T) {
   131  	tests := []struct {
   132  		name   string
   133  		input  []int
   134  		result bool
   135  	}{
   136  		{"non-empty set", []int{1}, false},
   137  		{"empty set", []int{}, true},
   138  	}
   139  
   140  	for _, tt := range tests {
   141  		t.Run(tt.name, func(t *testing.T) {
   142  			s := NewSet(tt.input...)
   143  			assert.Equal(t, tt.result, s.Empty())
   144  		})
   145  	}
   146  }