github.com/mitranim/gg@v0.1.17/set_test.go (about)

     1  package gg_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/mitranim/gg"
     7  	"github.com/mitranim/gg/gtest"
     8  )
     9  
    10  func TestSetOf(t *testing.T) {
    11  	defer gtest.Catch(t)
    12  
    13  	gtest.Equal(gg.SetOf[int](), IntSet{})
    14  	gtest.Equal(gg.SetOf(10), IntSet{10: void})
    15  	gtest.Equal(gg.SetOf(10, 20), IntSet{10: void, 20: void})
    16  	gtest.Equal(gg.SetOf(10, 20, 30), IntSet{10: void, 20: void, 30: void})
    17  	gtest.Equal(gg.SetOf(10, 20, 30, 10, 20), IntSet{10: void, 20: void, 30: void})
    18  }
    19  
    20  func BenchmarkSetOf_empty(b *testing.B) {
    21  	for ind := 0; ind < b.N; ind++ {
    22  		gg.Nop1(gg.SetOf[int]())
    23  	}
    24  }
    25  
    26  func BenchmarkSetOf_non_empty(b *testing.B) {
    27  	for ind := 0; ind < b.N; ind++ {
    28  		gg.Nop1(gg.SetOf(10, 20, 30, 40, 50, 60, 70, 80, 90))
    29  	}
    30  }
    31  
    32  func TestSet(t *testing.T) {
    33  	defer gtest.Catch(t)
    34  
    35  	t.Run(`SetOf`, func(t *testing.T) {
    36  		defer gtest.Catch(t)
    37  
    38  		gtest.Equal(gg.SetOf[int](), IntSet{})
    39  		gtest.Equal(gg.SetOf[int](10), IntSet{10: void})
    40  		gtest.Equal(gg.SetOf[int](10, 20), IntSet{10: void, 20: void})
    41  	})
    42  
    43  	t.Run(`Add`, func(t *testing.T) {
    44  		defer gtest.Catch(t)
    45  
    46  		set := IntSet{}
    47  		gtest.Equal(set, IntSet{})
    48  
    49  		set.Add(10)
    50  		gtest.Equal(set, IntSet{10: void})
    51  
    52  		set.Add(20, 30)
    53  		gtest.Equal(set, IntSet{10: void, 20: void, 30: void})
    54  	})
    55  
    56  	t.Run(`Clear`, func(t *testing.T) {
    57  		defer gtest.Catch(t)
    58  
    59  		gtest.Equal(IntSet{10: void, 20: void}.Clear(), IntSet{})
    60  	})
    61  
    62  	t.Run(`Reset`, func(t *testing.T) {
    63  		defer gtest.Catch(t)
    64  
    65  		set := IntSet{}
    66  		gtest.Equal(set, IntSet{})
    67  
    68  		set.Add(10)
    69  		gtest.Equal(set, IntSet{10: void})
    70  
    71  		set.Reset(20, 30)
    72  		gtest.Equal(set, IntSet{20: void, 30: void})
    73  	})
    74  
    75  	// TODO test multiple values (issue: ordering).
    76  	t.Run(`Slice`, func(t *testing.T) {
    77  		defer gtest.Catch(t)
    78  
    79  		gtest.Zero(IntSet(nil).Slice())
    80  		gtest.Equal(IntSet{}.Slice(), []int{})
    81  		gtest.Equal(IntSet{10: void}.Slice(), []int{10})
    82  	})
    83  
    84  	// TODO test multiple values (issue: ordering).
    85  	t.Run(`Filter`, func(t *testing.T) {
    86  		defer gtest.Catch(t)
    87  
    88  		gtest.Zero(IntSet(nil).Filter(gg.IsPos[int]))
    89  		gtest.Zero(IntSet{}.Filter(gg.IsPos[int]))
    90  		gtest.Zero(IntSet{-10: void}.Filter(gg.IsPos[int]))
    91  		gtest.Equal(IntSet{10: void}.Filter(gg.IsPos[int]), []int{10})
    92  	})
    93  
    94  	// TODO test multiple values (issue: ordering).
    95  	t.Run(`MarshalJSON`, func(t *testing.T) {
    96  		defer gtest.Catch(t)
    97  
    98  		test := func(set IntSet, exp string) {
    99  			gtest.Equal(gg.JsonString(set), exp)
   100  		}
   101  
   102  		test(IntSet(nil), `null`)
   103  		test(IntSet{}, `[]`)
   104  		test(IntSet{}.Add(10), `[10]`)
   105  	})
   106  
   107  	// TODO test multiple values (issue: ordering).
   108  	t.Run(`UnmarshalJSON`, func(t *testing.T) {
   109  		defer gtest.Catch(t)
   110  
   111  		test := func(src string, exp IntSet) {
   112  			gtest.Equal(gg.JsonParseTo[IntSet](src), exp)
   113  		}
   114  
   115  		test(`[]`, IntSet{})
   116  		test(`[10]`, IntSet{}.Add(10))
   117  	})
   118  
   119  	// TODO test multiple values (issue: ordering).
   120  	t.Run(`GoString`, func(t *testing.T) {
   121  		defer gtest.Catch(t)
   122  
   123  		gtest.Eq(gg.GoString(IntSet(nil)), `gg.Set[int](nil)`)
   124  		gtest.Eq(gg.GoString(IntSet{}), `gg.Set[int]{}`)
   125  		gtest.Eq(gg.GoString(IntSet{}.Add(10)), `gg.Set[int]{}.Add(10)`)
   126  	})
   127  }
   128  
   129  func Benchmark_Set_GoString(b *testing.B) {
   130  	val := gg.SetOf(10, 20, 30)
   131  
   132  	for ind := 0; ind < b.N; ind++ {
   133  		gg.Nop1(val.GoString())
   134  	}
   135  }