TF::UniformQuantizedAddOp ParseUniformQuantizedAddOp(
    const absl::string_view add_op_str, Block& block, MLIRContext& ctx) {
  const LogicalResult parse_result =
      parseSourceString(add_op_str, &block, ParserConfig(&ctx));
  EXPECT_TRUE(succeeded(parse_result));

  auto uq_add_op = dyn_cast_or_null<TF::UniformQuantizedAddOp>(block.back());
  EXPECT_TRUE(uq_add_op);

  return uq_add_op;
}

TF::UniformRequantizeOp ParseUniformRequantizedOp(

			succeededPods, failedPods := getNewFinishedPods(jobCtx)
			succeeded := int32(len(succeededPods)) + tc.job.Status.Succeeded + int32(len(uncounted.succeeded))
			failed := int32(len(failedPods)) + tc.job.Status.Failed + int32(len(uncounted.failed))
			if succeeded != tc.wantSucceeded {
				t.Errorf("getStatus reports %d succeeded pods, want %d", succeeded, tc.wantSucceeded)
			}
			if failed != tc.wantFailed {

	return b
}

// WithSucceeded sets the Succeeded field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Succeeded field is set to the value of the last call.
func (b *JobStatusApplyConfiguration) WithSucceeded(value int32) *JobStatusApplyConfiguration {
	b.Succeeded = &value
	return b
}

      GetDeviceOrdinalFromDeviceString(unknown_loc, tpu0, &device_ordinal0);
  EXPECT_TRUE(mlir::succeeded(result0));
  EXPECT_EQ(device_ordinal0, 0);

  int64_t device_ordinal1 = -1;
  mlir::LogicalResult result1 =
      GetDeviceOrdinalFromDeviceString(unknown_loc, tpu1, &device_ordinal1);
  EXPECT_TRUE(mlir::succeeded(result1));
  EXPECT_EQ(device_ordinal1, 1);
}

    val client1 =
      client.newBuilder()
        .readTimeout(500, TimeUnit.MILLISECONDS)
        .build()
    try {
      client1.newCall(request).execute().use { response ->
        println("Response 1 succeeded: $response")
      }
    } catch (e: IOException) {
      println("Response 1 failed: $e")
    }

    // Copy to customize OkHttp for this request.
    val client2 =
      client.newBuilder()

    }

    def checkTestCases(int total, int succeeded, int failed) {
        def tests = resultsNode.@tests as int
        def disabled = resultsNode.@disabled as int
        def testFailed = resultsNode.@failures as int
        def run = tests - disabled
        def testSucceeded = tests - failed
        assert run == total
        assert testSucceeded == succeeded
        assert testFailed == failed
        return true

// been accounted in Job status counters.
type UncountedTerminatedPods struct {
	// succeeded holds UIDs of succeeded Pods.
	// +listType=set
	// +optional
	Succeeded []types.UID `json:"succeeded,omitempty" protobuf:"bytes,1,rep,name=succeeded,casttype=k8s.io/apimachinery/pkg/types.UID"`

	// failed holds UIDs of failed Pods.
	// +listType=set
	// +optional

  // +optional
  optional PodFailurePolicy podFailurePolicy = 11;

  // successPolicy specifies the policy when the Job can be declared as succeeded.
  // If empty, the default behavior applies - the Job is declared as succeeded
  // only when the number of succeeded pods equals to the completions.
  // When the field is specified, it must be immutable and works only for the Indexed Jobs.

    }

    def "runs tasks"() {
        when:
        controller.scheduleAndRunTasks()

        then:
        1 * workController.scheduleAndRunRequestedTasks(null) >> ExecutionResult.succeeded()

        and:
        1 * finishExecutor.finishBuildTree([]) >> null
    }

    def "runs tasks and collects failure to schedule and execute tasks"() {
        def failure = new RuntimeException()

			if _, err = Lstat(s); err == nil {
				t.Fatalf("Lstat %q succeeded after partial RemoveAll", s)
			}
		}
	}
	if err = RemoveAll(path); err != nil {
		t.Fatalf("RemoveAll %q after partial RemoveAll: %s", path, err)
	}
	if _, err = Lstat(path); err == nil {
		t.Fatalf("Lstat %q succeeded after RemoveAll (final)", path)
	}
}

// Test RemoveAll on a large directory.