TF_KernelBuilder_TypeConstraint(
        builder, "T",
        static_cast<TF_DataType>(tensorflow::DataTypeToEnum<T>::v()), status);
    CHECK_EQ(TF_OK, TF_GetCode(status)) << "Error while adding type constraint";
    TF_RegisterKernelBuilder("HistogramSummary", builder, status);
    CHECK_EQ(TF_OK, TF_GetCode(status))
        << "Error while registering Histogram Summmary kernel";
  }
  TF_DeleteStatus(status);
}

import org.gradle.api.Action;

/**
 * Action adapter/implementation for action code that may throw exceptions.
 *
 * Implementations implement doExecute() (instead of execute()) which is allowed to throw checked exceptions.
 * Any checked exceptions thrown will be wrapped as unchecked exceptions and re-thrown.
 *
 * How the exception is wrapped is subject to {@link UncheckedException#throwAsUncheckedException(Throwable)}.
 *

                    div.append($("<label>", {for: id}).text(title));
                    var checkbox = $("<input>", {type: "checkbox", id: id, checked: true});
                    div.append(checkbox);
                    checkbox.change(function () {
                        if (checkbox.is(':checked')) {
                            $("." + id).show();
                        } else {
                            $("." + id).hide();

int OpView::NumOutputs() const { return output_args_.size(); }

ArgView OpView::OnlyInput() const {
  CHECK_EQ(input_args_.size(), 1);  // Crash OK
  return input_args_.front();
}

ArgView OpView::OnlyOutput() const {
  CHECK_EQ(output_args_.size(), 1);  // Crash OK
  return output_args_.front();
}

string OpView::FunctionName() const { return op_.name(); }

	. "internal/types/errors"
	"math"
)

// overflow checks that the constant x is representable by its type.
// For untyped constants, it checks that the value doesn't become
// arbitrarily large.
func (check *Checker) overflow(x *operand, opPos syntax.Pos) {
	assert(x.mode == constant_)

	if x.val.Kind() == constant.Unknown {
		// TODO(gri) We should report exactly what went wrong. At the

			pkgPath:         "k8s.io/bar/foo/baz/etc",
			shouldBeAllowed: true,
		},
	}

	checker := &illegalPackageSourceChecker{disallowedPrefixes}

	for _, tc := range testCases {
		if checker.IsForbidden(tc.pkgPath) {
			if tc.shouldBeAllowed {
				t.Fatalf("expected package path %q to have been allowed", tc.pkgPath)
			}
			continue
		}

  TF_OpDefinitionBuilderAddAttr(op_builder, "N: int >= 1");
  TF_OpDefinitionBuilderSetShapeInferenceFunction(
      op_builder, &merge_summary_shape_inference_fn);

  TF_RegisterOpDefinition(op_builder, status);
  CHECK_EQ(TF_GetCode(status), TF_OK)
      << "MergeSummary op registration failed: " << TF_Message(status);
  TF_DeleteStatus(status);
}

TF_ATTRIBUTE_UNUSED static bool MergeSummaryOpRegistered = []() {

     * Runtime exceptions are rethrown as is.
     * Checked exceptions are wrapped in {@link BuildOperationInvocationException}.</p>
     */
    void run(RunnableBuildOperation buildOperation);

    /**
     * Calls the given build operation, returns the result.
     *
     * <p>Rethrows any exception thrown by the action.
     * Runtime exceptions are rethrown as is.

        and:
        writeBuildFile()
        failedResolve.prepare()

        when:
        module.allowAll()

        then:
        executer.withStackTraceChecksDisabled()
        fails('checkDeps')

        and:
        failedResolve.assertFailurePresent(failure)
        failure.assertHasCause("Could not GET '$server.uri")
        failure.assertThatCause(
            allOf(
                anyOf(

// constraint is non-nil, it must be fully defined.
func NewTypeParam(obj *TypeName, constraint Type) *TypeParam {
	return (*Checker)(nil).newTypeParam(obj, constraint)
}

// check may be nil
func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
	// Always increment lastID, even if it is not used.
	id := nextID()
	if check != nil {
		check.nextID++