Remove usage of unsafe from gkvlite

store_test.go

 package gkvlite
 
 import (
         "bytes"
         "errors"
         "fmt"
         "io"
         "io/ioutil"
         "math/rand"
         "os"
@@ skipping 1608 matching lines @@
         if m != 0 {
                 t.Errorf("expected 0 items, got: %v", m)
         }
 }
 
 func TestItemCopy(t *testing.T) {
         i := &Item{
                 Key:       []byte("hi"),
                 Val:       []byte("world"),
                 Priority:  1234,
-                Transient: unsafe.Pointer(&node{}),
+                Transient: &node{},
         }
         j := i.Copy()
         if !bytes.Equal(j.Key, i.Key) || !bytes.Equal(j.Val, i.Val) ||
                 j.Priority != i.Priority || j.Transient != i.Transient {
                 t.Errorf("expected item copy to work")
         }
 }
 
 func TestCurFreeNodes(t *testing.T) {
         s, err := NewStore(nil)
@@ skipping 42 matching lines @@
         loadCollection(x, []string{"e", "d", "a", "c", "b", "c", "a"})
         fmt.Printf("testing dump\n")
         dump(s, x.root.root, 1)
 }
 
 func TestStoreClose(t *testing.T) {
         s, err := NewStore(nil)
         if err != nil || s == nil {
                 t.Errorf("expected memory-only NewStore to work")
         }
-        if s.coll == unsafe.Pointer(nil) {
+        if s.coll == nil {
                 t.Errorf("expected coll before Close()")
         }
         s.Close()
-        if s.coll != unsafe.Pointer(nil) {
+        if s.coll != nil {
                 t.Errorf("expected no coll after Close()")
         }
         s.Close()
-        if s.coll != unsafe.Pointer(nil) {
+        if s.coll != nil {
                 t.Errorf("expected no coll after re-Close()")
         }
         s.Close()
-        if s.coll != unsafe.Pointer(nil) {
+        if s.coll != nil {
                 t.Errorf("expected no coll after re-Close()")
         }
 
         // Now, with a collection
         s, _ = NewStore(nil)
         s.SetCollection("x", bytes.Compare)
-        if s.coll == unsafe.Pointer(nil) {
+        if s.coll == nil {
                 t.Errorf("expected coll before Close()")
         }
         s.Close()
-        if s.coll != unsafe.Pointer(nil) {
+        if s.coll != nil {
                 t.Errorf("expected no coll after Close()")
         }
         s.Close()
-        if s.coll != unsafe.Pointer(nil) {
+        if s.coll != nil {
                 t.Errorf("expected no coll after Close()")
         }
 }
 
 func TestItemNumValBytes(t *testing.T) {
         var x *Collection
         var h *Item
         s, err := NewStoreEx(nil, StoreCallbacks{
                 ItemValLength: func(c *Collection, i *Item) int {
                         if c != x {
@@ skipping 471 matching lines @@
         x.SetItem(&Item{
                 Key:      []byte("a"),
                 Val:      []byte("aaa"),
                 Priority: 100,
         })
         s.Flush()
 
         readShouldErr = true
 
         rnl := x.rootAddRef()
-        rnl.root.node = unsafe.Pointer(nil) // Evict node from memory to force reading.
+        rnl.root.node = nil // Evict node from memory to force reading.
 
         _, _, _, _, err = numInfo(s, rnl.root, empty_nodeLoc)
         if err == nil {
                 t.Errorf("expected numInfo to error")
         }
         _, _, _, _, err = numInfo(s, empty_nodeLoc, rnl.root)
         if err == nil {
                 t.Errorf("expected numInfo to error")
         }
 }
@@ skipping 121 matching lines @@
                 Priority: 100,
         })
         rnl := x.rootAddRef()
 
         writeShouldErr = true
         if rnl.root.write(s) == nil {
                 t.Errorf("expected write node to fail")
         }
         writeShouldErr = false
 
-        rnl.root.node = unsafe.Pointer(nil) // Force a nil node.
+        rnl.root.node = nil // Force a nil node.
         if rnl.root.write(s) != nil {
                 t.Errorf("expected write node on nil node to work")
         }
 }
 
 func TestStoreRefCount(t *testing.T) {
         counts := map[string]int{}
         nadds := 0
         ndecs := 0
         s, err := NewStoreEx(nil, StoreCallbacks{
@@ skipping 436 matching lines @@
                         if err != nil {
                                 t.Fatalf("expected nil error, got: %v", err)
                         }
                 }
                 mustJustOneRef(fmt.Sprintf("i: %d", i))
         }
 }
 
 // perm returns a random permutation of n Int items in the range [0, n).
 func perm(n int) (out [][]byte) {
-    for _, v := range rand.Perm(n) {
-        out = append(out, []byte(strconv.Itoa(v)))
-    }
-    return out
+        for _, v := range rand.Perm(n) {
+                out = append(out, []byte(strconv.Itoa(v)))
+        }
+        return out
 }
 
 const benchmarkSize = 10000
 
 func BenchmarkRandInsert(b *testing.B) {
         b.StopTimer()
         insertP := perm(benchmarkSize)
         i := 0
         b.StartTimer()
         for i < b.N {
@@ skipping 51 matching lines @@
                 b.StartTimer()
                 for _, item := range removeP {
                         x.Get(item)
                         i++
                         if i >= b.N {
                                 return
                         }
                 }
         }
 }