Function TestExceedsDepthBoundedTraversal

common/ast/navigable_test.go:269–302

(t *testing.T)

}

func TestExceedsDepthBoundedTraversal(t *testing.T) {
	// Build a synthetic AST nested far deeper than the parser's recursion limit would ever produce.
	// This is exactly the shape ExceedsDepth guards against, since such an AST can only enter through
	// proto loading rather than the parser. Stacking depth unary '!' calls on a literal places the
	// deepest node (the literal) at NavigableExpr.Depth() == depth.
	const depth = 300
	fac := ast.NewExprFactory()
	expr := fac.NewLiteral(1, types.Bool(true))
	for i := 0; i < depth; i++ {
		expr = fac.NewCall(int64(i+2), operators.LogicalNot, expr)
	}
	deep := ast.NewAST(expr, ast.NewSourceInfo(nil))

	tests := []struct {
		name     string
		maxDepth int
		want     bool
	}{
		{name: "below the deepest node", maxDepth: 250, want: true},
		// The traversal is bounded to maxDepth+1 levels, so it must still descend far enough to
		// observe a node sitting exactly at maxDepth.
		{name: "equal to the deepest node", maxDepth: depth, want: true},
		{name: "one past the deepest node", maxDepth: depth + 1, want: false},
		{name: "check disabled", maxDepth: 0, want: false},
	}
	for _, tst := range tests {
		tc := tst
		t.Run(tc.name, func(t *testing.T) {
			if got := ast.ExceedsDepth(deep, tc.maxDepth); got != tc.want {
				t.Errorf("ExceedsDepth(deepAST(%d), %d) = %v, wanted %v", depth, tc.maxDepth, got, tc.want)
			}
		})
	}
}

func TestNavigableASTNilSafety(t *testing.T) {
	tests := []struct {