const = 0;
  virtual absl::Status SetInput(size_t index,
                                ImmediateExecutionTensorHandle* input) = 0;

  virtual ImmediateExecutionContext* GetContext() const = 0;

  // Following two methods are used to support custom device.
  // Return true if the inputs contain custom device tensor handle. It means
  // that the argument need to be handled by a custom device.

    }

    @Override
    public int getInflightRequests() {
        return delegate.getInflightRequests();
    }

    @Override
    public CIFSContext getContext() {
        return delegate.getContext();
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T extends SmbTransport> T unwrap(Class<T> type) {
        if (type.isAssignableFrom(this.getClass())) {

     */
    public Category getCategory() {
        return category;
    }

    /**
     * Gets the error context
     *
     * @return the context map
     */
    public Map<String, Object> getContext() {
        return new HashMap<>(context);
    }

    /**
     * Gets a specific context value
     *
     * @param key the context key
     * @return the context value or null
     */

        this.hashesExternal = true;
    }

    /**
     * Get the CIFS context associated with this authentication.
     *
     * @return the CIFS context
     */
    protected CIFSContext getContext() {
        return this.context;
    }

    @Override
    public NtlmPasswordAuthentication clone() {
        final NtlmPasswordAuthentication cloned = new NtlmPasswordAuthentication();

        assertSame(dg, transport.getDigest());
    }

    @Test
    @DisplayName("Context accessor returns constructor-provided context")
    void contextAccessor() {
        assertSame(ctx, transport.getContext());
    }

    @Test
    @DisplayName("acquire returns same instance")
    void acquireReturnsSameInstance() {
        SmbTransportImpl acquired = transport.acquire();
        assertSame(transport, acquired);

        }
    }

    /**
     * Get the CIFS context
     *
     * @return CIFS context
     */
    public CIFSContext getContext() {
        return context;
    }

    /**
     * Check if directory notifications are enabled in configuration
     *
     * @param config configuration
     * @return true if notifications are enabled

    public ErrorCategory getErrorCategory() {
        return errorCode.getCategory();
    }

    public RetryPolicy getRetryPolicy() {
        return retryPolicy;
    }

    public Map<String, Object> getContext() {
        return Collections.unmodifiableMap(context);
    }

    public long getOperationStartTime() {
        return operationStartTime;
    }

    public String getOperationName() {

            // Then
            assertArrayEquals(testTargetInfo, message.getTargetInformation());
        }

        @Test
        @DisplayName("setContext and getContext should work correctly")
        void testGetSetContext() {
            // Given
            CIFSContext mockContext = createMockContext();
            Type2Message message = new Type2Message(mockContext);

  return tensorflow::unwrap(op)->Name().c_str();
}

TFE_Context* TFE_OpGetContext(const TFE_Op* op, TF_Status* status) {
  return tensorflow::wrap(tensorflow::unwrap(op)->GetContext());
}

void TFE_OpSetDevice(TFE_Op* op, const char* device_name, TF_Status* status) {
  status->status = tensorflow::unwrap(op)->SetDeviceName(device_name);
}

            return null;
        }

        @Override
        public String getContextPath() {
            return null;
        }

        @Override
        public ServletContext getContext(String uripath) {
            return null;
        }

        @Override
        public int getMajorVersion() {
            return 0;
        }

        @Override