github.com/seeker-insurance/kit@v0.0.13/counter/string_test.go (about)

     1  package counter
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  )
     8  
     9  const (
    10  	foo, bar, baz = "foo", "bar", "baz"
    11  )
    12  
    13  func TestString_Add(t *testing.T) {
    14  	c := make(String)
    15  	c.Add(foo)
    16  	want := String{foo: 1}
    17  	assert.Equal(t, want, c)
    18  	want = String{foo: 2}
    19  	c.Add(foo)
    20  	assert.Equal(t, want, c)
    21  }
    22  
    23  func TestString_Neg(t *testing.T) {
    24  	want := String{foo: -2, bar: -1}
    25  	c := FromStrings(foo, foo, bar)
    26  	assert.Equal(t, want, c.Neg())
    27  }
    28  
    29  func TestString_NonzeroElements(t *testing.T) {
    30  	want := String{foo: 2, bar: -1}
    31  	c := String{foo: 2, bar: -1, baz: 0}
    32  	assert.Equal(t, want, c.NonZeroElements())
    33  }
    34  func TestString_String(t *testing.T) {
    35  	a := String{foo: 2, bar: 3}
    36  	want := `{bar:3, foo:2}`
    37  	assert.Equal(t, want, a.String())
    38  }
    39  
    40  func TestString_Sorted(t *testing.T) {
    41  	c := String{"c": 1, "b": 2, "a": 2}
    42  	pairs := c.Sorted()
    43  	assert.Equal(t, []string{"c", "a", "b"}, pairs.Keys(), "should sort by count")
    44  	assert.Equal(t, []int{1, 2, 2}, pairs.Counts())
    45  }
    46  
    47  func TestString_Combine(t *testing.T) {
    48  	a := String{foo: 2, bar: 3}
    49  	b := String{foo: 1, bar: 1, baz: 1}
    50  	want := String{foo: 3, bar: 4, baz: 1}
    51  	assert.Equal(t, want, a.Combine(b))
    52  }
    53  
    54  func TestString_Copy(t *testing.T) {
    55  	a := String{foo: 1}
    56  	b := a.Copy()
    57  	b.Add(foo)
    58  	assert.Equal(t, String{foo: 2}, b)
    59  	assert.Equal(t, String{foo: 1}, a) //no leak
    60  }
    61  
    62  func TestMin(t *testing.T) {
    63  	a := String{foo: 1, bar: 2, baz: -2}
    64  	b := String{foo: -1}
    65  	c := String{bar: -4}
    66  	want := String{foo: -1, bar: -4, baz: -2}
    67  	assert.Equal(t, want, Min(a, b, c))
    68  	assert.Equal(t, want, Min(b, a, c))
    69  }
    70  
    71  func TestMax(t *testing.T) {
    72  	a := String{foo: 1, bar: 2, baz: -2}
    73  	b := String{foo: -1}
    74  	c := String{bar: 4}
    75  	want := String{foo: 1, bar: 4, baz: -2}
    76  	assert.Equal(t, want, Max(a, b, c))
    77  	assert.Equal(t, want, Max(b, a, c))
    78  }
    79  
    80  func TestFromStrings(t *testing.T) {
    81  	a := []string{foo, bar, bar, bar, foo, baz}
    82  	want := String{foo: 2, bar: 3, baz: 1}
    83  	assert.Equal(t, want, FromStrings(a...))
    84  }
    85  
    86  func Test_StringEqual(t *testing.T) {
    87  	a, b := String{foo: 2, bar: 3}, String{foo: 2, bar: 3}
    88  	assert.True(t, a.Equal(b))
    89  
    90  	c, d := String{}, String{foo: 2}
    91  	assert.False(t, c.Equal(d))
    92  
    93  	e, f := String{foo: 2, bar: 3}, String{foo: 3, bar: 3}
    94  	assert.False(t, e.Equal(f))
    95  }
    96  
    97  func Test_StringPositiveElements(t *testing.T) {
    98  	a := String{foo: 3, bar: -2, baz: 0}
    99  	want := String{foo: 3}
   100  	assert.Equal(t, want, a.PositiveElements())
   101  }
   102  
   103  func TestString_MostCommonN(t *testing.T) {
   104  	wantKeys, wantVals := []string{foo, bar}, []int{3, 2}
   105  	counter := String{foo: 3, bar: 2, baz: 2, "a": 1}
   106  	_, err := counter.MostCommonN(5)
   107  	assert.Error(t, err)
   108  	_, err = counter.MostCommonN(-1)
   109  	assert.Error(t, err)
   110  
   111  	gotPairs, err := counter.MostCommonN(2)
   112  	assert.NoError(t, err)
   113  	assert.Equal(t, wantKeys, gotPairs.Keys())
   114  	assert.Equal(t, wantVals, gotPairs.Counts())
   115  }
   116  
   117  func TestString_MostCommon(t *testing.T) {
   118  	wantKey, wantVal := foo, 3
   119  	counter := String{foo: 3, bar: 2, baz: -1}
   120  	gotKey, gotVal := counter.MostCommon()
   121  	assert.Equal(t, wantKey, gotKey)
   122  	assert.Equal(t, wantVal, gotVal)
   123  }