}

void CheckTFE_TensorHandleHasFloats(TFE_TensorHandle* handle,
                                    const std::vector<float>& expected_values) {
  std::unique_ptr<TF_Status, decltype(&TF_DeleteStatus)> status(
      TF_NewStatus(), TF_DeleteStatus);
  TF_Tensor* t = TFE_TensorHandleResolve(handle, status.get());
  ASSERT_EQ(TF_OK, TF_GetCode(status.get())) << TF_Message(status.get());

///

## Other middlewares

You can later read more about other middlewares in the [Advanced User Guide: Advanced Middleware](../advanced/middleware.md){.internal-link target=_blank}.

            0x00002000;

    /**
    * Sent by the server to indicate that the server and client are
    * on the same machine.  This implies that the server will include
    * a local security context handle in the Type 2 message, for
    * use in local authentication.
    */
    public static final int NTLMSSP_NEGOTIATE_LOCAL_CALL = 0x00004000;

    /**
    * Indicates that authenticated communication between the client

                        &arrived, &executed, status.get());
  ASSERT_TRUE(TF_GetCode(status.get()) == TF_OK) << TF_Message(status.get());

  // Create a variable handle placed on the custom device.
  std::unique_ptr<TFE_Op, decltype(&TFE_DeleteOp)> op(
      TFE_NewOp(context.get(), "VarHandleOp", status.get()), TFE_DeleteOp);

  optional k8s.io.api.core.v1.ObjectReference related = 9;

  // note is a human-readable description of the status of this operation.
  // Maximal length of the note is 1kB, but libraries should be prepared to
  // handle values up to 64kB.
  // +optional
  optional string note = 10;

  // type is the type of this event (Normal, Warning), new types could be added in the future.
  // It is machine-readable.
  // +optional

          // If the delegate is already done, run the execution list immediately on the current
          // thread.
          executionList.execute();
          return;
        }

        // TODO(lukes): handle RejectedExecutionException
        adapterExecutor.execute(
            () -> {
              try {
                /*
                 * Threads from our private pool are never interrupted. Threads from a

						</goals>
					</execution>
				</executions>
				<configuration>
					<failOnError>false</failOnError>
					<ignored>
						<difference>
							<!-- seems to be a clirr bug that it cannot handle the different inherited 
								return types -->
							<className>**</className>
							<differenceType>7006</differenceType>
							<method>*</method>
							<from>*</from>
							<to>*</to>

        "The client does not have the necessary access rights to perform the requested function.", "Access is denied.",
        "The TID specified was invalid.", "The handle is invalid.", "The network name cannot be found.",
        "Not enough storage is available to process this command.", "The media is write protected.", "The device is not ready.",

        "reserved",
        "The client does not have the necessary access rights to perform the requested function.",
        "Access is denied.",
        "The TID specified was invalid.",
        "The handle is invalid.",
        "The network name cannot be found.",
        "Not enough storage is available to process this command.",
        "The media is write protected.",
        "The device is not ready.",

     */
    @Override
    public void setExpiration ( Long exp ) {
        this.expiration = exp;
    }


    /**
     * @return whether the interim response has been handled
     */
    public boolean isAsyncHandled () {
        return this.asyncHandled;
    }


    /**
     * @param asyncHandled
     *            the asyncHandled to set
     */