github.com/ipld/go-ipld-prime@v0.21.0/datamodel/equal_test.go (about)

     1  package datamodel_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/ipfs/go-cid"
     7  	"github.com/ipld/go-ipld-prime/datamodel"
     8  	"github.com/ipld/go-ipld-prime/fluent/qp"
     9  	cidlink "github.com/ipld/go-ipld-prime/linking/cid"
    10  	basic "github.com/ipld/go-ipld-prime/node/basicnode" // shorter name for the tests
    11  )
    12  
    13  var (
    14  	globalNode = basic.NewString("global")
    15  	globalLink = func() datamodel.Link {
    16  		someCid, _ := cid.Cast([]byte{1, 85, 0, 5, 0, 1, 2, 3, 4})
    17  		return cidlink.Link{Cid: someCid}
    18  	}()
    19  	globalLink2 = func() datamodel.Link {
    20  		someCid, _ := cid.Cast([]byte{1, 85, 0, 5, 0, 5, 6, 7, 8})
    21  		return cidlink.Link{Cid: someCid}
    22  	}()
    23  )
    24  
    25  func qpMust(node datamodel.Node, err error) datamodel.Node {
    26  	if err != nil {
    27  		panic(err)
    28  	}
    29  	return node
    30  }
    31  
    32  var deepEqualTests = []struct {
    33  	name        string
    34  	left, right datamodel.Node
    35  	want        bool
    36  }{
    37  	{"MismatchingKinds", basic.NewBool(true), basic.NewInt(3), false},
    38  
    39  	{"SameNodeSamePointer", globalNode, globalNode, true},
    40  	// Repeated basicnode.New invocations might return different pointers.
    41  	{"SameNodeDiffPointer", basic.NewString("same"), basic.NewString("same"), true},
    42  
    43  	{"NilVsNil", nil, nil, true},
    44  	{"NilVsNull", nil, datamodel.Null, false},
    45  	{"SameKindNull", datamodel.Null, datamodel.Null, true},
    46  	{"DiffKindNull", datamodel.Null, datamodel.Absent, false},
    47  	{"SameKindBool", basic.NewBool(true), basic.NewBool(true), true},
    48  	{"DiffKindBool", basic.NewBool(true), basic.NewBool(false), false},
    49  	{"SameKindInt", basic.NewInt(12), basic.NewInt(12), true},
    50  	{"DiffKindInt", basic.NewInt(12), basic.NewInt(15), false},
    51  	{"SameKindFloat", basic.NewFloat(1.25), basic.NewFloat(1.25), true},
    52  	{"DiffKindFloat", basic.NewFloat(1.25), basic.NewFloat(1.75), false},
    53  	{"SameKindString", basic.NewString("foobar"), basic.NewString("foobar"), true},
    54  	{"DiffKindString", basic.NewString("foobar"), basic.NewString("baz"), false},
    55  	{"SameKindBytes", basic.NewBytes([]byte{5, 2, 3}), basic.NewBytes([]byte{5, 2, 3}), true},
    56  	{"DiffKindBytes", basic.NewBytes([]byte{5, 2, 3}), basic.NewBytes([]byte{5, 8, 3}), false},
    57  	{"SameKindLink", basic.NewLink(globalLink), basic.NewLink(globalLink), true},
    58  	{"DiffKindLink", basic.NewLink(globalLink), basic.NewLink(globalLink2), false},
    59  
    60  	{
    61  		"SameKindList",
    62  		qpMust(qp.BuildList(basic.Prototype.Any, -1, func(am datamodel.ListAssembler) {
    63  			qp.ListEntry(am, qp.Int(7))
    64  			qp.ListEntry(am, qp.Int(8))
    65  		})),
    66  		qpMust(qp.BuildList(basic.Prototype.Any, -1, func(am datamodel.ListAssembler) {
    67  			qp.ListEntry(am, qp.Int(7))
    68  			qp.ListEntry(am, qp.Int(8))
    69  		})),
    70  		true,
    71  	},
    72  	{
    73  		"DiffKindList_length",
    74  		qpMust(qp.BuildList(basic.Prototype.Any, -1, func(am datamodel.ListAssembler) {
    75  			qp.ListEntry(am, qp.Int(7))
    76  			qp.ListEntry(am, qp.Int(8))
    77  		})),
    78  		qpMust(qp.BuildList(basic.Prototype.Any, -1, func(am datamodel.ListAssembler) {
    79  			qp.ListEntry(am, qp.Int(7))
    80  		})),
    81  		false,
    82  	},
    83  	{
    84  		"DiffKindList_elems",
    85  		qpMust(qp.BuildList(basic.Prototype.Any, -1, func(am datamodel.ListAssembler) {
    86  			qp.ListEntry(am, qp.Int(7))
    87  			qp.ListEntry(am, qp.Int(8))
    88  		})),
    89  		qpMust(qp.BuildList(basic.Prototype.Any, -1, func(am datamodel.ListAssembler) {
    90  			qp.ListEntry(am, qp.Int(3))
    91  			qp.ListEntry(am, qp.Int(2))
    92  		})),
    93  		false,
    94  	},
    95  
    96  	{
    97  		"SameKindMap",
    98  		qpMust(qp.BuildMap(basic.Prototype.Any, -1, func(am datamodel.MapAssembler) {
    99  			qp.MapEntry(am, "foo", qp.Int(7))
   100  			qp.MapEntry(am, "bar", qp.Int(8))
   101  		})),
   102  		qpMust(qp.BuildMap(basic.Prototype.Any, -1, func(am datamodel.MapAssembler) {
   103  			qp.MapEntry(am, "foo", qp.Int(7))
   104  			qp.MapEntry(am, "bar", qp.Int(8))
   105  		})),
   106  		true,
   107  	},
   108  	{
   109  		"DiffKindMap_length",
   110  		qpMust(qp.BuildMap(basic.Prototype.Any, -1, func(am datamodel.MapAssembler) {
   111  			qp.MapEntry(am, "foo", qp.Int(7))
   112  			qp.MapEntry(am, "bar", qp.Int(8))
   113  		})),
   114  		qpMust(qp.BuildMap(basic.Prototype.Any, -1, func(am datamodel.MapAssembler) {
   115  			qp.MapEntry(am, "foo", qp.Int(7))
   116  		})),
   117  		false,
   118  	},
   119  	{
   120  		"DiffKindMap_elems",
   121  		qpMust(qp.BuildMap(basic.Prototype.Any, -1, func(am datamodel.MapAssembler) {
   122  			qp.MapEntry(am, "foo", qp.Int(7))
   123  			qp.MapEntry(am, "bar", qp.Int(8))
   124  		})),
   125  		qpMust(qp.BuildMap(basic.Prototype.Any, -1, func(am datamodel.MapAssembler) {
   126  			qp.MapEntry(am, "foo", qp.Int(3))
   127  			qp.MapEntry(am, "baz", qp.Int(8))
   128  		})),
   129  		false,
   130  	},
   131  
   132  	// TODO: tests involving different implementations, once bindnode is ready
   133  
   134  }
   135  
   136  func TestDeepEqual(t *testing.T) {
   137  	t.Parallel()
   138  	for _, tc := range deepEqualTests {
   139  		tc := tc // capture range variable
   140  		t.Run(tc.name, func(t *testing.T) {
   141  			t.Parallel()
   142  
   143  			got := datamodel.DeepEqual(tc.left, tc.right)
   144  			if got != tc.want {
   145  				t.Fatalf("DeepEqual got %v, want %v", got, tc.want)
   146  			}
   147  		})
   148  	}
   149  }