ID:        "uuid",
		Error:     "",
	}

	var buf bytes.Buffer
	gob.NewEncoder(&buf).Encode(v)
	encoded := buf.Bytes()
	b.Log("Size:", buf.Len(), "bytes")
	b.SetBytes(1)
	b.ReportAllocs()

	for b.Loop() {
		dec := gob.NewDecoder(bytes.NewBuffer(encoded))
		err := dec.Decode(&v)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkEncodeDiskInfoMsgp(b *testing.B) {

        return 0;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#decode(byte[], int)
     */
    @Override
    public int decode(final byte[] buffer, final int bufferIndex) throws SMBProtocolDecodingException {
        final int len = super.decode(buffer, bufferIndex);
        if (this.byteCount == 0) {
            // otherwise hasMore may not be correctly set

						return err
					}

					dec := json.NewDecoder(buf)
					// Use number to preserve integers.
					dec.UseNumber()
					var htr map[string]any
					if err = dec.Decode(&htr); err != nil {
						return err
					}
					ht[file.Name] = htr
				}
			}
			b, err := json.MarshalIndent(ht, "", "  ")
			if err != nil {
				return err
			}
			fmt.Println(string(b))

	v := ServerSystemConfig{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeServerSystemConfig Msgsize() is inaccurate")
	}

	vn := ServerSystemConfig{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)

	v := BucketMetadata{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeBucketMetadata Msgsize() is inaccurate")
	}

	vn := BucketMetadata{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}

        byte[] encoded = original.encode();
        assertEquals(Smb2ChannelCapabilities.NETWORK_INTERFACE_INFO_SIZE, encoded.length);

        NetworkInterfaceInfo decoded = NetworkInterfaceInfo.decode(encoded, 0);
        assertNotNull(decoded);
        assertEquals(original.getAddress(), decoded.getAddress());
        assertEquals(original.getLinkSpeed(), decoded.getLinkSpeed());

        assertDoesNotThrow(() -> response.reset());
    }

    @Test
    @DisplayName("Test encode operation")
    void testEncode() {
        byte[] buffer = new byte[1024];
        int length = response.encode(buffer, 0);
        assertTrue(length >= 0);
    }

    @Test
    @DisplayName("Test decode operation")
    void testDecode() {
        byte[] buffer = new byte[1024];

            return null;
        }

        // Methods from CommonServerMessageBlock interface
        @Override
        public int decode(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
            return 0;
        }

        @Override
        public int encode(byte[] dst, int dstIndex) {
            return 0;
        }

        @Override

        buffer.append("=");
        return buffer.toString();
    }

    /**
     * Decodes the supplied Base-64 encoded string.
     *
     * @param string The Base-64 encoded string that is to be decoded.
     * @return A <code>byte[]</code> containing the decoded data block.
     */
    public static byte[] decode(final String string) {
        final int length = string.length();
        if (length == 0) {

     */
    public NdrHyper(final long value) {
        this.value = value;
    }

    @Override
    public void encode(final NdrBuffer dst) throws NdrException {
        dst.enc_ndr_hyper(value);
    }

    @Override
    public void decode(final NdrBuffer src) throws NdrException {
        value = src.dec_ndr_hyper();
    }