tf_executor.fetch
  }
  func.return
}
func.func @foo0(%arg0: tensor<*xi32>) -> tensor<*xi32> {
  %0 = tf_executor.graph {
    tf_executor.fetch %arg0 : tensor<*xi32>
  }
  func.return %0 : tensor<*xi32>
}

// CHECK: node {
// CHECK:  name: "tf.LegacyCall"
// CHECK-NEXT:  op: "foo0"
// CHECK:  attr {

        buildFile << """
            class Foo0 {
                static final byte[] MEMORY_HOG = new byte[10 * 1024 * 1024]
            }
            task myTask() {
                doLast {
                    println new Foo0()
                }
            }
        """

        expect:
        for(int i = 0; i < 35; i++) {
            buildFile.text = buildFile.text.replace("Foo$i", "Foo${i + 1}")

# CHECK-LABEL:  func @main() {
# CHECK:    "tf.LegacyCall"() <{_disable_call_shape_inference = true, f = @foo0}> {device = ""}
# CHECK:    "tf.LegacyCall"() <{_disable_call_shape_inference = false, f = @bar0}> {device = ""}

# CHECK-LABEL:  func private @foo0()
# CHECK: "tf.LegacyCall"() <{_disable_call_shape_inference = false, f = @bar0}> {device = ""}

# the names are matching between the function definition and the uses / call
# site (a numerical suffix may be appended).

# CHECK: "tf.LegacyCall"(%outputs) <{_disable_call_shape_inference = false, f = @foo0}> {device = ""}

        name: "foo1"
        type: DT_FLOAT
      }
    }
    node_def {
      name: "Exp"
      op: "Exp"
      input: "foo"
      attr {
        key: "T"
        value {
          type: DT_FLOAT
        }
      }
      experimental_debug_info {
        original_node_names: "Exp"
      }
    }
    node_def {
      name: "Neg"
      op: "Neg"
      input: "foo"
      attr {

    )

    static final UBER_MOBILE_APP = new IncrementalAndroidTestProject(
        templateName: 'uberMobileApp',
        pathToChange: 'leafModuleAvg/src/main/java/leafModuleAvgpackageJava0/Foo0.java',
        taskToRunForChange: ':rootModule:assembleDebug'
    )

    String pathToChange
    String taskToRunForChange

    @Override
    void configure(CrossVersionPerformanceTestRunner runner) {

# 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 {

	c.Set("foo5", "bar")
	c.Set("foo6", "bar")
	c.Set("foo7", "bar")

	wg := new(sync.WaitGroup)
	workers := runtime.NumCPU()
	each := b.N / workers
	wg.Add(workers)

	b.ResetTimer()
	for i := 0; i < workers; i++ {
		go func() {
			for j := 0; j < each; j++ {
				c.Get("foo1")
				c.Get("foo2")
				c.Get("foo3")
				c.Get("foo5")
				c.Get("foo6")
				c.Get("foo7")

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 }
func (f foo7) F() { return }

				"foo3": "bar3",
				"foo4": "food",
			},
		},
		{
			labels:     nil,
			labelKey:   "foo4",
			labelValue: "food",
			want: map[string]string{
				"foo4": "food",
			},
		},
	}

	for _, tc := range cases {
		got := AddLabel(tc.labels, tc.labelKey, tc.labelValue)
		if !reflect.DeepEqual(got, tc.want) {
			t.Errorf("got %v, want %v", got, tc.want)
		}
	}
}