github.com/stffabi/git-lfs@v2.3.5-0.20180214015214-8eeaa8d88902+incompatible/tools/ordered_set_test.go (about)

     1  package tools
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/stretchr/testify/require"
     8  )
     9  
    10  func TestOrderedSetAddAddsElements(t *testing.T) {
    11  	s := NewOrderedSetFromSlice([]string{"a", "b", "c"})
    12  
    13  	assert.False(t, s.Contains("d"),
    14  		"tools: did not expected s to contain \"d\"")
    15  
    16  	assert.True(t, s.Add("d"))
    17  
    18  	assert.True(t, s.Contains("d"),
    19  		"tools: expected s to contain \"d\"")
    20  }
    21  
    22  func TestOrderedSetContainsReturnsTrueForItemsItContains(t *testing.T) {
    23  	s := NewOrderedSetFromSlice([]string{"a", "b", "c"})
    24  
    25  	assert.True(t, s.Contains("b"),
    26  		"tools: expected s to contain element \"b\"")
    27  }
    28  
    29  func TestOrderedSetContainsReturnsFalseForItemsItDoesNotContains(t *testing.T) {
    30  	s := NewOrderedSetFromSlice([]string{"a", "b", "c"})
    31  
    32  	assert.False(t, s.Contains("d"),
    33  		"tools: did not expect s to contain element \"d\"")
    34  }
    35  
    36  func TestOrderedSetContainsAllReturnsTrueWhenAllElementsAreContained(t *testing.T) {
    37  	s := NewOrderedSetFromSlice([]string{"a", "b", "c"})
    38  
    39  	assert.True(t, s.ContainsAll("b", "c"),
    40  		"tools: expected s to contain element \"b\" and \"c\"")
    41  }
    42  
    43  func TestOrderedSetContainsAllReturnsFalseWhenAllElementsAreNotContained(t *testing.T) {
    44  	s := NewOrderedSetFromSlice([]string{"a", "b", "c"})
    45  
    46  	assert.False(t, s.ContainsAll("b", "c", "d"),
    47  		"tools: did not expect s to contain element \"b\", \"c\" and \"d\"")
    48  }
    49  
    50  func TestOrderedSetIsSubsetReturnsTrueWhenOtherContainsAllElements(t *testing.T) {
    51  	s1 := NewOrderedSetFromSlice([]string{"a", "b", "c"})
    52  	s2 := NewOrderedSetFromSlice([]string{"a", "b"})
    53  
    54  	assert.True(t, s1.IsSubset(s2),
    55  		"tools: expected [a, b] to be a subset of [a, b, c]")
    56  }
    57  
    58  func TestOrderedSetIsSubsetReturnsFalseWhenOtherDoesNotContainAllElements(t *testing.T) {
    59  	s1 := NewOrderedSetFromSlice([]string{"a", "b"})
    60  	s2 := NewOrderedSetFromSlice([]string{"a", "b", "c"})
    61  
    62  	assert.False(t, s1.IsSubset(s2),
    63  		"tools: did not expect [a, b, c] to be a subset of [a, b]")
    64  }
    65  
    66  func TestOrderedSetIsSupersetReturnsTrueWhenContainsAllElementsOfOther(t *testing.T) {
    67  	s1 := NewOrderedSetFromSlice([]string{"a", "b"})
    68  	s2 := NewOrderedSetFromSlice([]string{"a", "b", "c"})
    69  
    70  	assert.True(t, s1.IsSuperset(s2),
    71  		"tools: expected [a, b, c] to be a superset of [a, b]")
    72  }
    73  
    74  func TestOrderedSetIsSupersetReturnsFalseWhenDoesNotContainAllElementsOfOther(t *testing.T) {
    75  	s1 := NewOrderedSetFromSlice([]string{"a", "b", "c"})
    76  	s2 := NewOrderedSetFromSlice([]string{"a", "b"})
    77  
    78  	assert.False(t, s1.IsSuperset(s2),
    79  		"tools: did not expect [a, b] to be a superset of [a, b, c]")
    80  }
    81  
    82  func TestOrderedSetUnion(t *testing.T) {
    83  	s1 := NewOrderedSetFromSlice([]string{"a"})
    84  	s2 := NewOrderedSetFromSlice([]string{"b", "a"})
    85  
    86  	elems := make([]string, 0)
    87  	for e := range s1.Union(s2).Iter() {
    88  		elems = append(elems, e)
    89  	}
    90  
    91  	require.Len(t, elems, 2)
    92  	assert.Equal(t, "a", elems[0])
    93  	assert.Equal(t, "b", elems[1])
    94  }
    95  
    96  func TestOrderedSetIntersect(t *testing.T) {
    97  	s1 := NewOrderedSetFromSlice([]string{"a"})
    98  	s2 := NewOrderedSetFromSlice([]string{"b", "a"})
    99  
   100  	elems := make([]string, 0)
   101  	for e := range s1.Intersect(s2).Iter() {
   102  		elems = append(elems, e)
   103  	}
   104  
   105  	require.Len(t, elems, 1)
   106  	assert.Equal(t, "a", elems[0])
   107  }
   108  
   109  func TestOrderedSetDifference(t *testing.T) {
   110  	s1 := NewOrderedSetFromSlice([]string{"a", "b"})
   111  	s2 := NewOrderedSetFromSlice([]string{"a"})
   112  
   113  	elems := make([]string, 0)
   114  	for e := range s1.Difference(s2).Iter() {
   115  		elems = append(elems, e)
   116  	}
   117  
   118  	require.Len(t, elems, 1)
   119  	assert.Equal(t, "b", elems[0])
   120  }
   121  
   122  func TestOrderedSetSymmetricDifference(t *testing.T) {
   123  	s1 := NewOrderedSetFromSlice([]string{"a", "b"})
   124  	s2 := NewOrderedSetFromSlice([]string{"b", "c"})
   125  
   126  	elems := make([]string, 0)
   127  	for e := range s1.SymmetricDifference(s2).Iter() {
   128  		elems = append(elems, e)
   129  	}
   130  
   131  	require.Len(t, elems, 2)
   132  	assert.Equal(t, "a", elems[0])
   133  	assert.Equal(t, "c", elems[1])
   134  }
   135  
   136  func TestOrderedSetClear(t *testing.T) {
   137  	s1 := NewOrderedSetFromSlice([]string{"a", "b"})
   138  
   139  	assert.Equal(t, 2, s1.Cardinality())
   140  
   141  	s1.Clear()
   142  
   143  	assert.Equal(t, 0, s1.Cardinality())
   144  }
   145  
   146  func TestOrderedSetRemove(t *testing.T) {
   147  	s1 := NewOrderedSetFromSlice([]string{"a", "b"})
   148  
   149  	assert.True(t, s1.Contains("a"), "tools: expected [a, b] to contain 'a'")
   150  	assert.True(t, s1.Contains("b"), "tools: expected [a, b] to contain 'b'")
   151  
   152  	s1.Remove("a")
   153  
   154  	assert.False(t, s1.Contains("a"), "tools: did not expect to find 'a' in [b]")
   155  	assert.True(t, s1.Contains("b"), "tools: expected [b] to contain 'b'")
   156  }
   157  
   158  func TestOrderedSetCardinality(t *testing.T) {
   159  	s1 := NewOrderedSetFromSlice([]string{"a", "b"})
   160  
   161  	assert.Equal(t, 2, s1.Cardinality(),
   162  		"tools: expected cardinality of [a, b] to equal 2")
   163  }
   164  
   165  func TestOrderedSetIter(t *testing.T) {
   166  	s1 := NewOrderedSetFromSlice([]string{"a", "b", "c"})
   167  
   168  	elems := make([]string, 0)
   169  	for e := range s1.Iter() {
   170  		elems = append(elems, e)
   171  	}
   172  
   173  	require.Len(t, elems, 3)
   174  	assert.Equal(t, "a", elems[0])
   175  	assert.Equal(t, "b", elems[1])
   176  	assert.Equal(t, "c", elems[2])
   177  }
   178  
   179  func TestOrderedSetEqualReturnsTrueWhenSameElementsInSameOrder(t *testing.T) {
   180  	s1 := NewOrderedSetFromSlice([]string{"a", "b", "c"})
   181  	s2 := NewOrderedSetFromSlice([]string{"a", "b", "c"})
   182  
   183  	assert.True(t, s1.Equal(s2),
   184  		"tools: expected [a, b, c] to equal [a, b, c]")
   185  }
   186  
   187  func TestOrderedSetEqualReturnsFalseWhenSameElementsInDifferentOrder(t *testing.T) {
   188  	s1 := NewOrderedSetFromSlice([]string{"a", "b", "c"})
   189  	s2 := NewOrderedSetFromSlice([]string{"a", "c", "b"})
   190  
   191  	assert.False(t, s1.Equal(s2),
   192  		"tools: did not expect [a, b, c] to equal [a, c, b]")
   193  }
   194  
   195  func TestOrderedSetEqualReturnsFalseWithDifferentCardinalities(t *testing.T) {
   196  	s1 := NewOrderedSetFromSlice([]string{"a"})
   197  	s2 := NewOrderedSetFromSlice([]string{"a", "b"})
   198  
   199  	assert.False(t, s1.Equal(s2),
   200  		"tools: did not expect [a] to equal [a, b]")
   201  }
   202  
   203  func TestOrderedSetClone(t *testing.T) {
   204  	s1 := NewOrderedSetFromSlice([]string{"a", "b", "c"})
   205  
   206  	s2 := s1.Clone()
   207  
   208  	elems := make([]string, 0)
   209  	for e := range s2.Iter() {
   210  		elems = append(elems, e)
   211  	}
   212  
   213  	require.Len(t, elems, 3)
   214  	assert.Equal(t, "a", elems[0])
   215  	assert.Equal(t, "b", elems[1])
   216  	assert.Equal(t, "c", elems[2])
   217  }