{
					Key:    "foo_2",
					Effect: v1.TaintEffectNoSchedule,
				},
				{
					Key:    "foo_3",
					Effect: v1.TaintEffectNoSchedule,
				},
			},
			expectedResult: "foo_2,foo_3",
		},
	}

	for _, c := range cases {
		result := CheckIfTaintsAlreadyExists(oldTaints, c.taintsToCheck)
		if result != c.expectedResult {

  EXPECT_EQ(root.GetUniqueNameForOp("foo"), "foo");
  EXPECT_EQ(root.GetUniqueNameForOp("foo"), "foo_1");
  EXPECT_EQ(root.GetUniqueNameForOp("foo_1"), "foo_1_1");
  EXPECT_EQ(root.GetUniqueNameForOp("foo_2"), "foo_2");
  EXPECT_EQ(root.GetUniqueNameForOp("foo"), "foo_3");
  EXPECT_EQ(root.GetUniqueNameForOp("foo_2"), "foo_2_1");
}

TEST(ScopeTest, HierarchicalNames) {
  Scope root = Scope::NewRootScope();

    }
  }
  function {
    signature {
      name: "foo11"
    }
  }
  function {
    signature {
      name: "foo12"
    }
  }
  function {
    signature {
      name: "foo13"
    }
  }
  function {
    signature {
      name: "foo14"
    }
  }
  function {
    signature {
      name: "foo15"
    }
  }
  function {
    signature {
      name: "foo16"

.../dataset/**/<testname>_<stageNo>_expected.json

e.g.
# First stage files. Meshconfig carries over to the next stage
.../dataset/**/foo_0.yaml
.../dataset/**/foo_0_meshconfig.yaml
.../dataset/**/foo_0_expected.json
# Second stage files.
.../dataset/**/foo_1.yaml
.../dataset/**/foo_1_expected.json

```

The expected file structure is as follows:

```json
{
  "collection": [
    {

	f.xx = &x
}

func foo43(f *Foo, x int) { // ERROR "f does not escape$" "moved to heap: x$"
	f.xx = &x
}

func foo44(yy *int) { // ERROR "leaking param: yy$"
	F.xx = yy
}

func (f *Foo) foo45() { // ERROR "f does not escape$"
	F.x = f.x
}

// See foo13 above for explanation of why f leaks.

	f.xx = &x
}

func foo43(f *Foo, x int) { // ERROR "f does not escape$" "moved to heap: x$"
	f.xx = &x
}

func foo44(yy *int) { // ERROR "leaking param: yy$"
	F.xx = yy
}

func (f *Foo) foo45() { // ERROR "f does not escape$"
	F.x = f.x
}

// See foo13 above for explanation of why f leaks.

import (
	"reflect"
	"testing"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func TestCloneAndAddLabel(t *testing.T) {
	labels := map[string]string{
		"foo1": "bar1",
		"foo2": "bar2",
		"foo3": "bar3",
	}

	cases := []struct {
		labels     map[string]string
		labelKey   string
		labelValue string
		want       map[string]string
	}{
		{
			labels: labels,
			want:   labels,
		},
		{

package a

type I interface {
	F()
}

type foo1 []byte
type foo2 []rune
type foo3 []uint8
type foo4 []int32
type foo5 string
type foo6 string
type foo7 string
type foo8 string
type foo9 string

func (f foo1) F() { return }
func (f foo2) F() { return }
func (f foo3) F() { return }
func (f foo4) F() { return }
func (f foo5) F() { return }
func (f foo6) F() { return }

limitations under the License.
*/

package v1

import (
	"reflect"
	"testing"
)

func TestCloneSelectorAndAddLabel(t *testing.T) {
	labels := map[string]string{
		"foo1": "bar1",
		"foo2": "bar2",
		"foo3": "bar3",
	}
	matchExpressions := []LabelSelectorRequirement{
		{Key: "foo", Operator: LabelSelectorOpIn, Values: []string{"foo"}},
	}

	cases := []struct {
		labels     map[string]string
		labelKey   string

fun Greeting(): String {
    return "Hi $foo!"
}

// FILE: p3/foo.kt
package p3

import org.jetbrains.kotlin.fir.plugin.MyComposable

private var foo_ = 0

fun setFoo(newFoo: Int) {
    foo_ = newFoo
}

val foo: Int