b.ResetTimer()
				for i := 0; i < b.N; i++ {
					result := &example.PodList{}
					err = cacher.GetList(context.TODO(), "pods", storage.ListOptions{
						Predicate:       pred,
						Recursive:       true,
						ResourceVersion: "12345",
					}, result)
					if err != nil {
						b.Fatalf("GetList cache: %v", err)
					}
					if len(result.Items) != tc.expectObjectNum {

		lastCheckpoint = st.Object
	}
	workers := make([]chan ReplicateObjectInfo, resyncParallelRoutines)
	resultCh := make(chan TargetReplicationResyncStatus, 1)
	defer xioutil.SafeClose(resultCh)
	go func() {
		for r := range resultCh {
			s.incStats(r, opts)
			globalSiteResyncMetrics.updateMetric(r, opts.resyncID)
		}
	}()

	var wg sync.WaitGroup

func.func @replace_const_op_test() {
  // CHECK-NEXT: %[[RESULT_0:.*]] = "tf.Const"() <{value = dense<2.000000e+00> : tensor<f32>}> {device = "/job:worker/replica:0/task:0/device:CPU:1"}
  // CHECK-NEXT: %[[RESULT_1:.*]] = "tf.Const"() <{value = dense<2.000000e+00> : tensor<f32>}> {device = "/job:worker/replica:0/task:0/device:CPU:0"}
  // CHECK-NEXT: %[[RESULT_2:.*]] = "tf.AddV2"(%[[RESULT_1]], %[[RESULT_1]]) {device = "/job:worker/replica:0/task:0/device:CPU:0"}

// CHECK-NEXT:   %[[RESULT_0:.*]] = "tf.Const"()
// CHECK-NEXT:   %[[RESULT_1:.*]] = "tf.AddV2"(%[[ARG_0]], %[[RESULT_0]])
// CHECK-NEXT:   %[[RESULT_2:.*]] = "tf.Const"() <{value = dense<16> : tensor<i32>}> : () -> tensor<i32>
// CHECK-NEXT:   tf_device.send %[[RESULT_2]] "key-0" "/job:worker/replica:0/task:1/device:CPU:0"

        def results3 = new DefaultVisitedGraphResults(resolutionResult, Collections.emptySet(), resolveEx)
        def results4 = new DefaultVisitedGraphResults(resolutionResult, Collections.singleton(unresolved), resolveEx)

        expect:
        visitFailures(results1) == []
        visitFailures(results2) == [throwable]
        visitFailures(results3) == [resolveEx]
        visitFailures(results4) == [throwable, resolveEx]
    }

			}
			if results0.Average < 15.5 || results0.Average > 16.1 {
				t.Errorf("Flow 0 got average concurrency of %v but expected about 16", results0.Average)
			} else {
				t.Logf("Flow 0 got average concurrency of %v and expected about 16", results0.Average)
			}
			if results1.Average < 5.5 || results1.Average > 6.1 {

        then:
        TestFile results1 = testDirectory.file('build/test-results/test/TEST-org.gradle.SomeTest.xml')
        TestFile results2 = testDirectory.file('build/test-results/test/TEST-org.gradle.SomeTest2.xml')
        results1.assertIsFile()
        results2.assertIsFile()
        assertThat(results1.linesThat(containsString('VM START TIME =')).get(0), equalTo(results2.linesThat(containsString('VM START TIME =')).get(0)))

      EXPECT_EQ(muladd.result0_data()[i], results0[i]);
      EXPECT_EQ(muladd.result1(i / 2, i % 2), results1[i]);
      EXPECT_EQ(muladd.result1_data()[i], results1[i]);
    }
    EXPECT_EQ(muladd.result0_data(), muladd.results()[0]);
    EXPECT_EQ(muladd.result1_data(), muladd.results()[1]);

    const ::foo::bar::MatMulAndAddComp& muladd_const = muladd;

  // CHECK: Tensor<type: int32 shape: [2,2] values: [4 4]
  %ch1 = "tfrt_fallback_async.print_tensor"(%result_1, %ch0) : (!tfrt_fallback.tf_tensor, !tfrt.chain) -> !tfrt.chain

  // CHECK: Tensor<type: int32 shape: [2,2] values: [6 6]
  %ch2 = "tfrt_fallback_async.print_tensor"(%result_2, %ch1) : (!tfrt_fallback.tf_tensor, !tfrt.chain) -> !tfrt.chain

  tfrt.return %ch2 : !tfrt.chain
}

  ^bb0(%arg3: tensor<i32>, %arg4: tensor<*xf32>):
    // CHECK-NEXT: %[[RESULT_1:.*]] = "tf.Identity"(%[[ARG_3]])
    %1 = "tf.Identity"(%arg3) : (tensor<i32>) -> tensor<i32>
    %2 = "tf.Identity"(%arg1) : (tensor<i32>) -> tensor<i32>
    // CHECK-NEXT: %[[RESULT_2:.*]] = "tf.NotEqual"(%[[RESULT_1]], %[[ARG_1]])
    %3 = "tf.NotEqual"(%1, %2) : (tensor<i32>, tensor<i32>) -> tensor<i1>