gorgonia.org/gorgonia@v0.9.17/collections_test.go (about)

     1  package gorgonia
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  func TestNodes(t *testing.T) {
    11  	assert := assert.New(t)
    12  	g := NewGraph()
    13  	n0 := newNode(In(g), WithName("n0"))
    14  	n1 := newNode(In(g), WithName("n1"))
    15  	n2 := newNode(In(g), WithName("n2"))
    16  	n3 := newNode(In(g), WithName("n3"))
    17  
    18  	// calculate hashcode first
    19  	n0h := n0.Hashcode()
    20  	n1h := n1.Hashcode()
    21  	n2h := n2.Hashcode()
    22  	n3h := n3.Hashcode()
    23  	t.Logf("%x, %x, %x, %x", n0h, n1h, n2h, n3h)
    24  
    25  	set := Nodes{n0, n1, n2, n3, n0, n0}
    26  
    27  	set = set.Set()
    28  	correct := Nodes{n0, n1, n2, n3}
    29  	for _, n := range correct {
    30  		assert.Contains(set, n, "SET: %v", set)
    31  	}
    32  	assert.Equal(len(correct), len(set))
    33  
    34  	t.Log("Test add")
    35  	set = Nodes{}
    36  	set = set.Add(n0)
    37  	set = set.Add(n2)
    38  	set = set.Add(n0)
    39  	set = set.Add(n3)
    40  	set = set.Add(n1)
    41  	correct = Nodes{n0, n2, n3, n1}
    42  	assert.Equal(correct, set)
    43  
    44  	t.Log("Testing intersection")
    45  	set = Nodes{n0, n2, n1, n3} // out of order, on purpose
    46  	other := Nodes{n0, n1}
    47  	inter := set.Intersect(other)
    48  
    49  	correct = Nodes{n0, n1}
    50  	for _, n := range correct {
    51  		assert.Contains(inter, n, "inter: %v", inter)
    52  	}
    53  	assert.Equal(len(correct), len(inter))
    54  
    55  	t.Log("Testing difference")
    56  	n4 := newNode(In(g))
    57  	n5 := newNode(In(g))
    58  	set = Nodes{n3, n0, n1, n2}
    59  	other = Nodes{n0, n3, n4, n5}
    60  
    61  	diff := set.Difference(other)
    62  	correct = Nodes{n1, n2}
    63  	for _, n := range correct {
    64  		assert.Contains(diff, n)
    65  	}
    66  	assert.Equal(len(correct), len(diff))
    67  
    68  	t.Log("Testing replace")
    69  	set = Nodes{n0, n2, n1, n2, n1} // not yet a set
    70  	set = set.replace(n2, n3)
    71  	correct = Nodes{n0, n3, n1, n3, n1}
    72  	assert.Equal(correct, set)
    73  
    74  	t.Log("Formatting")
    75  	formats := []string{"% v", "%+v", "%d", "%v", "%#v", "%Y", "%P"}
    76  	correctFormats := []string{
    77  		"[n0  n1  n2  n3]",
    78  		`[n0, 
    79  n1, 
    80  n2, 
    81  n3]`,
    82  		fmt.Sprintf("[%x, %x, %x, %x]", n0.id, n1.id, n2.id, n3.id),
    83  		"[n0, n1, n2, n3]",
    84  		"[n0 :: <nil>, n1 :: <nil>, n2 :: <nil>, n3 :: <nil>]",
    85  		"[<nil>, <nil>, <nil>, <nil>]",
    86  		fmt.Sprintf("[%p, %p, %p, %p]", n0, n1, n2, n3),
    87  	}
    88  
    89  	set = Nodes{n0, n1, n2, n3}
    90  	for i, f := range formats {
    91  		s := fmt.Sprintf(f, set)
    92  		if s != correctFormats[i] {
    93  			t.Errorf("Format %q. Expected %q. Got %q", f, correctFormats[i], s)
    94  		}
    95  	}
    96  
    97  	// corner cases
    98  	set = Nodes{}
    99  	if set.AllSameGraph() {
   100  		t.Error("Empty list of nodes cannot be of the same graph!")
   101  	}
   102  
   103  	nAbnormal := newNode(In(NewGraph()))
   104  	set = Nodes{n0, n1, nAbnormal, n2}
   105  	if set.AllSameGraph() {
   106  		t.Error("One node is in a different graph! This should have returned false")
   107  	}
   108  }