github.com/onflow/flow-go@v0.33.17/fvm/storage/primary/intersect_test.go (about)

     1  package primary
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/require"
     7  
     8  	"github.com/onflow/flow-go/model/flow"
     9  )
    10  
    11  func TestIntersect(t *testing.T) {
    12  	check := func(
    13  		writeSet map[flow.RegisterID]flow.RegisterValue,
    14  		readSet map[flow.RegisterID]struct{},
    15  		expectedMatch bool,
    16  		expectedRegisterId flow.RegisterID) {
    17  
    18  		match, registerId := intersectHelper(writeSet, readSet)
    19  		require.Equal(t, match, expectedMatch)
    20  		if match {
    21  			require.Equal(t, expectedRegisterId, registerId)
    22  		}
    23  
    24  		match, registerId = intersectHelper(readSet, writeSet)
    25  		require.Equal(t, match, expectedMatch)
    26  		if match {
    27  			require.Equal(t, expectedRegisterId, registerId)
    28  		}
    29  
    30  		match, registerId = intersect(writeSet, readSet)
    31  		require.Equal(t, match, expectedMatch)
    32  		if match {
    33  			require.Equal(t, expectedRegisterId, registerId)
    34  		}
    35  
    36  		match, registerId = intersect(readSet, writeSet)
    37  		require.Equal(t, match, expectedMatch)
    38  		if match {
    39  			require.Equal(t, expectedRegisterId, registerId)
    40  		}
    41  	}
    42  
    43  	owner := "owner"
    44  	key1 := "key1"
    45  	key2 := "key2"
    46  
    47  	// set up readSet1 and writeSet1 such that len(readSet1) > len(writeSet1),
    48  	// and shares key1
    49  
    50  	readSet1 := map[flow.RegisterID]struct{}{
    51  		flow.RegisterID{
    52  			Owner: owner,
    53  			Key:   key1,
    54  		}: struct{}{},
    55  		flow.RegisterID{
    56  			Owner: "1",
    57  			Key:   "read 1",
    58  		}: struct{}{},
    59  		flow.RegisterID{
    60  			Owner: "1",
    61  			Key:   "read 2",
    62  		}: struct{}{},
    63  	}
    64  
    65  	writeSet1 := map[flow.RegisterID]flow.RegisterValue{
    66  		flow.RegisterID{
    67  			Owner: owner,
    68  			Key:   key1,
    69  		}: []byte("blah"),
    70  		flow.RegisterID{
    71  			Owner: "1",
    72  			Key:   "write",
    73  		}: []byte("blah"),
    74  	}
    75  
    76  	// set up readSet2 and writeSet2 such that len(readSet2) < len(writeSet2),
    77  	// shares key2, and not share keys with readSet1 / writeSet1
    78  
    79  	readSet2 := map[flow.RegisterID]struct{}{
    80  		flow.RegisterID{
    81  			Owner: owner,
    82  			Key:   key2,
    83  		}: struct{}{},
    84  	}
    85  
    86  	writeSet2 := map[flow.RegisterID]flow.RegisterValue{
    87  		flow.RegisterID{
    88  			Owner: owner,
    89  			Key:   key2,
    90  		}: []byte("blah"),
    91  		flow.RegisterID{
    92  			Owner: "2",
    93  			Key:   "write 1",
    94  		}: []byte("blah"),
    95  		flow.RegisterID{
    96  			Owner: "2",
    97  			Key:   "write 2",
    98  		}: []byte("blah"),
    99  		flow.RegisterID{
   100  			Owner: "2",
   101  			Key:   "write 3",
   102  		}: []byte("blah"),
   103  	}
   104  
   105  	check(writeSet1, readSet1, true, flow.RegisterID{Owner: owner, Key: key1})
   106  	check(writeSet2, readSet2, true, flow.RegisterID{Owner: owner, Key: key2})
   107  
   108  	check(writeSet1, readSet2, false, flow.RegisterID{})
   109  	check(writeSet2, readSet1, false, flow.RegisterID{})
   110  }