github.com/m4gshm/gollections@v0.0.10/break/kv/loop/test/api_test.go (about)

     1  package test
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	breakkvloop "github.com/m4gshm/gollections/break/kv/loop"
    10  	"github.com/m4gshm/gollections/c"
    11  	"github.com/m4gshm/gollections/k"
    12  	kvloop "github.com/m4gshm/gollections/kv/loop"
    13  	"github.com/m4gshm/gollections/loop"
    14  	"github.com/m4gshm/gollections/op"
    15  	"github.com/m4gshm/gollections/slice"
    16  )
    17  
    18  func Test_HasAny(t *testing.T) {
    19  	kvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "one"), k.V(2, "two"), k.V(3, "three"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
    20  
    21  	result, _ := breakkvloop.HasAny(kvl, func(key int, val string) bool { return key == 2 })
    22  
    23  	assert.True(t, result)
    24  }
    25  
    26  func Test_HasAnyy(t *testing.T) {
    27  	kvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "one"), k.V(2, "two"), k.V(3, "three"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
    28  
    29  	result, _ := breakkvloop.HasAnyy(kvl, func(key int, val string) (bool, error) { return key == 2, nil })
    30  
    31  	assert.True(t, result)
    32  }
    33  
    34  func Test_Firstt(t *testing.T) {
    35  	kvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "one"), k.V(2, "two"), k.V(3, "three"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
    36  
    37  	k, v, ok, _ := breakkvloop.Firstt(kvl, func(key int, val string) (bool, error) { return key == 2 || val == "three", nil })
    38  
    39  	assert.True(t, ok)
    40  	assert.Equal(t, 2, k)
    41  	assert.Equal(t, "two", v)
    42  }
    43  
    44  func Test_Reduce(t *testing.T) {
    45  	kvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "one"), k.V(2, "two"), k.V(3, "three"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
    46  
    47  	k, v, _ := breakkvloop.Reduce(kvl, func(kl, kr int, vl, vr string) (int, string) { return kl + kr, vl + vr })
    48  
    49  	assert.Equal(t, 1+2+3, k)
    50  	assert.Equal(t, "one"+"two"+"three", v)
    51  }
    52  
    53  func Test_Reducee(t *testing.T) {
    54  	kvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "one"), k.V(2, "two"), k.V(3, "three"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
    55  
    56  	k, v, _ := breakkvloop.Reducee(kvl, func(kl, kr int, vl, vr string) (int, string, error) { return kl + kr, vl + vr, nil })
    57  
    58  	assert.Equal(t, 1+2+3, k)
    59  	assert.Equal(t, "one"+"two"+"three", v)
    60  }
    61  
    62  func Test_Convert(t *testing.T) {
    63  	kvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "1"), k.V(2, "2"), k.V(3, "3"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
    64  
    65  	out, _ := breakkvloop.ToSlice(breakkvloop.Convert(kvl, func(k int, v string) (int, string) { return k * k, v + v }).Next, k.V[int, string])
    66  
    67  	assert.Equal(t, slice.Of(k.V(1, "11"), k.V(4, "22"), k.V(9, "33")), out)
    68  }
    69  
    70  func Test_Conv(t *testing.T) {
    71  	kvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "1"), k.V(2, "2"), k.V(3, "3"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
    72  
    73  	out, _ := breakkvloop.ToSlice(breakkvloop.Conv(kvl, func(k int, v string) (int, string, error) { return k * k, v + v, nil }).Next, k.V[int, string])
    74  
    75  	assert.Equal(t, slice.Of(k.V(1, "11"), k.V(4, "22"), k.V(9, "33")), out)
    76  }
    77  
    78  func Test_Filter(t *testing.T) {
    79  	kvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "1"), k.V(2, "2"), k.V(3, "3"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
    80  
    81  	out, _ := breakkvloop.ToSlice(breakkvloop.Filter(kvl, func(key int, val string) bool { return key != 2 }).Next, k.V[int, string])
    82  
    83  	assert.Equal(t, slice.Of(k.V(1, "1"), k.V(3, "3")), out)
    84  }
    85  
    86  func Test_Filt(t *testing.T) {
    87  	kvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "1"), k.V(2, "2"), k.V(3, "3"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
    88  
    89  	out, _ := breakkvloop.ToSlice(breakkvloop.Filt(kvl, func(key int, val string) (bool, error) { return key != 2, nil }).Next, k.V[int, string])
    90  
    91  	assert.Equal(t, slice.Of(k.V(1, "1"), k.V(3, "3")), out)
    92  }
    93  
    94  func Test_Filt2(t *testing.T) {
    95  	kvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "1"), k.V(2, "2"), k.V(3, "3"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
    96  
    97  	out, err := breakkvloop.ToSlice(breakkvloop.Filt(kvl, func(key int, val string) (bool, error) {
    98  		ok := key <= 2
    99  		return ok, op.IfElse(key == 2, errors.New("abort"), nil)
   100  	}).Next, k.V[int, string])
   101  
   102  	assert.Error(t, err)
   103  	assert.Equal(t, slice.Of(k.V(1, "1"), k.V(2, "2")), out)
   104  }
   105  
   106  func Test_To(t *testing.T) {
   107  	bkvl := breakkvloop.From(loop.KeyValue(slice.NewIter(slice.Of(k.V(1, "1"), k.V(2, "2"), k.V(3, "3"))).Next, c.KV[int, string].Key, c.KV[int, string].Value).Next)
   108  
   109  	kvl := breakkvloop.To(bkvl, func(err error) { assert.NoError(t, err) })
   110  
   111  	out := kvloop.ToSlice(kvloop.Filter(kvl, func(key int, val string) bool { return key != 2 }).Next, k.V[int, string])
   112  
   113  	assert.Equal(t, slice.Of(k.V(1, "1"), k.V(3, "3")), out)
   114  }