*
     * @param str the string to encode
     * @return the string as bytes (UTF16-LE)
     */
    public static byte[] getUNIBytes(final String str) {
        return getBytes(str, UNI_ENCODING);
    }

    /**
     * Encodes a string into ASCII bytes.
     *
     * @param str the string to encode
     * @return the string as bytes (ASCII)
     */

		}
	}

	// Test invalid range strings.
	invalidRangeStrings := []string{
		"bytes=8",
		"bytes=5-2",
		"bytes=+2-5",
		"bytes=2-+5",
		"bytes=2--5",
		"bytes=-",
		"2-5",
		"bytes = 2-5",
		"bytes=2 - 5",
		"bytes=0-0,-1",
		"bytes=2-5 ",
		"bytes=-1",
		"bytes=1-",
	}
	for _, rangeString := range invalidRangeStrings {

     *
     * @param bytes number of bytes written
     * @param durationNanos operation duration in nanoseconds
     */
    public void recordRdmaWrite(int bytes, long durationNanos) {
        rdmaWrites.incrementAndGet();
        bytesTransferred.addAndGet(bytes);
        totalWriteTime.addAndGet(durationNanos);
    }

    /**
     * Record an RDMA send operation
     *
     * @param bytes number of bytes sent

	fieldValue := reflect.New(field.FieldType)

	if dbValue != nil {
		var bytes []byte
		switch v := dbValue.(type) {
		case []byte:
			bytes = v
		case string:
			bytes = []byte(v)
		default:
			bytes, err = json.Marshal(v)
			if err != nil {
				return err
			}
		}

		if len(bytes) > 0 {
			err = json.Unmarshal(bytes, fieldValue.Interface())
		}
	}

  public static boolean isCompatIPv4Address(Inet6Address ip) {
    if (!ip.isIPv4CompatibleAddress()) {
      return false;
    }

    byte[] bytes = ip.getAddress();
    if ((bytes[12] == 0)
        && (bytes[13] == 0)
        && (bytes[14] == 0)
        && ((bytes[15] == 0) || (bytes[15] == 1))) {
      return false;
    }

    return true;
  }

  /**

		b.Fatal(err)
	}

	// get text data generated for number of bytes equal to object size.
	textData := generateBytesData(objSize)
	// generate md5sum for the generated data.
	// md5sum of the data to written is required as input for PutObject.

	md5hex := getMD5Hash(textData)
	sha256hex := ""

	// benchmark utility which helps obtain number of allocations and bytes allocated per ops.
	b.ReportAllocs()

        // Verify bytes written
        assertTrue(bytesWritten > 0);
        assertEquals(19, bytesWritten); // 2 + 13 + 2 + 2

        // Verify NET_SHARE_ENUM command (2 bytes)
        assertEquals(SmbComTransaction.NET_SHARE_ENUM, dst[0]);
        assertEquals(0, dst[1]);

        // Verify descriptor (WrLeh\0B13BWz\0 in ASCII - 13 bytes)
        String expectedDescr = "WrLeh\u0000B13BWz\u0000";

    /** Total number of parameter bytes the server is returning */
    protected int totalParameterCount;
    /** Total number of data bytes the server is returning */
    protected int totalDataCount;
    /** Number of parameter bytes in this response */
    protected int parameterCount;
    /** Offset from the start of the SMB header to the parameter bytes */
    protected int parameterOffset;

   * well-formed.
   *
   * <p>This method returns {@code true} if and only if {@code Arrays.equals(bytes, new
   * String(bytes, UTF_8).getBytes(UTF_8))} does, but is more efficient in both time and space.
   */
  public static boolean isWellFormed(byte[] bytes) {
    return isWellFormed(bytes, 0, bytes.length);
  }

  /**

import (
	"bytes"
	"testing"

	"github.com/tinylib/msgp/msgp"
)

func TestMarshalUnmarshalmetacache(t *testing.T) {
	v := metacache{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}