// WARNING: in.Target requires manual conversion: does not exist in peer-type
	// WARNING: in.MetricName requires manual conversion: does not exist in peer-type
	// WARNING: in.CurrentValue requires manual conversion: does not exist in peer-type
	// WARNING: in.Selector requires manual conversion: does not exist in peer-type
	// WARNING: in.AverageValue requires manual conversion: does not exist in peer-type
	return nil
}

	}
}

func test2(iter int) {

	const maxI = 500
	m := make(map[int][]int) // ERROR "make\(map\[int\]\[\]int\) does not escape$"

	// var fn func()
	for i := 0; i < maxI; i++ {
		var fn func() // this makes it work, because fn stays off heap
		j := 0
		fn = func() { // ERROR "func literal does not escape$"
			m[i] = append(m[i], 0)

     * Does not calculate the value on demand and does not block if the value is currently being calculated.
     *
     * <p>Rethrows any exception that happened while calculating the value</p>
     */
    T get() throws IllegalStateException;

    /**
     * Returns the result of calculating the value, failing if it has not been calculated.

	f := t.noescape // ERROR "t.noescape does not escape"
	f()
}

func f2() {
	var t T       // ERROR "moved to heap"
	f := t.escape // ERROR "t.escape does not escape"
	f()
}

func f3() {
	var t T        // ERROR "moved to heap"
	f := t.returns // ERROR "t.returns does not escape"
	sink = f()
}

type T struct{}

func (t *T) noescape()   {}           // ERROR "t does not escape"

	// WARNING: in.Target requires manual conversion: does not exist in peer-type
	// WARNING: in.MetricName requires manual conversion: does not exist in peer-type
	// WARNING: in.CurrentValue requires manual conversion: does not exist in peer-type
	// WARNING: in.Selector requires manual conversion: does not exist in peer-type
	// WARNING: in.AverageValue requires manual conversion: does not exist in peer-type
	return nil
}

        def collector = new FormattingValidationProblemCollector("<thing>", ModelType.of(String))
        collector.add("does not extend RuleSource")
        collector.add("does not have any rule method")

        expect:
        collector.format() == '''Type java.lang.String is not a valid <thing>:
- does not extend RuleSource
- does not have any rule method'''
    }

    static class SuperClass {
        private String value

    }

    def "does not select items when no matches"() {
        expect:
        doesNotMatch("name")
        doesNotMatch("name", "other")
        doesNotMatch("name", "na")
        doesNotMatch("sN", "otherName")
        doesNotMatch("sA", "someThing")
        doesNotMatch("soN", "saN")
        doesNotMatch("soN", "saName")
    }

    def "does not select items when multiple camel case matches"() {

	v6 = f4
	v7 = f4 // ERROR "inferred type func(int, int) for func(P, P) does not match type func(int, string) of v7"
	v8 = f5
	v9 = f5 // ERROR "inferred type func(string) []string for func(P) []P does not match type func(string) []int of v9"

	// non-trivial LHS
	var a [2]func(string) []int
	a[0] = f5 // ERROR "inferred type func(string) []string for func(P) []P does not match type func(string) []int of a[0]"
}

// Return statements

// using the provided remove function. It removes everything it can but returns
// the first error it encounters. If the path does not exist, RemoveAll
// returns nil (no error).
// It makes sure it does not cross mount boundary, i.e. it does *not* remove
// files from another filesystems. Like 'rm -rf --one-file-system'.
// It is copied from RemoveAll() sources, with IsLikelyNotMountPoint

func f1(x, y float64, z int) float64 {
	a := x + y  // generate flags
	if z == 0 { // create basic block that does not clobber flags
		return a
	}
	if a > 0 { // use flags in different basic block
		return y
	}
	return x
}

func f2(x, y float64, z int) float64 {
	a := x - y  // generate flags
	if z == 0 { // create basic block that does not clobber flags
		return a
	}
	if a > 0 { // use flags in different basic block
		return y