|
|
|
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, parents ...*lnode) *lnode {
|
|
|
|
if len(parents) == 0 {
|
|
|
|
return rootLNode(test)
|
|
|
|
}
|
|
|
|
|
|
|
|
id := nextNodeID()
|
|
|
|
node := lnode{
|
|
|
|
id: id,
|
|
|
|
name: parseName(test),
|
|
|
|
test: test,
|
|
|
|
parents: parents,
|
|
|
|
}
|
|
|
|
|
|
|
|
xID := 0
|
|
|
|
for _, parent := range parents {
|
|
|
|
for i, _ := range parent.xnodes {
|
|
|
|
node.xnodes = append(node.xnodes, xnode{
|
|
|
|
id: xID,
|
|
|
|
lnode: &node,
|
|
|
|
parent: &parent.xnodes[i],
|
|
|
|
})
|
|
|
|
xID++
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for i, _ := range node.xnodes {
|
|
|
|
xparent := node.xnodes[i]
|
|
|
|
xparent.children = append(xparent.children, &node.xnodes[i])
|
|
|
|
}
|
|
|
|
return &node
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
// child adds an lnode as a child of the receiver. For every xnode in this
|
|
|
|
// receiver, the child lnode has a component xnode whose parent is the
|
|
|
|
// corresponding xnode in this lnode.
|
|
|
|
func (l *lnode) child(c *lnode, t Test) {
|
|
|
|
panic("nuh")
|
|
|
|
//c.parents = append(c.parents, l)
|
|
|
|
//l.children = append(l.children, c)
|
|
|
|
//for i, x := range l.xnodes {
|
|
|
|
// xchild := x.child(t)
|
|
|
|
// xchild.lnode = c
|
|
|
|
// xchild.id = i
|
|
|
|
// c.xnodes = append(c.xnodes, xchild)
|
|
|
|
//}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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 newXNode(L *lnode
|
|
|
|
|
|
|
|
func (x *xnode) child(t Test) *xnode {
|
|
|
|
panic("no")
|
|
|
|
// child := &xnode{test: t, parent: x}
|
|
|
|
// x.children = append(x.children, child)
|
|
|
|
// return child
|
|
|
|
}
|
|
|
|
|
|
|
|
func (x *xnode) isOnlyTestInLNode() bool {
|
|
|
|
return len(x.lnode.children) == 1
|
|
|
|
}
|
|
|
|
|
|
|
|
func (x *xnode) label() string {
|
|
|
|
if x.isOnlyTestInLNode() {
|
|
|
|
return x.lnode.name
|
|
|
|
}
|
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ancestry gives a slice of xnodes beginning at the root of the x graph and
|
|
|
|
// terminating at the receiver xnode.
|
|
|
|
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
|
|
|
|
}
|