You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
665 lines
16 KiB
665 lines
16 KiB
package gg
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
. "testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func edge(val Value, from *Vertex) Edge {
|
|
return Edge{Value: val, From: from}
|
|
}
|
|
|
|
func value(val Value, in ...Edge) *Vertex {
|
|
return &Vertex{
|
|
VertexType: ValueVertex,
|
|
Value: val,
|
|
In: in,
|
|
}
|
|
}
|
|
|
|
func tuple(val Value, in ...Edge) Edge {
|
|
return Edge{
|
|
From: &Vertex{
|
|
VertexType: TupleVertex,
|
|
In: in,
|
|
},
|
|
Value: val,
|
|
}
|
|
}
|
|
|
|
func assertVertexEqual(t *T, exp, got *Vertex, msgAndArgs ...interface{}) bool {
|
|
var assertInner func(*Vertex, *Vertex, map[*Vertex]bool) bool
|
|
assertInner = func(exp, got *Vertex, m map[*Vertex]bool) bool {
|
|
// if got is already in m then we've already looked at it
|
|
if m[got] {
|
|
return true
|
|
}
|
|
m[got] = true
|
|
|
|
assert.Equal(t, exp.VertexType, got.VertexType, msgAndArgs...)
|
|
assert.Equal(t, exp.Value, got.Value, msgAndArgs...)
|
|
if !assert.Len(t, got.In, len(exp.In), msgAndArgs...) {
|
|
return false
|
|
}
|
|
for i := range exp.In {
|
|
assertInner(exp.In[i].From, got.In[i].From, m)
|
|
assert.Equal(t, exp.In[i].Value, got.In[i].Value, msgAndArgs...)
|
|
assert.Equal(t, got, got.In[i].To)
|
|
assert.Contains(t, got.In[i].From.Out, got.In[i])
|
|
}
|
|
return true
|
|
|
|
}
|
|
return assertInner(exp, got, map[*Vertex]bool{})
|
|
}
|
|
|
|
func assertIter(t *T, expVals, expJuncs int, g *Graph, msgAndArgs ...interface{}) {
|
|
seen := map[*Vertex]bool{}
|
|
var gotVals, gotJuncs int
|
|
g.Iter(func(v *Vertex) bool {
|
|
assert.NotContains(t, seen, v, msgAndArgs...)
|
|
seen[v] = true
|
|
if v.VertexType == ValueVertex {
|
|
gotVals++
|
|
} else {
|
|
gotJuncs++
|
|
}
|
|
return true
|
|
})
|
|
assert.Equal(t, expVals, gotVals, msgAndArgs...)
|
|
assert.Equal(t, expJuncs, gotJuncs, msgAndArgs...)
|
|
}
|
|
|
|
type graphTest struct {
|
|
name string
|
|
out func() *Graph
|
|
exp []*Vertex
|
|
numVals, numJuncs int
|
|
}
|
|
|
|
func mkTest(name string, out func() *Graph, numVals, numJuncs int, exp ...*Vertex) graphTest {
|
|
return graphTest{
|
|
name: name,
|
|
out: out,
|
|
exp: exp,
|
|
numVals: numVals, numJuncs: numJuncs,
|
|
}
|
|
}
|
|
|
|
func TestGraph(t *T) {
|
|
var (
|
|
v0 = NewValue("v0")
|
|
v1 = NewValue("v1")
|
|
v2 = NewValue("v2")
|
|
v3 = NewValue("v3")
|
|
e0 = NewValue("e0")
|
|
e00 = NewValue("e00")
|
|
e01 = NewValue("e01")
|
|
e1 = NewValue("e1")
|
|
e10 = NewValue("e10")
|
|
e11 = NewValue("e11")
|
|
e2 = NewValue("e2")
|
|
e20 = NewValue("e20")
|
|
e21 = NewValue("e21")
|
|
ej0 = NewValue("ej0")
|
|
ej1 = NewValue("ej1")
|
|
ej2 = NewValue("ej2")
|
|
)
|
|
tests := []graphTest{
|
|
mkTest(
|
|
"values-basic",
|
|
func() *Graph {
|
|
return ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
|
|
},
|
|
2, 0,
|
|
value(v0),
|
|
value(v1, edge(e0, value(v0))),
|
|
),
|
|
|
|
mkTest(
|
|
"values-2edges",
|
|
func() *Graph {
|
|
g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v2)
|
|
return g0.AddValueIn(ValueOut(v1, e1), v2)
|
|
},
|
|
3, 0,
|
|
value(v0),
|
|
value(v1),
|
|
value(v2,
|
|
edge(e0, value(v0)),
|
|
edge(e1, value(v1)),
|
|
),
|
|
),
|
|
|
|
mkTest(
|
|
"values-separate",
|
|
func() *Graph {
|
|
g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
|
|
return g0.AddValueIn(ValueOut(v2, e2), v3)
|
|
},
|
|
4, 0,
|
|
value(v0),
|
|
value(v1, edge(e0, value(v0))),
|
|
value(v2),
|
|
value(v3, edge(e2, value(v2))),
|
|
),
|
|
|
|
mkTest(
|
|
"values-circular",
|
|
func() *Graph {
|
|
return ZeroGraph.AddValueIn(ValueOut(v0, e0), v0)
|
|
},
|
|
1, 0,
|
|
value(v0, edge(e0, value(v0))),
|
|
),
|
|
|
|
mkTest(
|
|
"values-circular2",
|
|
func() *Graph {
|
|
g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
|
|
return g0.AddValueIn(ValueOut(v1, e1), v0)
|
|
},
|
|
2, 0,
|
|
value(v0, edge(e1, value(v1, edge(e0, value(v0))))),
|
|
value(v1, edge(e0, value(v0, edge(e1, value(v1))))),
|
|
),
|
|
|
|
mkTest(
|
|
"values-circular3",
|
|
func() *Graph {
|
|
g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
|
|
g1 := g0.AddValueIn(ValueOut(v1, e1), v2)
|
|
return g1.AddValueIn(ValueOut(v2, e2), v1)
|
|
},
|
|
3, 0,
|
|
value(v0),
|
|
value(v1,
|
|
edge(e0, value(v0)),
|
|
edge(e2, value(v2, edge(e1, value(v1)))),
|
|
),
|
|
value(v2, edge(e1, value(v1,
|
|
edge(e0, value(v0)),
|
|
edge(e2, value(v2)),
|
|
))),
|
|
),
|
|
|
|
mkTest(
|
|
"tuple-basic",
|
|
func() *Graph {
|
|
e0 := ValueOut(v0, e0)
|
|
e1 := ValueOut(v1, e1)
|
|
ej0 := TupleOut([]OpenEdge{e0, e1}, ej0)
|
|
return ZeroGraph.AddValueIn(ej0, v2)
|
|
},
|
|
3, 1,
|
|
value(v0), value(v1),
|
|
value(v2, tuple(ej0,
|
|
edge(e0, value(v0)),
|
|
edge(e1, value(v1)),
|
|
)),
|
|
),
|
|
|
|
mkTest(
|
|
"tuple-basic2",
|
|
func() *Graph {
|
|
e00 := ValueOut(v0, e00)
|
|
e10 := ValueOut(v1, e10)
|
|
ej0 := TupleOut([]OpenEdge{e00, e10}, ej0)
|
|
e01 := ValueOut(v0, e01)
|
|
e11 := ValueOut(v1, e11)
|
|
ej1 := TupleOut([]OpenEdge{e01, e11}, ej1)
|
|
ej2 := TupleOut([]OpenEdge{ej0, ej1}, ej2)
|
|
return ZeroGraph.AddValueIn(ej2, v2)
|
|
},
|
|
3, 3,
|
|
value(v0), value(v1),
|
|
value(v2, tuple(ej2,
|
|
tuple(ej0,
|
|
edge(e00, value(v0)),
|
|
edge(e10, value(v1)),
|
|
),
|
|
tuple(ej1,
|
|
edge(e01, value(v0)),
|
|
edge(e11, value(v1)),
|
|
),
|
|
)),
|
|
),
|
|
|
|
mkTest(
|
|
"tuple-circular",
|
|
func() *Graph {
|
|
e0 := ValueOut(v0, e0)
|
|
e1 := ValueOut(v1, e1)
|
|
ej0 := TupleOut([]OpenEdge{e0, e1}, ej0)
|
|
g0 := ZeroGraph.AddValueIn(ej0, v2)
|
|
e20 := ValueOut(v2, e20)
|
|
g1 := g0.AddValueIn(e20, v0)
|
|
e21 := ValueOut(v2, e21)
|
|
return g1.AddValueIn(e21, v1)
|
|
},
|
|
3, 1,
|
|
value(v0, edge(e20, value(v2, tuple(ej0,
|
|
edge(e0, value(v0)),
|
|
edge(e1, value(v1, edge(e21, value(v2)))),
|
|
)))),
|
|
value(v1, edge(e21, value(v2, tuple(ej0,
|
|
edge(e0, value(v0, edge(e20, value(v2)))),
|
|
edge(e1, value(v1)),
|
|
)))),
|
|
value(v2, tuple(ej0,
|
|
edge(e0, value(v0, edge(e20, value(v2)))),
|
|
edge(e1, value(v1, edge(e21, value(v2)))),
|
|
)),
|
|
),
|
|
}
|
|
|
|
for i := range tests {
|
|
t.Logf("test[%d]:%q", i, tests[i].name)
|
|
out := tests[i].out()
|
|
for j, exp := range tests[i].exp {
|
|
msgAndArgs := []interface{}{
|
|
"tests[%d].name:%q exp[%d].val:%q",
|
|
i, tests[i].name, j, exp.Value.V.(string),
|
|
}
|
|
v := out.ValueVertex(exp.Value)
|
|
if !assert.NotNil(t, v, msgAndArgs...) {
|
|
continue
|
|
}
|
|
assertVertexEqual(t, exp, v, msgAndArgs...)
|
|
}
|
|
|
|
msgAndArgs := []interface{}{
|
|
"tests[%d].name:%q",
|
|
i, tests[i].name,
|
|
}
|
|
|
|
// sanity check that graphs are equal to themselves
|
|
assert.True(t, Equal(out, out), msgAndArgs...)
|
|
|
|
// test the Iter method in here too
|
|
assertIter(t, tests[i].numVals, tests[i].numJuncs, out, msgAndArgs...)
|
|
}
|
|
}
|
|
|
|
func TestGraphImmutability(t *T) {
|
|
v0 := NewValue("v0")
|
|
v1 := NewValue("v1")
|
|
e0 := NewValue("e0")
|
|
oe0 := ValueOut(v0, e0)
|
|
g0 := ZeroGraph.AddValueIn(oe0, v1)
|
|
assert.Nil(t, ZeroGraph.ValueVertex(v0))
|
|
assert.Nil(t, ZeroGraph.ValueVertex(v1))
|
|
assert.NotNil(t, g0.ValueVertex(v0))
|
|
assert.NotNil(t, g0.ValueVertex(v1))
|
|
|
|
// half-edges should be re-usable
|
|
v2 := NewValue("v2")
|
|
v3a, v3b := NewValue("v3a"), NewValue("v3b")
|
|
e1 := NewValue("e1")
|
|
oe1 := ValueOut(v2, e1)
|
|
g1a := g0.AddValueIn(oe1, v3a)
|
|
g1b := g0.AddValueIn(oe1, v3b)
|
|
assertVertexEqual(t, value(v3a, edge(e1, value(v2))), g1a.ValueVertex(v3a))
|
|
assert.Nil(t, g1a.ValueVertex(v3b))
|
|
assertVertexEqual(t, value(v3b, edge(e1, value(v2))), g1b.ValueVertex(v3b))
|
|
assert.Nil(t, g1b.ValueVertex(v3a))
|
|
|
|
// ... even re-usable twice in succession
|
|
v3 := NewValue("v3")
|
|
v4 := NewValue("v4")
|
|
g2 := g0.AddValueIn(oe1, v3).AddValueIn(oe1, v4)
|
|
assert.Nil(t, g2.ValueVertex(v3b))
|
|
assert.Nil(t, g2.ValueVertex(v3a))
|
|
assertVertexEqual(t, value(v3, edge(e1, value(v2))), g2.ValueVertex(v3))
|
|
assertVertexEqual(t, value(v4, edge(e1, value(v2))), g2.ValueVertex(v4))
|
|
}
|
|
|
|
func TestGraphDelValueIn(t *T) {
|
|
v0 := NewValue("v0")
|
|
v1 := NewValue("v1")
|
|
e0 := NewValue("e0")
|
|
{ // removing from null
|
|
g := ZeroGraph.DelValueIn(ValueOut(v0, e0), v1)
|
|
assert.True(t, Equal(ZeroGraph, g))
|
|
}
|
|
|
|
e1 := NewValue("e1")
|
|
{ // removing edge from vertex which doesn't have that edge
|
|
g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
|
|
g1 := g0.DelValueIn(ValueOut(v0, e1), v1)
|
|
assert.True(t, Equal(g0, g1))
|
|
}
|
|
|
|
{ // removing only edge
|
|
oe := ValueOut(v0, e0)
|
|
g0 := ZeroGraph.AddValueIn(oe, v1)
|
|
g1 := g0.DelValueIn(oe, v1)
|
|
assert.True(t, Equal(ZeroGraph, g1))
|
|
}
|
|
|
|
ej0 := NewValue("ej0")
|
|
v2 := NewValue("v2")
|
|
{ // removing only edge (tuple)
|
|
oe := TupleOut([]OpenEdge{
|
|
ValueOut(v0, e0),
|
|
ValueOut(v1, e1),
|
|
}, ej0)
|
|
g0 := ZeroGraph.AddValueIn(oe, v2)
|
|
g1 := g0.DelValueIn(oe, v2)
|
|
assert.True(t, Equal(ZeroGraph, g1))
|
|
}
|
|
|
|
{ // removing one of two edges
|
|
oe := ValueOut(v1, e0)
|
|
g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v2)
|
|
g1 := g0.AddValueIn(oe, v2)
|
|
g2 := g1.DelValueIn(oe, v2)
|
|
assert.True(t, Equal(g0, g2))
|
|
assert.NotNil(t, g2.ValueVertex(v0))
|
|
assert.Nil(t, g2.ValueVertex(v1))
|
|
assert.NotNil(t, g2.ValueVertex(v2))
|
|
}
|
|
|
|
e2 := NewValue("e2")
|
|
eja, ejb := NewValue("eja"), NewValue("ejb")
|
|
v3 := NewValue("v3")
|
|
{ // removing one of two edges (tuple)
|
|
e0 := ValueOut(v0, e0)
|
|
e1 := ValueOut(v1, e1)
|
|
e2 := ValueOut(v2, e2)
|
|
oeA := TupleOut([]OpenEdge{e0, e1}, eja)
|
|
oeB := TupleOut([]OpenEdge{e1, e2}, ejb)
|
|
g0a := ZeroGraph.AddValueIn(oeA, v3)
|
|
g0b := ZeroGraph.AddValueIn(oeB, v3)
|
|
g1 := g0a.Union(g0b).DelValueIn(oeA, v3)
|
|
assert.True(t, Equal(g1, g0b))
|
|
assert.Nil(t, g1.ValueVertex(v0))
|
|
assert.NotNil(t, g1.ValueVertex(v1))
|
|
assert.NotNil(t, g1.ValueVertex(v2))
|
|
assert.NotNil(t, g1.ValueVertex(v3))
|
|
}
|
|
|
|
{ // removing one of two edges in circular graph
|
|
e0 := ValueOut(v0, e0)
|
|
e1 := ValueOut(v1, e1)
|
|
g0 := ZeroGraph.AddValueIn(e0, v1).AddValueIn(e1, v0)
|
|
g1 := g0.DelValueIn(e0, v1)
|
|
assert.True(t, Equal(ZeroGraph.AddValueIn(e1, v0), g1))
|
|
assert.NotNil(t, g1.ValueVertex(v0))
|
|
assert.NotNil(t, g1.ValueVertex(v1))
|
|
}
|
|
|
|
ej := NewValue("ej")
|
|
{ // removing to's only edge, sub-nodes have edge to each other
|
|
oej := TupleOut([]OpenEdge{
|
|
ValueOut(v0, ej0),
|
|
ValueOut(v1, ej0),
|
|
}, ej)
|
|
g0 := ZeroGraph.AddValueIn(oej, v2)
|
|
e0 := ValueOut(v0, e0)
|
|
g1 := g0.AddValueIn(e0, v1)
|
|
g2 := g1.DelValueIn(oej, v2)
|
|
assert.True(t, Equal(ZeroGraph.AddValueIn(e0, v1), g2))
|
|
assert.NotNil(t, g2.ValueVertex(v0))
|
|
assert.NotNil(t, g2.ValueVertex(v1))
|
|
assert.Nil(t, g2.ValueVertex(v2))
|
|
}
|
|
}
|
|
|
|
// deterministically hashes a Graph
|
|
func graphStr(g *Graph) string {
|
|
var vStr func(vertex) string
|
|
var oeStr func(OpenEdge) string
|
|
vStr = func(v vertex) string {
|
|
if v.VertexType == ValueVertex {
|
|
return fmt.Sprintf("v:%q\n", v.val.V.(string))
|
|
}
|
|
s := fmt.Sprintf("j:%d\n", len(v.in))
|
|
ssOE := make([]string, len(v.in))
|
|
for i := range v.in {
|
|
ssOE[i] = oeStr(v.in[i])
|
|
}
|
|
sort.Strings(ssOE)
|
|
return s + strings.Join(ssOE, "")
|
|
}
|
|
oeStr = func(oe OpenEdge) string {
|
|
s := fmt.Sprintf("oe:%q\n", oe.val.V.(string))
|
|
return s + vStr(oe.fromV)
|
|
}
|
|
sVV := make([]string, 0, len(g.vM))
|
|
for _, v := range g.vM {
|
|
sVV = append(sVV, vStr(v))
|
|
}
|
|
sort.Strings(sVV)
|
|
return strings.Join(sVV, "")
|
|
}
|
|
|
|
func assertEqualSets(t *T, exp, got []*Graph) bool {
|
|
if !assert.Equal(t, len(exp), len(got)) {
|
|
return false
|
|
}
|
|
|
|
m := map[*Graph]string{}
|
|
for _, g := range exp {
|
|
m[g] = graphStr(g)
|
|
}
|
|
for _, g := range got {
|
|
m[g] = graphStr(g)
|
|
}
|
|
|
|
sort.Slice(exp, func(i, j int) bool {
|
|
return m[exp[i]] < m[exp[j]]
|
|
})
|
|
sort.Slice(got, func(i, j int) bool {
|
|
return m[got[i]] < m[got[j]]
|
|
})
|
|
|
|
b := true
|
|
for i := range exp {
|
|
b = b || assert.True(t, Equal(exp[i], got[i]), "i:%d exp:%q got:%q", i, m[exp[i]], m[got[i]])
|
|
}
|
|
return b
|
|
}
|
|
|
|
func TestGraphUnion(t *T) {
|
|
assertUnion := func(g1, g2 *Graph) *Graph {
|
|
ga := g1.Union(g2)
|
|
gb := g2.Union(g1)
|
|
assert.True(t, Equal(ga, gb))
|
|
return ga
|
|
}
|
|
|
|
assertDisjoin := func(g *Graph, exp ...*Graph) {
|
|
ggDisj := g.Disjoin()
|
|
assertEqualSets(t, exp, ggDisj)
|
|
}
|
|
|
|
v0 := NewValue("v0")
|
|
v1 := NewValue("v1")
|
|
e0 := NewValue("e0")
|
|
{ // Union with ZeroGraph
|
|
assert.True(t, Equal(ZeroGraph, ZeroGraph.Union(ZeroGraph)))
|
|
|
|
g := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
|
|
assert.True(t, Equal(g, assertUnion(g, ZeroGraph)))
|
|
|
|
assertDisjoin(g, g)
|
|
}
|
|
|
|
v2 := NewValue("v2")
|
|
v3 := NewValue("v3")
|
|
e1 := NewValue("e1")
|
|
{ // Two disparate graphs union'd
|
|
g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
|
|
g1 := ZeroGraph.AddValueIn(ValueOut(v2, e1), v3)
|
|
g := assertUnion(g0, g1)
|
|
assertVertexEqual(t, value(v0), g.ValueVertex(v0))
|
|
assertVertexEqual(t, value(v1, edge(e0, value(v0))), g.ValueVertex(v1))
|
|
assertVertexEqual(t, value(v2), g.ValueVertex(v2))
|
|
assertVertexEqual(t, value(v3, edge(e1, value(v2))), g.ValueVertex(v3))
|
|
|
|
assertDisjoin(g, g0, g1)
|
|
}
|
|
|
|
va0, vb0 := NewValue("va0"), NewValue("vb0")
|
|
va1, vb1 := NewValue("va1"), NewValue("vb1")
|
|
va2, vb2 := NewValue("va2"), NewValue("vb2")
|
|
ea0, eb0 := NewValue("ea0"), NewValue("eb0")
|
|
ea1, eb1 := NewValue("ea1"), NewValue("eb1")
|
|
eaj, ebj := NewValue("eaj"), NewValue("ebj")
|
|
{ // Two disparate graphs with tuples
|
|
ga := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{
|
|
ValueOut(va0, ea0),
|
|
ValueOut(va1, ea1),
|
|
}, eaj), va2)
|
|
gb := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{
|
|
ValueOut(vb0, eb0),
|
|
ValueOut(vb1, eb1),
|
|
}, ebj), vb2)
|
|
g := assertUnion(ga, gb)
|
|
assertVertexEqual(t, value(va0), g.ValueVertex(va0))
|
|
assertVertexEqual(t, value(va1), g.ValueVertex(va1))
|
|
assertVertexEqual(t,
|
|
value(va2, tuple(eaj,
|
|
edge(ea0, value(va0)),
|
|
edge(ea1, value(va1)))),
|
|
g.ValueVertex(va2),
|
|
)
|
|
assertVertexEqual(t, value(vb0), g.ValueVertex(vb0))
|
|
assertVertexEqual(t, value(vb1), g.ValueVertex(vb1))
|
|
assertVertexEqual(t,
|
|
value(vb2, tuple(ebj,
|
|
edge(eb0, value(vb0)),
|
|
edge(eb1, value(vb1)))),
|
|
g.ValueVertex(vb2),
|
|
)
|
|
|
|
assertDisjoin(g, ga, gb)
|
|
}
|
|
|
|
{ // Two partially overlapping graphs
|
|
g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v2)
|
|
g1 := ZeroGraph.AddValueIn(ValueOut(v1, e1), v2)
|
|
g := assertUnion(g0, g1)
|
|
assertVertexEqual(t, value(v0), g.ValueVertex(v0))
|
|
assertVertexEqual(t, value(v1), g.ValueVertex(v1))
|
|
assertVertexEqual(t,
|
|
value(v2,
|
|
edge(e0, value(v0)),
|
|
edge(e1, value(v1)),
|
|
),
|
|
g.ValueVertex(v2),
|
|
)
|
|
|
|
assertDisjoin(g, g)
|
|
}
|
|
|
|
ej0 := NewValue("ej0")
|
|
ej1 := NewValue("ej1")
|
|
{ // two partially overlapping graphs with tuples
|
|
g0 := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{
|
|
ValueOut(v0, e0),
|
|
ValueOut(v1, e1),
|
|
}, ej0), v2)
|
|
g1 := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{
|
|
ValueOut(v0, e0),
|
|
ValueOut(v1, e1),
|
|
}, ej1), v2)
|
|
g := assertUnion(g0, g1)
|
|
assertVertexEqual(t, value(v0), g.ValueVertex(v0))
|
|
assertVertexEqual(t, value(v1), g.ValueVertex(v1))
|
|
assertVertexEqual(t,
|
|
value(v2,
|
|
tuple(ej0, edge(e0, value(v0)), edge(e1, value(v1))),
|
|
tuple(ej1, edge(e0, value(v0)), edge(e1, value(v1))),
|
|
),
|
|
g.ValueVertex(v2),
|
|
)
|
|
|
|
assertDisjoin(g, g)
|
|
}
|
|
|
|
{ // Two equal graphs
|
|
g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
|
|
g := assertUnion(g0, g0)
|
|
assertVertexEqual(t, value(v0), g.ValueVertex(v0))
|
|
assertVertexEqual(t,
|
|
value(v1, edge(e0, value(v0))),
|
|
g.ValueVertex(v1),
|
|
)
|
|
}
|
|
|
|
{ // Two equal graphs with tuples
|
|
g0 := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{
|
|
ValueOut(v0, e0),
|
|
ValueOut(v1, e1),
|
|
}, ej0), v2)
|
|
g := assertUnion(g0, g0)
|
|
assertVertexEqual(t, value(v0), g.ValueVertex(v0))
|
|
assertVertexEqual(t, value(v1), g.ValueVertex(v1))
|
|
assertVertexEqual(t,
|
|
value(v2,
|
|
tuple(ej0, edge(e0, value(v0)), edge(e1, value(v1))),
|
|
),
|
|
g.ValueVertex(v2),
|
|
)
|
|
}
|
|
}
|
|
|
|
func TestGraphEqual(t *T) {
|
|
assertEqual := func(g1, g2 *Graph) {
|
|
assert.True(t, Equal(g1, g2))
|
|
assert.True(t, Equal(g2, g1))
|
|
}
|
|
|
|
assertNotEqual := func(g1, g2 *Graph) {
|
|
assert.False(t, Equal(g1, g2))
|
|
assert.False(t, Equal(g2, g1))
|
|
}
|
|
|
|
assertEqual(ZeroGraph, ZeroGraph) // duh
|
|
|
|
v0 := NewValue("v0")
|
|
v1 := NewValue("v1")
|
|
v2 := NewValue("v2")
|
|
e0 := NewValue("e0")
|
|
e1 := NewValue("e1")
|
|
e1a, e1b := NewValue("e1a"), NewValue("e1b")
|
|
{
|
|
// graph is equal to itself, not to null
|
|
e0 := ValueOut(v0, e0)
|
|
g0 := ZeroGraph.AddValueIn(e0, v1)
|
|
assertNotEqual(g0, ZeroGraph)
|
|
assertEqual(g0, g0)
|
|
|
|
// adding the an existing edge again shouldn't do anything
|
|
assertEqual(g0, g0.AddValueIn(e0, v1))
|
|
|
|
// g1a and g1b have the same vertices, but the edges are different
|
|
g1a := g0.AddValueIn(ValueOut(v0, e1a), v2)
|
|
g1b := g0.AddValueIn(ValueOut(v0, e1b), v2)
|
|
assertNotEqual(g1a, g1b)
|
|
}
|
|
|
|
{ // equal construction should yield equality, even if out of order
|
|
ga := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
|
|
ga = ga.AddValueIn(ValueOut(v1, e1), v2)
|
|
gb := ZeroGraph.AddValueIn(ValueOut(v1, e1), v2)
|
|
gb = gb.AddValueIn(ValueOut(v0, e0), v1)
|
|
assertEqual(ga, gb)
|
|
}
|
|
|
|
ej := NewValue("ej")
|
|
{ // tuple basic test
|
|
e0 := ValueOut(v0, e0)
|
|
e1 := ValueOut(v1, e1)
|
|
ga := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{e0, e1}, ej), v2)
|
|
gb := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{e1, e0}, ej), v2)
|
|
assertEqual(ga, ga)
|
|
assertNotEqual(ga, gb)
|
|
}
|
|
}
|
|
|