127.0.0.1 test
127.0.0.2 test2.example.com 2.test
127.0.0.3 3.test test3.example.com
127.0.0.4 example.com
127.0.0.5 test4.example.com 4.test 5.test test5.example.com

# must be a non resolvable domain on the internet

	m1v("")
	m2v := b1.m2
	m2v("")
	b2v := b2.m2
	b2v("")
}

// actual test case from issue

type A[T any] struct{}

func (*A[T]) f(T) {}

type B[T any] struct{ A[T] }

func test3() {
	var b B[string]
	b.A.f("")
	b.f("")
}

func main() {
	test1[string]("")
	test2()
	test3()

package main

import "./a"

// Testing inlining of functions that refer to instantiated exported and non-exported
// generic types.

func main() {
	a.Test1()
	a.Test2()
	a.Test3()

			rows: []metav1.TableRow{
				{Cells: []interface{}{"test1", "1/1", "podPhase", int64(5), "20h"}},
				{Cells: []interface{}{"test2", "1/2", "podPhase", int64(30), "21h"}},
				{Cells: []interface{}{"test3", "4/4", "podPhase", int64(1), "22h"}},
			},
			options: PrintOptions{},
			expected: `NAME    READY   STATUS
test1   1/1     podPhase
test2   1/2     podPhase
test3   4/4     podPhase
`,
		},

}

func Test2(t *testing.T) {
	t.Parallel()

	_ = filter.New()
}

func Test3(t *testing.T) {
	t.Parallel()

	_ = filter.New()
}

func Test4(t *testing.T) {
	t.Parallel()

	_ = filter.New()

    def "downloads artifacts in parallel from a Maven repo - #expression"() {
        def m1 = mavenRepo.module('test', 'test1', '1.0').publish()
        def m2 = mavenRepo.module('test', 'test2', '1.0').publish()
        def m3 = mavenRepo.module('test', 'test3', '1.0').publish()
        def m4 = mavenRepo.module('test', 'test4', '1.0').publish()

        buildFile << """
            repositories {
                maven {

  parent.Set(String("test3"), Integer(3));
  Object child;
  child.Set(String("test1"), Integer(1));
  child.Set(String("test2"), Integer(2));
  child.Set(Object::ParentKey(), parent);
  EXPECT_EQ(child.Get<Integer>(String("test1"))->get(), 1);
  EXPECT_EQ(child.Get<Integer>(String("test2"))->get(), 2);
  EXPECT_EQ(child.Get<Integer>(String("test3"))->get(), 3);
  ASSERT_FALSE(child.Get<Integer>(String("test4")).status().ok());

        run 'show'

        then:
        outputContains("files: [test-1.0, test-1.0, test-1.0-classy]")
        outputContains("display-names: [test-1.0 (org:test:1.0), test-1.0 (org:test:1.0), test-1.0-classy (org:test:1.0)]")
        outputContains("ids: [test-1.0 (org:test:1.0), test-1.0 (org:test:1.0), test-1.0-classy (org:test:1.0)]")
        outputContains("names: [test::jar, test::, test::]")
        outputContains("classifiers: [null, null, classy]")

}

type Val[T comparable] struct {
	val T
}

//go:noinline
func (l *Val[T]) check(want T) {
	if l.val != want {
		panic("hi")
	}
}

func Test1() {
	var l Val[int]
	if l.val != 0 {
		panic("hi")
	}
	_ = IVal[int](&l)
}

func Test2() {
	var l Val[float64]
	l.val = 3.0
	l.check(float64(3))
	_ = IVal[float64](&l)
}

type privateVal[T comparable] struct {
	val T
}

	go func() {
		if err := http.Serve(unixListener, mux); err != nil {
			t.Error(err)
		}
	}()

	{
		t.Log("test sending normal log")

		WithLabels("k", "v").Info("test")
		Warn("test2")
		Sync()

		// There should be two messages received at server
		// {"msg":"test","k":"v"}
		// {"msg":"test2"}
		if got, want := len(srv.messages), 2; got != want {
			t.Fatalf("number received log messages got %v want %v", got, want)