foo243()
	foo244()
	foo245()
	foo246()
	foo247()
	foo248()
	foo249()
	foo250()
	foo251()
	foo252()
	foo253()
	foo254()
	foo255()
	foo256()
	foo257()
	foo258()
	foo259()
	foo260()
	foo261()
	foo262()
	foo263()
	foo264()
	foo265()
	foo266()
	foo267()
	foo268()
	foo269()
	foo270()
	foo271()
	foo272()
	foo273()
	foo274()
	foo275()

# library contains "foo1", "foo2", ..., "foo20", from which "foo1" and "foo11"
# were mapped to the same name "foo110" in the bug.
node {
  name: "unnamed"
  op: "foo1"
}
node {
  name: "unnamed1"
  op: "foo11"
}
library {
  function {
    signature {
      name: "foo1"
    }
  }
  function {
    signature {
      name: "foo2"
    }
  }
  function {
    signature {

// does not leak x but does leak content
func foo105(x []*int) { // ERROR "leaking param content: x"
	_ = append(y, x...)
}

// does leak x
func foo106(x *int) { // ERROR "leaking param: x$"
	_ = append(y, x)
}

func foo107(x *int) map[*int]*int { // ERROR "leaking param: x$"
	return map[*int]*int{x: nil} // ERROR "map\[\*int\]\*int{...} escapes to heap$"
}

func foo108(x *int) map[*int]*int { // ERROR "leaking param: x$"

				c.Set("foo1", "bar")
				c.Set("foo2", "bar")
				c.Set("foo3", "bar")
				c.Set("foo4", "bar")
				c.Set("foo5", "bar")
				c.Set("foo6", "bar")
				c.Set("foo7", "bar")
			}
			wg.Done()
		}()
	}
	wg.Wait()
}

func benchmarkCacheGetSetConcurrent(c Cache, b *testing.B) {
	c.Set("foo1", "bar")
	c.Set("foo2", "bar")
	c.Set("foo3", "bar")
	c.Set("foo4", "bar")

				makeGCContainer("foo1", "baz", 0, 0, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo2", "bar", 2, 2, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo2", "bar", 1, 1, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo2", "bar", 0, 0, runtimeapi.ContainerState_CONTAINER_EXITED),
			},
			remain:               []int{0, 1, 3, 4, 6, 7},

	_ = x.foo2 // ERROR "x.foo2 undefined (type S has no field or method foo2, but does have field FoO2)"
	_ = x.foo3 // OK
	_ = x.foo4 // ERROR "x.foo4 undefined (type S has no field or method foo4, but does have field foO4)"
}

func _() {
	_ = S{Foo1: 0} // OK
	_ = S{Foo2 /* ERROR "unknown field Foo2 in struct literal of type S, but does have FoO2" */ : 0}

        }
    }

    void 'dependency updated through constraints has its transitive dependencies'() {
        given:
        def foo10 = mavenRepo.module('org', 'foo', '1.0').publish()
        mavenRepo.module('org', 'bar', '1.0').publish()
        mavenRepo.module('org', 'bar', '1.1').dependsOn(foo10).publish()
        writeSpec {
            rootProject {
                dependencies {
                    conf 'org:bar:1.0'

				{"foo2", "foo2.bar.com", "192.1.1.2"},
				{"foo3", "foo3.bar.com", "192.1.1.3"},
			},
		},
		{
			desc: "update-delete-and-create-resources",
			resources: []*anypb.Any{
				constructResource("foo2", "foo2.bar.com", "192.1.1.222", "4"),
				constructResource("foo4", "foo4.bar.com", "192.1.1.4", "1"),
			},
			expectedResources: [][]string{
				{"foo2", "foo2.bar.com", "192.1.1.222"},

                       assert files.collect { it.name } == ['b-foo2.jar']
                    }
                }
            }
            project(':b') {
                configurations {
                    foo {
                        attributes { $debug; attribute(flavor, objects.named(Flavor, "ONE")) }
                    }
                    foo2 {

            void foo2() {
                printf("foo2");
            }
        """)]
    }

    @Override
    List<SourceFile> getHeaderFiles() {
        [sourceFile("headers", "foo.h", """
           void foo1();
           void foo2();
           """)]
    }