then:
        1 * visitor.visitCause(cause)
        1 * visitor.endVisiting()
        0 * visitor._

        and:
        e.reportableCauses == []
    }

    def "visitor visits indirect cause"() {
        def childCause = new RuntimeException()
        def cause = new RuntimeException(childCause)
        def e = new ContextAwareException(cause)

        when:
        e.accept(visitor)

	//
	// The "direct" map controls which modules are annotated with "// indirect"
	// comments in the go.mod file, and may impact which modules are listed as
	// explicit roots (vs. indirect-only dependencies). However, it should not
	// have a semantic effect on the build list overall.
	//
	// The initial direct map is populated from the existing "// indirect"
	// comments (or lack thereof) in the go.mod file. It is updated by the

			e = e.overflow.Load()
		}
		return
	}
	i := n.indirect()
	fmt.Printf("%s%p [Indirect Parent=%p Dead=%t Children=[", prefix, i, i.parent, i.dead.Load())
	for j := range i.children {
		c := i.children[j].Load()
		fmt.Printf("%p", c)
		if j != len(i.children)-1 {
			fmt.Printf(", ")

// crash 3
type t3 *interface{ t3.p /* ERROR "t3.p is not a type" */ }

// crash 4
type Numeric4 interface{t4 /* ERROR "not a type" */ }
func t4[T Numeric4](s[]T){if( /* ERROR "non-boolean" */ 0){*s /* ERROR "cannot indirect" */ [0]}}

// crash 7
type foo7 interface { bar() }
type x7[A any] struct{ foo7 }
func main7() { var _ foo7 = x7[int]{} }

// crash 8
type foo8[A any] interface { ~A /* ERROR "cannot be a type parameter" */ }

				vars[idx] = nullStr
			} else if valuer, ok := v.(driver.Valuer); ok {
				v, _ = valuer.Value()
				convertParams(v, idx)
			} else if rv.Kind() == reflect.Ptr && !rv.IsZero() {
				convertParams(reflect.Indirect(rv).Interface(), idx)
			} else if isNumeric(rv.Kind()) {
				if rv.CanInt() || rv.CanUint() {
					vars[idx] = fmt.Sprintf("%d", rv.Interface())
				} else {
					vars[idx] = fmt.Sprintf("%.6f", rv.Interface())

	NotNil(ii, t)

	var fi struct {
		x func(t *testing.T)
	}
	Nil(fi, t)
	fi.x = TestIsNil
	NotNil(fi, t)
}

// Indirect returns the value that v points to.
// If v is a nil pointer, Indirect returns a zero Value.
// If v is not a pointer, Indirect returns v.
func Indirect(v Value) Value {
	if v.Kind() != Ptr {
		return v
	}
	return v.Elem()
}

func TestNilPtrValueSub(t *testing.T) {

        !ModelPath.path("a.b").isDescendant(ModelPath.path("c.a.b.c"))
        !ModelPath.path("a.b").isDescendant(null)
    }

    def "can create paths for indirect descendants"() {
        expect:
        ModelPath.ROOT.descendant(ModelPath.path("c.d")) == ModelPath.path("c.d")
        ModelPath.path("a.b").descendant(ModelPath.path("c.d")) == ModelPath.path("a.b.c.d")
    }

                require '1.0'
                reject('1.1', '1.2')
            }
        }
        hasDependency('shortcut') {
            withGAV('g', 'a', '1.0')
        }
        hasDependency('indirect') {
            withGAV('g', 'b', '1.2')
        }
        hasDependency('incremental') {
            withGroup 'group'
            withName 'name'
            withVersion {

      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY