void* data, size_t len,
                                                TF_Status* status) {
  auto dtype = static_cast<tensorflow::DataType>(data_type);
  DCHECK(tensorflow::DataTypeCanUseMemcpy(dtype));

  tensorflow::Tensor tensor(dtype, tensorflow::TensorShape({}));
  std::memcpy(tensorflow::TensorCApi::Buffer(tensor)->data(), data, len);

  status->status = absl::OkStatus();

            metadata.type = TF_ATTR_INT;
          } else if (typestr == "list(float)") {
            metadata.type = TF_ATTR_FLOAT;
          } else if (typestr == "list(bool)") {
            metadata.type = TF_ATTR_BOOL;
          } else if (typestr == "list(type)") {
            metadata.type = TF_ATTR_TYPE;
          } else if (typestr == "list(shape)") {
            metadata.type = TF_ATTR_SHAPE;

        the layer's dtype. If you had a model that used `float64`, it will
        probably silently use `float32` in TensorFlow2, and a warning will be
        issued that starts with Layer "layer-name" is casting an input tensor
        from dtype float64 to the layer's dtype of float32. To fix, either set
        the default dtype to float64 with

     * Artifact type name for a JAR file containing test sources.
     */
    String TEST_JAVA_SOURCE = "test-java-source";

    /**
     * Returns the dependency type id.
     * The id uniquely identifies this <i>dependency type</i>.
     *
     * @return the id of this type, never {@code null}.
     */
    @Nonnull
    @Override
    String id();

    /**
     * Returns the dependency type language.
     *

     *            The string. Must not be {@literal null}.
     * @param ctype
     *            The array of character types. Must not be {@literal null} or empty.
     */
    public Tokenizer(final String str, final byte[] ctype) {
        assertArgumentNotNull("str", str);
        assertArgumentNotEmpty("ctype", ctype);

        this.str = str;
        this.ctype = ctype;
    }

    /**
     * Sets up the character type array.

}

func reqSignatureV4Verify(r *http.Request, region string, stype serviceType) (s3Error APIErrorCode) {
	sha256sum := getContentSha256Cksum(r, stype)
	switch {
	case isRequestSignatureV4(r):
		return doesSignatureMatch(sha256sum, r, region, stype)
	case isRequestPresignedSignatureV4(r):
		return doesPresignedSignatureMatch(sha256sum, r, region, stype)
	default:
		return ErrAccessDenied
	}
}

    public void decode(final NdrBuffer buf) throws NdrException {
        decode_header(buf);

        if (this.ptype != 12 && this.ptype != 2 && this.ptype != 3 && this.ptype != 13) {
            throw new NdrException("Unexpected ptype: " + this.ptype);
        }

        if (this.ptype == 2 || this.ptype == 3) { /* Response or Fault */
            this.alloc_hint = buf.dec_ndr_long();

     */
    void setMethod(String method);

    /**
     * Returns the MIME type of the accessed resource.
     *
     * @return the MIME type
     */
    String getMimeType();

    /**
     * Sets the MIME type of the accessed resource.
     *
     * @param mimeType the MIME type
     */
    void setMimeType(String mimeType);

    /**

 *
 * @param <IDTYPE> the type of the identifier for the access result
 */
public class AccessResultImpl<IDTYPE> implements AccessResult<IDTYPE> {

    /**
     * Creates a new instance of AccessResultImpl.
     */
    public AccessResultImpl() {
        // NOP
    }

    /** The unique identifier for the access result. */
    protected IDTYPE id;

        TestMessage m = new TestMessage();
        m.ptype = 0; // Request type
        NdrBuffer buf = new NdrBuffer(new byte[1024], 0);
        m.encode(buf);

        buf.setIndex(0);
        // Decode will throw exception as ptype 0 is not a valid response type
        assertThrows(NdrException.class, () -> m.decode(buf));
    }

    @Test