141 lines
3.0 KiB
Go
141 lines
3.0 KiB
Go
package tea
|
|
|
|
import (
|
|
"testing"
|
|
)
|
|
|
|
type selectionTest struct {
|
|
label string
|
|
selection Selection
|
|
lnodes []string
|
|
xnodes []string
|
|
xleaves []string
|
|
}
|
|
|
|
func (test *selectionTest) Run(t *testing.T) {
|
|
LWanted := wantStrings("selected lnode names", test.lnodes...)
|
|
for _, L := range test.selection.nodes {
|
|
LWanted.add(L.name)
|
|
}
|
|
LWanted.report(t)
|
|
|
|
XWanted := wantStrings("selected xnode labels", test.xnodes...)
|
|
for _, X := range test.selection.xnodes() {
|
|
XWanted.add(X.label())
|
|
}
|
|
XWanted.report(t)
|
|
|
|
// XLeavesWanted := wantStrings("leaf xnode labels", test.xleaves...)
|
|
// for _, X := range test.selection.xnodes() {
|
|
// leaves := X.leaves()
|
|
// for _, leaf := range leaves {
|
|
// XLeavesWanted.
|
|
|
|
// }
|
|
|
|
// }
|
|
}
|
|
|
|
func TestSelections(t *testing.T) {
|
|
tests := []selectionTest{
|
|
{
|
|
label: "new selection",
|
|
selection: NewSelection(A),
|
|
lnodes: []string{"A"},
|
|
xnodes: []string{"A.0"},
|
|
},
|
|
{
|
|
label: "root with one child",
|
|
selection: NewSelection(A).Child(B),
|
|
lnodes: []string{"B"},
|
|
xnodes: []string{"B.0.A"},
|
|
},
|
|
{
|
|
label: "two selected roots",
|
|
selection: NewSelection(A).And(NewSelection(B)),
|
|
lnodes: []string{"A", "B"},
|
|
xnodes: []string{"A.0", "B.0"},
|
|
},
|
|
}
|
|
|
|
add := func(fn func() selectionTest) { tests = append(tests, fn()) }
|
|
|
|
add(func() selectionTest {
|
|
root := NewSelection(A)
|
|
b := root.Child(B)
|
|
return selectionTest{
|
|
label: "root and child selected",
|
|
selection: root.And(b),
|
|
lnodes: []string{"A", "B"},
|
|
xnodes: []string{"A.0", "B.0.A"},
|
|
}
|
|
})
|
|
|
|
add(func() selectionTest {
|
|
root := NewSelection(A)
|
|
b := root.Child(B)
|
|
return selectionTest{
|
|
label: "an optional test",
|
|
selection: root.And(b).Child(C),
|
|
lnodes: []string{"C"},
|
|
xnodes: []string{"C.0.A", "C.1.B"},
|
|
}
|
|
})
|
|
|
|
add(func() selectionTest {
|
|
root := NewSelection(A)
|
|
b := root.Child(B)
|
|
c := root.Child(C)
|
|
|
|
return selectionTest{
|
|
label: "two children selected",
|
|
selection: b.And(c),
|
|
lnodes: []string{"B", "C"},
|
|
xnodes: []string{"B.0.A", "C.0.A"},
|
|
}
|
|
})
|
|
|
|
add(func() selectionTest {
|
|
root := NewSelection(A)
|
|
b := root.Child(B)
|
|
c := root.Child(C)
|
|
return selectionTest{
|
|
label: "a diamond test",
|
|
selection: b.And(c).Child(D),
|
|
lnodes: []string{"D"},
|
|
xnodes: []string{"D.0.B", "D.1.C"},
|
|
}
|
|
})
|
|
|
|
add(func() selectionTest {
|
|
root := NewSelection(A)
|
|
b := root.Child(B)
|
|
c := root.Child(C)
|
|
d := b.And(c).Child(D)
|
|
return selectionTest{
|
|
label: "child of a node having multiple parents",
|
|
selection: d.Child(E),
|
|
lnodes: []string{"E"},
|
|
xnodes: []string{"E.0.D", "E.1.D"},
|
|
}
|
|
})
|
|
|
|
add(func() selectionTest {
|
|
root := NewSelection(A)
|
|
b := root.Child(B)
|
|
c := root.Child(C)
|
|
d := b.And(c).Child(D)
|
|
d.Child(E)
|
|
return selectionTest{
|
|
label: "the root of a complex graph",
|
|
selection: root,
|
|
lnodes: []string{"A"},
|
|
xnodes: []string{"A.0"},
|
|
}
|
|
})
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.label, test.Run)
|
|
}
|
|
}
|