github.com/ndau/noms@v1.0.5/go/types/walk_refs_test.go (about)

     1  // Copyright 2016 Attic Labs, Inc. All rights reserved.
     2  // Licensed under the Apache License, version 2.0:
     3  // http://www.apache.org/licenses/LICENSE-2.0
     4  
     5  package types
     6  
     7  import (
     8  	"bytes"
     9  	"io"
    10  	"math/rand"
    11  	"testing"
    12  
    13  	"github.com/ndau/noms/go/hash"
    14  	"github.com/stretchr/testify/assert"
    15  )
    16  
    17  func TestWalkRefs(t *testing.T) {
    18  	runTest := func(v Value, t *testing.T) {
    19  		assert := assert.New(t)
    20  		expected := hash.HashSlice{}
    21  		v.WalkRefs(func(r Ref) {
    22  			expected = append(expected, r.TargetHash())
    23  		})
    24  		WalkRefs(EncodeValue(v), func(r Ref) {
    25  			if assert.True(len(expected) > 0) {
    26  				assert.Equal(expected[0], r.TargetHash())
    27  				expected = expected[1:]
    28  			}
    29  		})
    30  		assert.Len(expected, 0)
    31  	}
    32  
    33  	t.Run("SingleRef", func(t *testing.T) {
    34  		t.Parallel()
    35  		t.Run("Typed", func(t *testing.T) {
    36  			vrw := newTestValueStore()
    37  			s := NewStruct("", StructData{"n": Number(1)})
    38  			runTest(NewRef(NewMap(vrw, s, Number(2))), t)
    39  		})
    40  		t.Run("OfValue", func(t *testing.T) {
    41  			runTest(ToRefOfValue(NewRef(Bool(false))), t)
    42  		})
    43  	})
    44  
    45  	t.Run("Struct", func(t *testing.T) {
    46  		t.Parallel()
    47  		data := StructData{
    48  			"ref": NewRef(Bool(false)),
    49  			"num": Number(42),
    50  		}
    51  		runTest(NewStruct("nom", data), t)
    52  	})
    53  
    54  	// must return a slice with an even number of elements
    55  	newValueSlice := func(r *rand.Rand) ValueSlice {
    56  		vs := make(ValueSlice, 256)
    57  		for i := range vs {
    58  			vs[i] = NewStruct("", StructData{"n": Number(r.Uint64())})
    59  		}
    60  		return vs
    61  	}
    62  
    63  	t.Run("List", func(t *testing.T) {
    64  		t.Parallel()
    65  		vrw := newTestValueStore()
    66  		r := rand.New(rand.NewSource(0))
    67  
    68  		t.Run("OfRefs", func(t *testing.T) {
    69  			l := NewList(vrw, vrw.WriteValue(Number(42)), vrw.WriteValue(Number(0)))
    70  			runTest(l, t)
    71  		})
    72  
    73  		t.Run("Chunked", func(t *testing.T) {
    74  			l := NewList(vrw, newValueSlice(r)...)
    75  			for l.sequence.isLeaf() {
    76  				l = l.Concat(NewList(vrw, newValueSlice(r)...))
    77  			}
    78  			runTest(l, t)
    79  		})
    80  	})
    81  
    82  	t.Run("Set", func(t *testing.T) {
    83  		t.Parallel()
    84  		vrw := newTestValueStore()
    85  		r := rand.New(rand.NewSource(0))
    86  
    87  		t.Run("OfRefs", func(t *testing.T) {
    88  			s := NewSet(vrw, vrw.WriteValue(Number(42)), vrw.WriteValue(Number(0)))
    89  			runTest(s, t)
    90  		})
    91  
    92  		t.Run("Chunked", func(t *testing.T) {
    93  			s := NewSet(vrw, newValueSlice(r)...)
    94  			for s.isLeaf() {
    95  				e := s.Edit()
    96  				e = e.Insert(newValueSlice(r)...)
    97  				s = e.Set()
    98  			}
    99  			runTest(s, t)
   100  		})
   101  	})
   102  
   103  	t.Run("Map", func(t *testing.T) {
   104  		t.Parallel()
   105  		vrw := newTestValueStore()
   106  		r := rand.New(rand.NewSource(0))
   107  
   108  		t.Run("OfRefs", func(t *testing.T) {
   109  			m := NewMap(vrw, vrw.WriteValue(Number(42)), vrw.WriteValue(Number(0)))
   110  			runTest(m, t)
   111  		})
   112  
   113  		t.Run("Chunked", func(t *testing.T) {
   114  			m := NewMap(vrw, newValueSlice(r)...)
   115  			for m.isLeaf() {
   116  				e := m.Edit()
   117  				vs := newValueSlice(r)
   118  				for i := 0; i < len(vs); i += 2 {
   119  					e = e.Set(vs[i], vs[i+1])
   120  				}
   121  				m = e.Map()
   122  			}
   123  			runTest(m, t)
   124  		})
   125  	})
   126  
   127  	t.Run("Blob", func(t *testing.T) {
   128  		t.Parallel()
   129  		vrw := newTestValueStore()
   130  		r := rand.New(rand.NewSource(0))
   131  
   132  		scratch := make([]byte, 1024)
   133  		freshRandomBytes := func() io.Reader {
   134  			r.Read(scratch)
   135  			return bytes.NewReader(scratch)
   136  		}
   137  		b := NewBlob(vrw, freshRandomBytes())
   138  		for b.sequence.isLeaf() {
   139  			b = b.Concat(NewBlob(vrw, freshRandomBytes()))
   140  		}
   141  		runTest(b, t)
   142  	})
   143  }