Source: report_value.go in package github.com/google/go-cmp/cmp


package cmp

import "reflect"

valueNode represents a single node within a report, which is a structured representation of the value tree, containing information regarding which nodes are equal or not.

type valueNode struct {
	parent *valueNode

	Type   reflect.Type
	ValueX reflect.Value
	ValueY reflect.Value

NumSame is the number of leaf nodes that are equal. All descendants are equal only if NumDiff is 0.

NumDiff is the number of leaf nodes that are not equal.

NumIgnored is the number of leaf nodes that are ignored.

NumCompared is the number of leaf nodes that were compared using an Equal method or Comparer function.

NumTransformed is the number of non-leaf nodes that were transformed.

NumChildren is the number of transitive descendants of this node. This counts from zero; thus, leaf nodes have no descendants.

MaxDepth is the maximum depth of the tree. This counts from zero; thus, leaf nodes have a depth of zero.

	MaxDepth int

Records is a list of struct fields, slice elements, or map entries.

	Records []reportRecord // If populated, implies Value is not populated

Value is the result of a transformation, pointer indirect, of type assertion.

	Value *valueNode // If populated, implies Records is not populated

TransformerName is the name of the transformer.

	TransformerName string // If non-empty, implies Value is populated
}
type reportRecord struct {
	Key   reflect.Value // Invalid for slice element
	Value *valueNode
}

func (parent *valueNode) PushStep(ps PathStep) (child *valueNode) {
	vx, vy := ps.Values()
	child = &valueNode{parent: parent, Type: ps.Type(), ValueX: vx, ValueY: vy}
	switch s := ps.(type) {
	case StructField:
		assert(parent.Value == nil)
		parent.Records = append(parent.Records, reportRecord{Key: reflect.ValueOf(s.Name()), Value: child})
	case SliceIndex:
		assert(parent.Value == nil)
		parent.Records = append(parent.Records, reportRecord{Value: child})
	case MapIndex:
		assert(parent.Value == nil)
		parent.Records = append(parent.Records, reportRecord{Key: s.Key(), Value: child})
	case Indirect:
		assert(parent.Value == nil && parent.Records == nil)
		parent.Value = child
	case TypeAssertion:
		assert(parent.Value == nil && parent.Records == nil)
		parent.Value = child
	case Transform:
		assert(parent.Value == nil && parent.Records == nil)
		parent.Value = child
		parent.TransformerName = s.Name()
		parent.NumTransformed++
	default:
		assert(parent == nil) // Must be the root step
	}
	return child
}

func (r *valueNode) Report(rs Result) {
	assert(r.MaxDepth == 0) // May only be called on leaf nodes

	if rs.ByIgnore() {
		r.NumIgnored++
	} else {
		if rs.Equal() {
			r.NumSame++
		} else {
			r.NumDiff++
		}
	}
	assert(r.NumSame+r.NumDiff+r.NumIgnored == 1)

	if rs.ByMethod() {
		r.NumCompared++
	}
	if rs.ByFunc() {
		r.NumCompared++
	}
	assert(r.NumCompared <= 1)
}

func (child *valueNode) PopStep() (parent *valueNode) {
	if child.parent == nil {
		return nil
	}
	parent = child.parent
	parent.NumSame += child.NumSame
	parent.NumDiff += child.NumDiff
	parent.NumIgnored += child.NumIgnored
	parent.NumCompared += child.NumCompared
	parent.NumTransformed += child.NumTransformed
	parent.NumChildren += child.NumChildren + 1
	if parent.MaxDepth < child.MaxDepth+1 {
		parent.MaxDepth = child.MaxDepth + 1
	}
	return parent