github.com/hslam/atomic@v1.0.0/atomic_test.go (about)

     1  // Copyright (c) 2020 Meng Huang (mhboy@outlook.com)
     2  // This package is licensed under a MIT license that can be found in the LICENSE file.
     3  
     4  package atomic
     5  
     6  import (
     7  	"testing"
     8  	"unsafe"
     9  )
    10  
    11  func TestAtomicInt32(t *testing.T) {
    12  	var v int32
    13  	StoreInt32(&v, 1)
    14  	if LoadInt32(&v) != 1 {
    15  		t.Log(LoadInt32(&v))
    16  	}
    17  	old := SwapInt32(&v, 2)
    18  	if old != 1 {
    19  		t.Log(LoadInt32(&v))
    20  	}
    21  	if AddInt32(&v, 1) != 3 {
    22  		t.Log(LoadInt32(&v))
    23  	}
    24  	if !CompareAndSwapInt32(&v, 3, 4) {
    25  		t.Log(LoadInt32(&v))
    26  	}
    27  	if CompareAndSwapInt32(&v, 3, 4) {
    28  		t.Log(LoadInt32(&v))
    29  	}
    30  }
    31  
    32  func TestAtomicInt64(t *testing.T) {
    33  	var v int64
    34  	StoreInt64(&v, 1)
    35  	if LoadInt64(&v) != 1 {
    36  		t.Log(LoadInt64(&v))
    37  	}
    38  	old := SwapInt64(&v, 2)
    39  	if old != 1 {
    40  		t.Log(LoadInt64(&v))
    41  	}
    42  	if AddInt64(&v, 1) != 3 {
    43  		t.Log(LoadInt64(&v))
    44  	}
    45  	if !CompareAndSwapInt64(&v, 3, 4) {
    46  		t.Log(LoadInt64(&v))
    47  	}
    48  	if CompareAndSwapInt64(&v, 3, 4) {
    49  		t.Log(LoadInt64(&v))
    50  	}
    51  }
    52  
    53  func TestAtomicUint32(t *testing.T) {
    54  	var v uint32
    55  	StoreUint32(&v, 1)
    56  	if LoadUint32(&v) != 1 {
    57  		t.Log(LoadUint32(&v))
    58  	}
    59  	old := SwapUint32(&v, 2)
    60  	if old != 1 {
    61  		t.Log(LoadUint32(&v))
    62  	}
    63  	if AddUint32(&v, 1) != 3 {
    64  		t.Log(LoadUint32(&v))
    65  	}
    66  	if !CompareAndSwapUint32(&v, 3, 4) {
    67  		t.Log(LoadUint32(&v))
    68  	}
    69  	if CompareAndSwapUint32(&v, 3, 4) {
    70  		t.Log(LoadUint32(&v))
    71  	}
    72  }
    73  
    74  func TestAtomicUint64(t *testing.T) {
    75  	var v uint64
    76  	StoreUint64(&v, 1)
    77  	if LoadUint64(&v) != 1 {
    78  		t.Log(LoadUint64(&v))
    79  	}
    80  	old := SwapUint64(&v, 2)
    81  	if old != 1 {
    82  		t.Log(LoadUint64(&v))
    83  	}
    84  	if AddUint64(&v, 1) != 3 {
    85  		t.Log(LoadUint64(&v))
    86  	}
    87  	if !CompareAndSwapUint64(&v, 3, 4) {
    88  		t.Log(LoadUint64(&v))
    89  	}
    90  	if CompareAndSwapUint64(&v, 3, 4) {
    91  		t.Log(LoadUint64(&v))
    92  	}
    93  }
    94  
    95  func TestAtomicUintptr(t *testing.T) {
    96  	var v uintptr
    97  	StoreUintptr(&v, 1)
    98  	if LoadUintptr(&v) != 1 {
    99  		t.Log(LoadUintptr(&v))
   100  	}
   101  	old := SwapUintptr(&v, 2)
   102  	if old != 1 {
   103  		t.Log(LoadUintptr(&v))
   104  	}
   105  	if AddUintptr(&v, 1) != 3 {
   106  		t.Log(LoadUintptr(&v))
   107  	}
   108  	if !CompareAndSwapUintptr(&v, 3, 4) {
   109  		t.Log(LoadUintptr(&v))
   110  	}
   111  	if CompareAndSwapUintptr(&v, 3, 4) {
   112  		t.Log(LoadUintptr(&v))
   113  	}
   114  }
   115  
   116  func TestAtomicPointer(t *testing.T) {
   117  	var v string
   118  	var vp = unsafe.Pointer(&v)
   119  	var v1 = "Hello World"
   120  	var vp1 = unsafe.Pointer(&v1)
   121  	StorePointer(&vp, vp1)
   122  	if LoadPointer(&vp) != vp1 {
   123  		t.Log(LoadPointer(&vp))
   124  	}
   125  	var v2 = "Foo"
   126  	var vp2 = unsafe.Pointer(&v2)
   127  	old := SwapPointer(&vp, vp2)
   128  	if old != vp1 {
   129  		t.Log(LoadPointer(&vp))
   130  	}
   131  	var v3 = "Bar"
   132  	var vp3 = unsafe.Pointer(&v3)
   133  	if !CompareAndSwapPointer(&vp, vp2, vp3) {
   134  		t.Log(LoadPointer(&vp))
   135  	}
   136  	if CompareAndSwapPointer(&vp, vp2, vp3) {
   137  		t.Log(LoadPointer(&vp))
   138  	}
   139  }