Name: name,
					},
				},
			}
			container.EnvFrom = append(container.EnvFrom, envFrom)
		}

		for _, name := range configMaps.envVarNames {
			envSource := &v1.EnvVarSource{
				ConfigMapKeyRef: &v1.ConfigMapKeySelector{
					LocalObjectReference: v1.LocalObjectReference{
						Name: name,
					},
				},
			}
			container.Env = append(container.Env, v1.EnvVar{ValueFrom: envSource})

    FUN name:consume visibility:public modality:FINAL <> (n:kotlin.Int) returnType:kotlin.Unit
      VALUE_PARAMETER name:n index:0 type:kotlin.Int
      BLOCK_BODY
    FUN name:test visibility:public modality:FINAL <> (x:kotlin.Int) returnType:kotlin.Unit
      VALUE_PARAMETER name:x index:0 type:kotlin.Int
      BLOCK_BODY
        FUN LOCAL_FUNCTION name:call visibility:local modality:FINAL <> () returnType:kotlin.Unit

	for _, test := range tests {
		pkg := mustTypecheck(test.src, nil, nil)

		t.Run(pkg.Name(), func(t *testing.T) {
			ctxt := NewContext()

			T1 := pkg.Scope().Lookup(test.name1).Type()
			res1, err := Instantiate(ctxt, T1, test.targs1, false)
			if err != nil {
				t.Fatal(err)
			}

			T2 := pkg.Scope().Lookup(test.name2).Type()
			res2, err := Instantiate(ctxt, T2, test.targs2, false)
			if err != nil {

                        help="sub claim. If not provided, it is set to the same as iss claim.")
    parser.add_argument("-claims", "--claims",
                        help="Other claims in format name1:value1,name2:value2 etc. Only string values are supported.")

        $this: VALUE_PARAMETER name:<this> type:kotlin.Any
      FUN name:test visibility:public modality:FINAL <> ($this:<root>.Foo, $receiver:kotlin.String) returnType:kotlin.Unit
        $this: VALUE_PARAMETER name:<this> type:<root>.Foo
        $receiver: VALUE_PARAMETER name:<this> type:kotlin.String
        BLOCK_BODY
          VAR name:x type:kotlin.Int [var]

                        help="sub claim. If not provided, it is set to the same as iss claim.")
    parser.add_argument("-claims", "--claims",
                        help="Other claims in format name1:value1,name2:value2 etc. Only string values are supported.")
    parser.add_argument("-jwks", "--jwks",
                        help="Path to the output file for JWKS.")

			data = data[dirent.Reclen:]
			name := make([]byte, dirent.Namlen)
			for i := 0; i < int(dirent.Namlen); i++ {
				name[i] = byte(dirent.Name[i])
			}
			names2 = append(names2, string(name))
		}
	}

	names = append(names, ".", "..") // Getdirentries returns these also
	slices.Sort(names)
	slices.Sort(names2)
	if strings.Join(names, ":") != strings.Join(names2, ":") {

			Name:      "name2",
			Namespace: "namespace",
		},
		Status: corev1.PodStatus{PodIP: "1.2.3.5"},
	}
	pc.CreateOrUpdateStatus(pod2)
	tt.WaitUnordered("add/namespace/name2")
	assert.Equal(t, Collection.Get(), ptr.Of("namespace/name,namespace/name2"))

	pc.Delete(pod.Name, pod.Namespace)
	pc.Delete(pod2.Name, pod2.Namespace)
	tt.WaitUnordered("delete/namespace/name", "delete/namespace/name2")

  EXPECT_EQ(names2[2], "linear_2/c1");
  EXPECT_EQ(names2[3], "linear_2/mul_1");
  EXPECT_EQ(names2[4], "linear_2");

  const auto names3 = LinearOp(root.WithOpName("c"));

  EXPECT_EQ(names3[0], "c/mul");
  EXPECT_EQ(names3[1], "c/bias_add");
  EXPECT_EQ(names3[2], "c/c1");
  EXPECT_EQ(names3[3], "c/mul_1");
  EXPECT_EQ(names3[4], "c");
}

TEST(ScopeTest, SingleUseScope) {

// errorcheck

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that basic operations on named types are valid
// and preserve the type.
// Does not compile.

package main

type Bool bool

type Map map[int]int

func (Map) M() {}

type Slice []byte

var slice Slice

func asBool(Bool)     {}