"genericArgs" | 'genericArgs(List<String>, Map<Integer, List<String>>)'
    }

    def "inner classes are described"() {
        when:
        def sb = new StringBuilder()
        MethodModelRuleDescriptor.of(weakMethod(Outer.Inner, "noArgs")).describeTo(sb)

        then:
        sb.toString() == 'MethodModelRuleDescriptorTest.Outer.Inner#noArgs()'
    }

    private WeaklyTypeReferencingMethod weakMethod(Class type, String name) {

		if k != 0 {
			panic("k not zero")
		} // inner loop breaks this one every time
		for i = 0; i < 2; i++ {
			if i != 0 {
				panic("i not zero")
			} // loop breaks every time
			r += fmt.Sprintln("inner loop top i", i)
			if true {
				r += "do break\n"
				break outer
			}
		}
	}
	r += "broke\n"
	expect := `outer loop top k 0
inner loop top i 0
do break
broke
`
	if r != expect {

			}

		case *BlockStmt:
			inner := targets{ctxt.breaks, ctxt.continues, -1}
			innerBlock(inner, s.Pos(), s.List)

		case *IfStmt:
			inner := targets{ctxt.breaks, ctxt.continues, -1}
			innerBlock(inner, s.Then.Pos(), s.Then.List)
			if s.Else != nil {
				innerBlock(inner, s.Else.Pos(), []Stmt{s.Else})
			}

		case *ForStmt:
			inner := targets{s, s, -1}

import java.io.IOException;

/**
 * Efficiently serializes hierarchical names, like Java class names or relative paths of resources.
 * Splits names into prefixes and suffixes along package separators, inner class separators, file separators and camel case borders.
 * Reuses these prefixes and suffixes to efficiently store names or parts of names it has seen before.
 *

	// Give the base type a chance to print the inner types.
	ps.inner = append(ps.inner, twq)
	ps.print(twq.Base)
	if len(ps.inner) > 0 {
		// The qualifier wasn't printed by Base.
		ps.writeByte(' ')
		ps.print(twq.Qualifiers)
		ps.inner = ps.inner[:len(ps.inner)-1]
	}
}

// Print qualifiers as an inner type by just printing the qualifiers.

version = "1.0.0"

repositories {
    mavenCentral()
}

dependencies {
    implementation 'commons-io:commons-io:2.6'
}

// tag::link-task-properties[]
// tag::inner-link-task-properties[]
def archivesDirPath = layout.buildDirectory.dir('archives')
// end::inner-link-task-properties[]

tasks.register('packageClasses', Zip) {
    archiveAppendix = "classes"
    destinationDirectory = archivesDirPath

    from compileJava
}

			dprintf(depth, "Link:\n")
			dumpInlines(in.Inner, depth+1)
			dprintf(depth+1, "URL: %q\n", in.URL)
		case *md.Strong:
			dprintf(depth, "Strong(%q):\n", in.Marker)
			dumpInlines(in.Inner, depth+1)
		case *md.Emph:
			dprintf(depth, "Emph(%q):\n", in.Marker)
			dumpInlines(in.Inner, depth+1)
		case *md.Del:
			dprintf(depth, "Del(%q):\n", in.Marker)
			dumpInlines(in.Inner, depth+1)
		default:

}

func (s *KubeSource) Create(config config.Config) (revision string, err error) {
	return s.inner.Create(config)
}

func (s *KubeSource) Update(config config.Config) (newRevision string, err error) {
	return s.inner.Update(config)
}

func (s *KubeSource) UpdateStatus(config config.Config) (newRevision string, err error) {
	return s.inner.UpdateStatus(config)
}

			}
			check.caseValues(&x, clause.List, seen)
			check.openScope(clause, "case")
			inner := inner
			if i+1 < len(s.Body.List) {
				inner |= fallthroughOk
			} else {
				inner |= finalSwitchCase
			}
			check.stmtList(inner, clause.Body)
			check.closeScope()
		}

	case *ast.TypeSwitchStmt:
		inner |= breakOk | inTypeSwitch
		check.openScope(s, "type switch")
		defer check.closeScope()

	// volumes is a nested map that forces a unique volumes. The outer map's
	// keys are a string that should specify the target component to add the
	// volume to. The values (inner map) of the outer map are maps with string
	// keys and v1.Volume values. The inner map's key should specify the volume
	// name.
	volumes map[string]map[string]v1.Volume
	// volumeMounts is a nested map that forces a unique volume mounts. The