var b1 B1[T]
	b1.A1 = &A1[T]{}
	b1.A2 = &ImpA2[T]{}

	b1.A1.m1(arg)
	b1.m1(arg)

	b1.A2.m2(arg)
	b1.m2(arg)

	var b2 B2[T]
	b2 = &ImpA2[T]{}
	b2.m2(arg)

	// a deeper nesting
	var d D[T]
	d.C.B1.A1 = &A1[T]{}
	d.C.B1.A2 = &ImpA2[T]{}
	d.m1(arg)
	d.m2(arg)

	// calling method expressions
	m1x := B1[T].m1
	m1x(b1, arg)
	// TODO(khr): reenable these.
	//m2x := B2[T].m2

	filler3 int
	C[T]
}

func _() {
	// calling embedded methods
	var b1 B1[string]

	b1.A1.m1("")
	b1.m1("")

	b1.A2.m2("")
	b1.m2("")

	var b2 B2[string]
	b2.m2("")

	// a deeper nesting
	var d D[string]
	d.m1("")
	d.m2("")

	// calling method expressions
	m1x := B1[string].m1
	m1x(b1, "")
	m2x := B2[string].m2
	m2x(b2, "")

	// calling method values
	m1v := b1.m1

						bang: &Bar{foo: []*Foo{
							&Foo{bar: &Bar{baz: &Baz{
								entries: map[int]interface{}{
									0:	&Foo{},
									-2:	&Bar{},
									-11:	&Baz{whatever: "we need to go deeper"}}}},
								bang: &Bar{foo: []*Foo{
									&Foo{bar: &Bar{baz: &Baz{
										entries: map[int]interface{}{
											-2:	&Foo{},
											-5:	&Bar{},
											-7:	&Baz{whatever: "are you serious?"}}}},

        instance.leaveCall(entryBar)
        instance.leaveCall(entryFoo)

        where:
        entryPointKind                 | index
        "has already been popped"      | 0
        "is still deeper in the stack" | 1
    }

    def 'throws an exception on instance.markCurrentCallAsIntercepted if its #part does not match'() {
        given:
        def entryFoo = instance.enterCall("FooCallerClass", "foo", INVOKE_METHOD)

import org.codehaus.plexus.configuration.PlexusConfigurationException;

/**
 * Exception which occurs to indicate that the plugin cannot be initialized due
 * to some deeper problem with Plexus. Context information includes the groupId,
 * artifactId, and version for the plugin; at times, the goal name for which
 * execution failed; a message detailing the problem; the ClassRealm used to

61: &Foo{},
71: &Bar{},
11: &Baz{ whatever: "no, it's Go" }}}},
        bang: &Bar{foo: []*Foo{
&Foo{bar: &Bar{ baz: &Baz{
entries: map[int]interface{}{
0: &Foo{},
-2: &Bar{},
-11: &Baz{ whatever: "we need to go deeper" }}}},
        bang: &Bar{foo: []*Foo{
&Foo{bar: &Bar{ baz: &Baz{
entries: map[int]interface{}{
-2: &Foo{},
-5: &Bar{},
-7: &Baz{ whatever: "are you serious?" }}}},
        bang: &Bar{foo: []*Foo{}}},

				// to empty to signify that has happened, and
				// there's no need to add this field.
				old.Name = ""
				add = false
			} else if len(w.index) < len(old.Index) {
				// The old field loses because it's deeper than the new one.
				old.Name = ""
			} else {
				// The old field wins because it's shallower than the new one.
				add = false
			}
		}
		if add {
			// Copy the index so that it's not overwritten

    // and that a proper implementation of an NTLM authenticator shouldn't do this
    // but those are test fixtures and I couldn't find a better way to do this
    // without deeper understanding of the Jetty APIs. Feel free to provide an
    // alternate solution
    private final Map<HttpConnection, NtlmConnectionAuthentication> connections = [:]

    @Override
    String getAuthMethod() {

        def cycle = new Tree(value: "cycle", left: new Tree(value: "left"))
        cycle.right = cycle
        task.nested = new Tree(value: "first", left: new Tree(value: "left"), right: new Tree(value: "deeper", left: cycle, right: new Tree(value: "no-cycle")))

        when:
        visitProperties(task)

        then:
        _ * visitor.visitNested() >> true

	}
}

// TryRLock tries to lock rw for reading and reports whether it succeeded.
//
// Note that while correct uses of TryRLock do exist, they are rare,
// and use of TryRLock is often a sign of a deeper problem
// in a particular use of mutexes.
func (rw *RWMutex) TryRLock() bool {
	if race.Enabled {
		_ = rw.w.state
		race.Disable()
	}
	for {
		c := rw.readerCount.Load()
		if c < 0 {
			if race.Enabled {