github.com/mitranim/gg@v0.1.17/sync_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  // Placeholder, needs a concurrency test.
    11  func TestAtom(t *testing.T) {
    12  	defer gtest.Catch(t)
    13  
    14  	var ref gg.Atom[string]
    15  	gtest.Zero(ref.Load())
    16  	gtest.Eq(
    17  		gg.Tuple2(ref.Loaded()),
    18  		gg.Tuple2(``, false),
    19  	)
    20  
    21  	ref.Store(``)
    22  	gtest.Zero(ref.Load())
    23  	gtest.Eq(
    24  		gg.Tuple2(ref.Loaded()),
    25  		gg.Tuple2(``, true),
    26  	)
    27  
    28  	ref.Store(`one`)
    29  	gtest.Eq(ref.Load(), `one`)
    30  	gtest.Eq(
    31  		gg.Tuple2(ref.Loaded()),
    32  		gg.Tuple2(`one`, true),
    33  	)
    34  
    35  	gtest.False(ref.CompareAndSwap(`three`, `two`))
    36  	gtest.Eq(ref.Load(), `one`)
    37  
    38  	gtest.True(ref.CompareAndSwap(`one`, `two`))
    39  	gtest.Eq(ref.Load(), `two`)
    40  }
    41  
    42  func BenchmarkAtom_Store(b *testing.B) {
    43  	var ref gg.Atom[string]
    44  
    45  	for ind := 0; ind < b.N; ind++ {
    46  		ref.Store(`str`)
    47  	}
    48  }
    49  
    50  func BenchmarkAtom_Load(b *testing.B) {
    51  	var ref gg.Atom[string]
    52  	ref.Store(`str`)
    53  
    54  	for ind := 0; ind < b.N; ind++ {
    55  		gg.Nop1(ref.Load())
    56  	}
    57  }
    58  
    59  func TestChanInit(t *testing.T) {
    60  	defer gtest.Catch(t)
    61  
    62  	gg.ChanInit((*chan string)(nil))
    63  
    64  	var tar chan string
    65  	gtest.Eq(gg.ChanInit(&tar), tar)
    66  
    67  	gtest.NotZero(tar)
    68  	gtest.Eq(cap(tar), 0)
    69  
    70  	prev := tar
    71  	gtest.Eq(gg.ChanInit(&tar), prev)
    72  	gtest.Eq(tar, prev)
    73  }
    74  
    75  func TestChanInitCap(t *testing.T) {
    76  	defer gtest.Catch(t)
    77  
    78  	gg.ChanInitCap((*chan string)(nil), 1)
    79  
    80  	var tar chan string
    81  	gtest.Eq(gg.ChanInitCap(&tar, 3), tar)
    82  
    83  	gtest.NotZero(tar)
    84  	gtest.Eq(cap(tar), 3)
    85  
    86  	prev := tar
    87  	gtest.Eq(gg.ChanInitCap(&tar, 5), prev)
    88  	gtest.Eq(tar, prev)
    89  	gtest.Eq(cap(prev), 3)
    90  	gtest.Eq(cap(tar), 3)
    91  }
    92  
    93  func TestSendOpt(t *testing.T) {
    94  	defer gtest.Catch(t)
    95  
    96  	var tar chan string
    97  	gg.SendOpt(tar, `val`)
    98  	gg.SendOpt(tar, `val`)
    99  	gg.SendOpt(tar, `val`)
   100  
   101  	tar = make(chan string, 1)
   102  	gg.SendOpt(tar, `val`)
   103  	gg.SendOpt(tar, `val`)
   104  	gg.SendOpt(tar, `val`)
   105  
   106  	gtest.Eq(<-tar, `val`)
   107  }
   108  
   109  func TestSendZeroOpt(t *testing.T) {
   110  	defer gtest.Catch(t)
   111  
   112  	var tar chan string
   113  	gg.SendZeroOpt(tar)
   114  	gg.SendZeroOpt(tar)
   115  	gg.SendZeroOpt(tar)
   116  
   117  	tar = make(chan string, 1)
   118  	gg.SendZeroOpt(tar)
   119  	gg.SendZeroOpt(tar)
   120  	gg.SendZeroOpt(tar)
   121  
   122  	val, ok := <-tar
   123  	gtest.Zero(val)
   124  	gtest.True(ok)
   125  }