Compare commits
1 Commits
| Author | SHA1 | Date |
|---|---|---|
 Jordan Orelli
|
7363c4b2c4 | 4 years ago |
@ -1,74 +0,0 @@
|
|||||||
package tea
|
|
||||||
|
|
||||||
// this is just a collection of ... reusable assertions for the unit tests for
|
|
||||||
// tea itself.
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
type labelChecker struct {
|
|
||||||
name string
|
|
||||||
wanted map[string]bool // all the strings we want
|
|
||||||
found map[string]bool // all the strings we've found
|
|
||||||
}
|
|
||||||
|
|
||||||
func wantStrings(name string, want ...string) labelChecker {
|
|
||||||
l := newLabelChecker(name)
|
|
||||||
l.want(want...)
|
|
||||||
return l
|
|
||||||
}
|
|
||||||
|
|
||||||
func newLabelChecker(name string) labelChecker {
|
|
||||||
return labelChecker{
|
|
||||||
name: name,
|
|
||||||
wanted: make(map[string]bool),
|
|
||||||
found: make(map[string]bool),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *labelChecker) want(names ...string) {
|
|
||||||
for _, name := range names {
|
|
||||||
l.wanted[name] = true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *labelChecker) add(name string) {
|
|
||||||
l.found[name] = true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *labelChecker) report(t *testing.T) {
|
|
||||||
for name, _ := range l.found {
|
|
||||||
if l.wanted[name] {
|
|
||||||
t.Logf("%s saw expected value %s", l.name, name)
|
|
||||||
} else {
|
|
||||||
t.Errorf("%s saw unexpected value %s", l.name, name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for name, _ := range l.wanted {
|
|
||||||
if !l.found[name] {
|
|
||||||
t.Errorf("%s missing expected value %s", l.name, name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func assertError(t *testing.T, fatal bool, err error, target error) {
|
|
||||||
if !errors.Is(err, target) {
|
|
||||||
if fatal {
|
|
||||||
t.Fatalf("expected error to be %s, instead found: %s", target, err)
|
|
||||||
} else {
|
|
||||||
t.Errorf("expected error to be %s, instead found: %s", target, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func assertNoError(t *testing.T, fatal bool, err error) {
|
|
||||||
if err != nil {
|
|
||||||
if fatal {
|
|
||||||
t.Fatalf("encountered unexpected error: %v", err)
|
|
||||||
} else {
|
|
||||||
t.Fatalf("encountered unexpected error: %v", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,7 +0,0 @@
|
|||||||
package tea
|
|
||||||
|
|
||||||
// xchain is a chain of xnodes. an xchain is an execution plan for executing a
|
|
||||||
// sequence of tests. somwhat ironically the nodes are actually in a slice.
|
|
||||||
type xchain struct {
|
|
||||||
xnodes []*xnode
|
|
||||||
}
|
|
||||||
@ -1,33 +0,0 @@
|
|||||||
package tea
|
|
||||||
|
|
||||||
// these constant tests are useful for testing things that manipulate the
|
|
||||||
// graph.
|
|
||||||
|
|
||||||
const (
|
|
||||||
A = Passing("A")
|
|
||||||
B = Passing("B")
|
|
||||||
C = Passing("C")
|
|
||||||
D = Passing("D")
|
|
||||||
E = Passing("E")
|
|
||||||
F = Passing("F")
|
|
||||||
G = Passing("G")
|
|
||||||
H = Passing("H")
|
|
||||||
I = Passing("I")
|
|
||||||
J = Passing("J")
|
|
||||||
K = Passing("K")
|
|
||||||
L = Passing("L")
|
|
||||||
M = Passing("M")
|
|
||||||
N = Passing("N")
|
|
||||||
O = Passing("O")
|
|
||||||
P = Passing("P")
|
|
||||||
Q = Passing("Q")
|
|
||||||
R = Passing("R")
|
|
||||||
S = Passing("S")
|
|
||||||
T = Passing("T")
|
|
||||||
U = Passing("U")
|
|
||||||
V = Passing("V")
|
|
||||||
W = Passing("W")
|
|
||||||
X = Passing("X")
|
|
||||||
Y = Passing("Y")
|
|
||||||
Z = Passing("Z")
|
|
||||||
)
|
|
||||||
@ -1,34 +0,0 @@
|
|||||||
package tea
|
|
||||||
|
|
||||||
// generator functions for creating randomized test data.
|
|
||||||
|
|
||||||
import (
|
|
||||||
"math/rand"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// alpha is an alphabet of letters to pick from when producing random strings.
|
|
||||||
// the selected characters are human-readable without much visual ambiguity and
|
|
||||||
// include some code points beyond the ascii range to make sure things don't
|
|
||||||
// break on unicode input.
|
|
||||||
var alpha = []rune("" +
|
|
||||||
// lower-case ascii letters
|
|
||||||
"abcdefghjkmnpqrstwxyz" +
|
|
||||||
// upper-case ascii letters
|
|
||||||
"ABCDEFGHIJKLMNPQRSTWXYZ" +
|
|
||||||
// some digits
|
|
||||||
"23456789" +
|
|
||||||
// miscellaneous non-ascii characters
|
|
||||||
"¢£¥ÐÑØæñþÆŁřƩλЖд")
|
|
||||||
|
|
||||||
func rstring(n int) string {
|
|
||||||
r := make([]rune, n)
|
|
||||||
for i, _ := range r {
|
|
||||||
r[i] = alpha[rand.Intn(len(alpha))]
|
|
||||||
}
|
|
||||||
return string(r)
|
|
||||||
}
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
rand.Seed(time.Now().Unix())
|
|
||||||
}
|
|
||||||
@ -1,59 +0,0 @@
|
|||||||
package tea
|
|
||||||
|
|
||||||
import "reflect"
|
|
||||||
|
|
||||||
type sval struct {
|
|
||||||
name string
|
|
||||||
val interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// layerData is an ordered list of key-value pairs. We preserve the ordering of
|
|
||||||
// the fields from the structs that produced the layer so that viewing a list
|
|
||||||
// of layers shows each layer from the sam struct in the same value-order,
|
|
||||||
// which is the order those fields appear in their originating stuct (and not,
|
|
||||||
// like, alphabetical order). Although a bit more tedious to work with
|
|
||||||
// internally, this is intended to make it possible to write more descriptive,
|
|
||||||
// easily understood PlanError messages.
|
|
||||||
type layerData []sval
|
|
||||||
|
|
||||||
func (l layerData) get(key string) (val interface{}, present bool) {
|
|
||||||
for _, pair := range l {
|
|
||||||
if pair.name == key {
|
|
||||||
return pair.val, true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
|
|
||||||
type layer struct {
|
|
||||||
origin *xnode
|
|
||||||
saved layerData
|
|
||||||
}
|
|
||||||
|
|
||||||
func makeLayerData(test Test) (layerData, error) {
|
|
||||||
V := reflect.ValueOf(test)
|
|
||||||
if V.Type().Kind() == reflect.Ptr {
|
|
||||||
V = V.Elem()
|
|
||||||
}
|
|
||||||
T := V.Type()
|
|
||||||
|
|
||||||
if T.Kind() != reflect.Struct {
|
|
||||||
return nil, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
fields, err := getSaveFields(T)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
if len(fields) == 0 {
|
|
||||||
// is this weird? maybe this is weird.
|
|
||||||
return nil, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
data := make(layerData, 0, len(fields))
|
|
||||||
for _, f := range fields {
|
|
||||||
fv := V.FieldByName(f.Name).Interface()
|
|
||||||
data = append(data, sval{name: f.Name, val: fv})
|
|
||||||
}
|
|
||||||
return data, nil
|
|
||||||
}
|
|
||||||
@ -1,95 +0,0 @@
|
|||||||
package tea
|
|
||||||
|
|
||||||
import (
|
|
||||||
"math/rand"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestLayerData(t *testing.T) {
|
|
||||||
t.Run("non-struct tests produce empty layers", func(t *testing.T) {
|
|
||||||
lr, err := makeLayerData(Pass)
|
|
||||||
if len(lr) != 0 {
|
|
||||||
t.Errorf("expected a nil layer but saw %v instead", lr)
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
t.Errorf("expected no error from lay but saw %v instead", err)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
|
|
||||||
t.Run("save tags on unexported fields are plan errors", func(t *testing.T) {
|
|
||||||
type T struct {
|
|
||||||
Passing
|
|
||||||
count int `tea:"save"`
|
|
||||||
}
|
|
||||||
_, err := makeLayerData(T{})
|
|
||||||
assertError(t, true, err, PlanError)
|
|
||||||
})
|
|
||||||
|
|
||||||
t.Run("mixed exported/unexported fields still an error", func(t *testing.T) {
|
|
||||||
type T struct {
|
|
||||||
Passing
|
|
||||||
count int `tea:"save"`
|
|
||||||
Bar string `tea:"save"`
|
|
||||||
}
|
|
||||||
_, err := makeLayerData(T{})
|
|
||||||
assertError(t, true, err, PlanError)
|
|
||||||
})
|
|
||||||
|
|
||||||
t.Run("mixed exported/unexported fields still an error", func(t *testing.T) {
|
|
||||||
type T struct {
|
|
||||||
Passing
|
|
||||||
count int `tea:"save"`
|
|
||||||
bar string `tea:"save"`
|
|
||||||
}
|
|
||||||
_, err := makeLayerData(T{})
|
|
||||||
assertError(t, true, err, PlanError)
|
|
||||||
})
|
|
||||||
|
|
||||||
t.Run("save one int", func(t *testing.T) {
|
|
||||||
type T struct {
|
|
||||||
Passing
|
|
||||||
Count int `tea:"save"`
|
|
||||||
}
|
|
||||||
test := T{Count: rand.Int()}
|
|
||||||
data, err := makeLayerData(test)
|
|
||||||
assertNoError(t, true, err)
|
|
||||||
if len(data) == 0 {
|
|
||||||
t.Fatalf("expected nonempty layer, saw empty layer instead")
|
|
||||||
}
|
|
||||||
if v, ok := data.get("Count"); !ok {
|
|
||||||
t.Errorf("layer data is missing expected field Count")
|
|
||||||
} else {
|
|
||||||
if v != test.Count {
|
|
||||||
t.Errorf("layer data expected Count value of %d but saw %d instead", test.Count, v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
|
|
||||||
t.Run("an int and a string", func(t *testing.T) {
|
|
||||||
type T struct {
|
|
||||||
Passing
|
|
||||||
Count int `tea:"save"`
|
|
||||||
Name string `tea:"save"`
|
|
||||||
}
|
|
||||||
test := T{Count: rand.Int(), Name: rstring(8)}
|
|
||||||
data, err := makeLayerData(test)
|
|
||||||
assertNoError(t, true, err)
|
|
||||||
if len(data) == 0 {
|
|
||||||
t.Fatalf("expected nonempty layer, saw empty layer instead")
|
|
||||||
}
|
|
||||||
if v, ok := data.get("Count"); !ok {
|
|
||||||
t.Errorf("layer data is missing expected field Count")
|
|
||||||
} else {
|
|
||||||
if v != test.Count {
|
|
||||||
t.Errorf("layer data expected Count value of %d but saw %d instead", test.Count, v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if v, ok := data.get("Name"); !ok {
|
|
||||||
t.Errorf("layer data is missing expected field Count")
|
|
||||||
} else {
|
|
||||||
if v != test.Name {
|
|
||||||
t.Errorf("layer data expected Name value of %s but saw %s instead", test.Name, v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
@ -1,158 +0,0 @@
|
|||||||
package tea
|
|
||||||
|
|
||||||
import "fmt"
|
|
||||||
|
|
||||||
var lastID int
|
|
||||||
|
|
||||||
func nextNodeID() int {
|
|
||||||
lastID++
|
|
||||||
return lastID
|
|
||||||
}
|
|
||||||
|
|
||||||
// lnode is a node in the logical graph. Developers create a logical graph in
|
|
||||||
// which nodes may have more than one parent. Each test value written by a
|
|
||||||
// developer appears as one logical node in the logical graph. The public
|
|
||||||
// documentation refers to the logical graph as simply the test graph.
|
|
||||||
type lnode struct {
|
|
||||||
id int
|
|
||||||
name string
|
|
||||||
xnodes []xnode
|
|
||||||
test Test
|
|
||||||
parents []*lnode
|
|
||||||
children []*lnode
|
|
||||||
}
|
|
||||||
|
|
||||||
// newLNode greates a new lnode with the provided test and the list of parents.
|
|
||||||
// If there are no parents, the lnode is a root node, and the provided test is
|
|
||||||
// run once. Otherwise, the provided test is used to create xnodes that are
|
|
||||||
// children of all of the provided parent nodes' xnodes.
|
|
||||||
func newLNode(test Test, sel Selection) *lnode {
|
|
||||||
if len(sel.nodes) == 0 {
|
|
||||||
return rootLNode(test)
|
|
||||||
}
|
|
||||||
|
|
||||||
node := lnode{
|
|
||||||
id: nextNodeID(),
|
|
||||||
name: parseName(test),
|
|
||||||
test: test,
|
|
||||||
parents: make([]*lnode, len(sel.nodes)),
|
|
||||||
}
|
|
||||||
// not sure if this copy is necessary
|
|
||||||
copy(node.parents, sel.nodes)
|
|
||||||
|
|
||||||
xID := 0
|
|
||||||
for _, parent := range node.parents {
|
|
||||||
parent.children = append(parent.children, &node)
|
|
||||||
for i, _ := range parent.xnodes {
|
|
||||||
x := xnode{
|
|
||||||
id: xID,
|
|
||||||
lnode: &node,
|
|
||||||
parent: &parent.xnodes[i],
|
|
||||||
}
|
|
||||||
node.xnodes = append(node.xnodes, x)
|
|
||||||
xID++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for i, x := range node.xnodes {
|
|
||||||
x.parent.children = append(x.parent.children, &node.xnodes[i])
|
|
||||||
}
|
|
||||||
return &node
|
|
||||||
}
|
|
||||||
|
|
||||||
// rootLNode creates a root lnode. This case is a lot simpler so I split it out
|
|
||||||
// to keep newLNode a little more readable.
|
|
||||||
func rootLNode(test Test) *lnode {
|
|
||||||
id := nextNodeID()
|
|
||||||
node := lnode{
|
|
||||||
id: id,
|
|
||||||
name: parseName(test),
|
|
||||||
test: test,
|
|
||||||
}
|
|
||||||
node.xnodes = []xnode{{id: 0, lnode: &node}}
|
|
||||||
return &node
|
|
||||||
}
|
|
||||||
|
|
||||||
// xnode is a node in the execution graph, representing one instance of a test
|
|
||||||
// to be executed. xnode is the unit test in tea. every xnode is either
|
|
||||||
// unparented or has one parent.
|
|
||||||
type xnode struct {
|
|
||||||
id int // id within the parent lnode
|
|
||||||
lnode *lnode // corresponding node in the logical test graph
|
|
||||||
parent *xnode
|
|
||||||
children []*xnode
|
|
||||||
}
|
|
||||||
|
|
||||||
func (x *xnode) isOnlyTestInLNode() bool {
|
|
||||||
return len(x.lnode.xnodes) == 1
|
|
||||||
}
|
|
||||||
|
|
||||||
// label must be unique or some other shit will break, I'm using this as a way
|
|
||||||
// to globally identify xnodes, which may be very flawed and maybe I should
|
|
||||||
// have an actual global ID system.
|
|
||||||
func (x *xnode) label() string {
|
|
||||||
if x.parent == nil {
|
|
||||||
switch {
|
|
||||||
case len(x.lnode.children) < 10:
|
|
||||||
return fmt.Sprintf("%s.%d", x.lnode.name, x.id)
|
|
||||||
case len(x.lnode.children) < 100:
|
|
||||||
return fmt.Sprintf("%s.%02d", x.lnode.name, x.id)
|
|
||||||
case len(x.lnode.children) < 1000:
|
|
||||||
return fmt.Sprintf("%s.%03d", x.lnode.name, x.id)
|
|
||||||
default:
|
|
||||||
return fmt.Sprintf("%s.%04d", x.lnode.name, x.id)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
switch {
|
|
||||||
case len(x.lnode.children) < 10:
|
|
||||||
return fmt.Sprintf("%s.%d.%s", x.lnode.name, x.id, x.parent.lnode.name)
|
|
||||||
case len(x.lnode.children) < 100:
|
|
||||||
return fmt.Sprintf("%s.%02d.%s", x.lnode.name, x.id, x.parent.lnode.name)
|
|
||||||
case len(x.lnode.children) < 1000:
|
|
||||||
return fmt.Sprintf("%s.%03d.%s", x.lnode.name, x.id, x.parent.lnode.name)
|
|
||||||
default:
|
|
||||||
return fmt.Sprintf("%s.%04d.%s", x.lnode.name, x.id, x.parent.lnode.name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// ancestry gives a slice of xnodes beginning at the root of the x graph and
|
|
||||||
// terminating at the receiver xnode. The ancestry list of a leaf node in the x
|
|
||||||
// graph is a single chain of tests.
|
|
||||||
func (x *xnode) ancestry() []*xnode {
|
|
||||||
if x.parent == nil {
|
|
||||||
return []*xnode{x}
|
|
||||||
}
|
|
||||||
return append(x.parent.ancestry(), x)
|
|
||||||
}
|
|
||||||
|
|
||||||
// descendents gives a slice of all xnodes whose ancestry includes the receiver
|
|
||||||
// xnode, in depth-first order.
|
|
||||||
func (x *xnode) descendents() []*xnode {
|
|
||||||
if len(x.children) == 0 {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
descendents := make([]*xnode, 0, len(x.children))
|
|
||||||
for _, c := range x.children {
|
|
||||||
descendents = append(descendents, c)
|
|
||||||
descendents = append(descendents, c.descendents()...)
|
|
||||||
}
|
|
||||||
return descendents
|
|
||||||
}
|
|
||||||
|
|
||||||
// leaves descends the x graph from the receiver xnode, returning a slice
|
|
||||||
// containing all of the leaves of the x graph having the receiver x as an
|
|
||||||
// ancestor.
|
|
||||||
func (x *xnode) leaves() []*xnode {
|
|
||||||
if len(x.children) == 0 {
|
|
||||||
return []*xnode{x}
|
|
||||||
}
|
|
||||||
|
|
||||||
var leaves []*xnode
|
|
||||||
for _, child := range x.children {
|
|
||||||
leaves = append(leaves, child.leaves()...)
|
|
||||||
}
|
|
||||||
|
|
||||||
return leaves
|
|
||||||
}
|
|
||||||
@ -1,8 +0,0 @@
|
|||||||
package tea
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestXLabels(t *testing.T) {
|
|
||||||
}
|
|
||||||
@ -1,73 +0,0 @@
|
|||||||
package tea
|
|
||||||
|
|
||||||
func NewSelection(test Test) Selection {
|
|
||||||
node := newLNode(test, Selection{})
|
|
||||||
return Selection{nodes: []*lnode{node}}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Selection represents a set of nodes in our graph.
|
|
||||||
type Selection struct {
|
|
||||||
nodes []*lnode
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s Selection) Child(test Test) Selection {
|
|
||||||
node := newLNode(test, s)
|
|
||||||
return Selection{nodes: []*lnode{node}}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s Selection) And(other Selection) Selection {
|
|
||||||
included := make(map[int]bool)
|
|
||||||
|
|
||||||
out := make([]*lnode, 0, len(s.nodes)+len(other.nodes))
|
|
||||||
for _, n := range append(s.nodes, other.nodes...) {
|
|
||||||
if !included[n.id] {
|
|
||||||
out = append(out, n)
|
|
||||||
included[n.id] = true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return Selection{nodes: out}
|
|
||||||
}
|
|
||||||
|
|
||||||
// xnodes represents all xnodes in the selected lnodes
|
|
||||||
func (s Selection) xnodes() []*xnode {
|
|
||||||
xnodes := make([]*xnode, 0, s.countXNodes())
|
|
||||||
for _, L := range s.nodes {
|
|
||||||
for i, _ := range L.xnodes {
|
|
||||||
xnodes = append(xnodes, &L.xnodes[i])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return xnodes
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s Selection) countXNodes() int {
|
|
||||||
total := 0
|
|
||||||
for _, child := range s.nodes {
|
|
||||||
total += len(child.xnodes)
|
|
||||||
}
|
|
||||||
return total
|
|
||||||
}
|
|
||||||
|
|
||||||
// xleaves looks at all of the selected xnodes, and for every selected xnode,
|
|
||||||
// traverses the x graph until we arrive at the set of all leaf nodes that have
|
|
||||||
// a selected ancestor. If the selection consists of the root node, the xleaves
|
|
||||||
// are all of the leaves of the x graph.
|
|
||||||
func (s *Selection) xleaves() []*xnode {
|
|
||||||
// honestly think that by definition every xnode in the selection has a
|
|
||||||
// non-overlapping set of leaves but thinking about this shit is extremely
|
|
||||||
// starting to hurt my brain so I'm going to write this in a way that's
|
|
||||||
// maybe very redundant.
|
|
||||||
|
|
||||||
seen := make(map[string]bool)
|
|
||||||
var leaves []*xnode
|
|
||||||
for _, x := range s.xnodes() {
|
|
||||||
for _, leaf := range x.leaves() {
|
|
||||||
if seen[leaf.label()] {
|
|
||||||
panic("double-counting leaves somehow")
|
|
||||||
}
|
|
||||||
seen[leaf.label()] = true
|
|
||||||
leaves = append(leaves, leaf)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return leaves
|
|
||||||
}
|
|
||||||
@ -1,219 +0,0 @@
|
|||||||
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() {
|
|
||||||
for _, leaf := range X.leaves() {
|
|
||||||
XLeavesWanted.add(leaf.label())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
XLeavesWanted.report(t)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSelections(t *testing.T) {
|
|
||||||
tests := []selectionTest{
|
|
||||||
{
|
|
||||||
label: "new selection",
|
|
||||||
selection: NewSelection(A),
|
|
||||||
lnodes: []string{"A"},
|
|
||||||
xnodes: []string{"A.0"},
|
|
||||||
xleaves: []string{"A.0"},
|
|
||||||
},
|
|
||||||
{
|
|
||||||
label: "root with one child",
|
|
||||||
selection: NewSelection(A).Child(B),
|
|
||||||
lnodes: []string{"B"},
|
|
||||||
xnodes: []string{"B.0.A"},
|
|
||||||
xleaves: []string{"B.0.A"},
|
|
||||||
},
|
|
||||||
{
|
|
||||||
label: "two selected roots",
|
|
||||||
selection: NewSelection(A).And(NewSelection(B)),
|
|
||||||
lnodes: []string{"A", "B"},
|
|
||||||
xnodes: []string{"A.0", "B.0"},
|
|
||||||
xleaves: []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"},
|
|
||||||
xleaves: []string{"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"},
|
|
||||||
xleaves: []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"},
|
|
||||||
xleaves: []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"},
|
|
||||||
xleaves: []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"},
|
|
||||||
xleaves: []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"},
|
|
||||||
xleaves: []string{"E.0.D", "E.1.D"},
|
|
||||||
}
|
|
||||||
})
|
|
||||||
|
|
||||||
// A
|
|
||||||
// / \
|
|
||||||
// / \
|
|
||||||
// B C
|
|
||||||
// / \ / \
|
|
||||||
// / \ / \
|
|
||||||
// D E F
|
|
||||||
// / \ / \
|
|
||||||
// / \ / \
|
|
||||||
// G H I
|
|
||||||
// | | |
|
|
||||||
// | | |
|
|
||||||
// J K L
|
|
||||||
// | \ /
|
|
||||||
// | \ /
|
|
||||||
// M N
|
|
||||||
//
|
|
||||||
add(func() selectionTest {
|
|
||||||
root := NewSelection(A)
|
|
||||||
b := root.Child(B)
|
|
||||||
c := root.Child(C)
|
|
||||||
b.Child(D)
|
|
||||||
e := b.And(c).Child(E)
|
|
||||||
f := c.Child(F)
|
|
||||||
e.Child(G).Child(J).Child(M)
|
|
||||||
h := e.And(f).Child(H)
|
|
||||||
l := f.Child(I).Child(L)
|
|
||||||
k := h.Child(K)
|
|
||||||
k.And(l).Child(N)
|
|
||||||
return selectionTest{
|
|
||||||
label: "criss-crossing",
|
|
||||||
selection: root,
|
|
||||||
lnodes: []string{"A"},
|
|
||||||
xnodes: []string{"A.0"},
|
|
||||||
xleaves: []string{
|
|
||||||
"D.0.B", // A B D
|
|
||||||
"M.0.J", // A B E G J M
|
|
||||||
"M.1.J", // A C E G J M
|
|
||||||
"N.0.K", // A B E H K N
|
|
||||||
"N.1.K", // A C E H K N
|
|
||||||
"N.2.K", // A C F H K N
|
|
||||||
"N.3.L", // A C F I L N
|
|
||||||
},
|
|
||||||
}
|
|
||||||
})
|
|
||||||
|
|
||||||
add(func() selectionTest {
|
|
||||||
root := NewSelection(A)
|
|
||||||
b := root.Child(B)
|
|
||||||
c := root.Child(C)
|
|
||||||
b.Child(D)
|
|
||||||
e := b.And(c).Child(E)
|
|
||||||
f := c.Child(F)
|
|
||||||
e.Child(G).Child(J).Child(M)
|
|
||||||
h := e.And(f).Child(H)
|
|
||||||
l := f.Child(I).Child(L)
|
|
||||||
k := h.Child(K)
|
|
||||||
k.And(l).Child(N)
|
|
||||||
return selectionTest{
|
|
||||||
label: "criss-crossing-partial",
|
|
||||||
selection: e,
|
|
||||||
lnodes: []string{"E"},
|
|
||||||
xnodes: []string{"E.0.B", "E.1.C"},
|
|
||||||
xleaves: []string{
|
|
||||||
"M.0.J", // A B E G J M
|
|
||||||
"M.1.J", // A C E G J M
|
|
||||||
"N.0.K", // A B E H K N
|
|
||||||
"N.1.K", // A C E H K N
|
|
||||||
},
|
|
||||||
}
|
|
||||||
})
|
|
||||||
|
|
||||||
for _, test := range tests {
|
|
||||||
t.Run(test.label, test.Run)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue