Michael Matloob <******@****.***> 1664988840 -0400

-- 122go.mod --
module example.com/x
go 1.22

require "foo.com/internal/bar" v1.0.0

-- go.mod --
module example.com/x
go 1.23

require "foo.com/internal/bar" v1.0.0

-- incorrect_modules.txt --
# foo.com/internal/bar v1.0.0
## explicit
foo.com/internal/bar/a

-- correct_modules.txt --
# foo.com/internal/bar v1.0.0
## explicit
foo.com/internal/bar/a
foo.com/internal/bar/b

            """,
            multifileAnnotations
        )
        givenKotlinScriptInBuildSrcContains(
            "bar",
            """
            fun bar() = "bar"
            """,
            multifileAnnotations
        )
        withUniqueScript("println($packageName.foo() + $packageName.bar())")
        configureProject().assertBuildScriptCompiled().assertOutputContains("foobar")

			in:  `foo.Bar[sync/atomic.Uint64]`,
			pkg: `foo`,
			sym: "Bar[sync/atomic.Uint64]",
		},
		{
			in:  `example%2ecom.Bar[sync/atomic.Uint64]`,
			pkg: `example%2ecom`,
			sym: "Bar[sync/atomic.Uint64]",
		},
		{
			in:  `gopkg.in/yaml%2ev3.Bar[sync/atomic.Uint64]`,
			pkg: `gopkg.in/yaml%2ev3`,
			sym: "Bar[sync/atomic.Uint64]",
		},
		{
			// This one is a real symbol name.

    Table<String, Integer, C> reordered = create("foo", 3, 'c', "foo", 1, 'a', "bar", 1, 'b');
    Table<String, Integer, C> smaller = create("foo", 1, 'a', "bar", 1, 'b');
    Table<String, Integer, C> swapOuter = create("bar", 1, 'a', "foo", 1, 'b', "bar", 3, 'c');
    Table<String, Integer, C> swapValues = create("foo", 1, 'c', "bar", 1, 'b', "foo", 3, 'a');

    new EqualsTester()

                newApi("Method", "Bar.fooExt(int)"),
                newApi("Method", "Bar.getBar()"),
                newApi("Method", "Bar.getBarExt(java.lang.String)"),
                newApi("Method", "Bar.getBazar()"),
                newApi("Method", "Bar.getBazarExt(int)"),
                newApi("Method", "Bar.getBazool()"),
                newApi("Method", "Bar.getBool()"),

                }

                fun bar(): String = foo()
            """,
            { assertThat(it.instantiateAndCall("bar"), equalTo("foo")) },
            """
                internal inline fun foo(): String {
                    return "bar"
                }

                fun bar(): String = foo()
            """,
            { assertThat(it.instantiateAndCall("bar"), equalTo("bar")) }
        ).assertSameApi()

    }

    static String setFooBar(String bar) {
        return setFoo(setBar(bar))
    }

    static String setBar(String bar) {
        return "bar = \"${bar}\"\n"
    }

    static String setFoo(String contents) {
        return "foo {\n${contents}\n}"
    }

    static String setAll(String id, String bar) {
        return setId(id) + "\n" + setFooBar(bar)
    }

    map.put("quux", 3);

    map.remove("bar");
    assertThat(map.entrySet())
        .containsExactly(Maps.immutableEntry("foo", 1), Maps.immutableEntry("quux", 3))
        .inOrder();
  }

  public void testInsertionOrderAfterRemoveLast() {
    BiMap<String, Integer> map = HashBiMap.create();
    map.put("foo", 1);
    map.put("bar", 2);
    map.put("quux", 3);

    map.remove("quux");

# Only the linker and buildid tool should be needed.

mkdir bar
cp foo/main.go bar/main.go
cd bar
go build -x -o a.exe main.go
! stderr ${/}compile$GOEXE

go tool buildid a.exe
cp stdout ../bar-buildid.txt
go version a.exe
cp stdout ../bar-version.txt
cd ..

cmp bar-buildid.txt foo-buildid.txt
cmp bar-version.txt foo-version.txt
cmp bar/a.exe foo/a.exe


-- $WORK/tmp/foo/main.go --
package main