var buf bytes.Buffer
	msgp.Encode(&buf, &v)

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

	vn := BaseOptions{}
	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)
	}
}

        objAttr.decode(mockNdrBuffer);

        assertEquals(100, objAttr.length);
        assertEquals(3, objAttr.attributes);
        assertEquals(4, objAttr.security_descriptor);

        verify(objAttr.root_directory).decode(mockDeferredNdrBuffer);
        verify(objAttr.object_name).decode(mockDeferredNdrBuffer);
        verify(objAttr.security_quality_of_service).decode(mockDeferredNdrBuffer);
    }

                readn(this.in, buffer, Smb2Constants.SMB2_HEADER_LENGTH, rl - Smb2Constants.SMB2_HEADER_LENGTH);

                len = cur.decode(buffer, 0, true);
                if (len > rl) {
                    throw new IOException(String.format("WHAT? ( read %d decoded %d ): %s", rl, len, cur));
                }
                if (nextCommand != 0 && len > nextCommand) {

			}
		case "ActiveWorkers":
			err = z.ActiveWorkers.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "ActiveWorkers")
				return
			}
		case "QStats":
			err = z.QStats.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "QStats")
				return
			}
		case "MRFStats":
			err = z.MRFStats.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "MRFStats")

	return
}

// DecodeMsg implements msgp.Decodable
func (z *dataUsageEntryV4) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 4 {
		err = msgp.ArrayError{Wanted: 4, Got: zb0001}
		return
	}
	err = z.Children.DecodeMsg(dc)
	if err != nil {

		return 0
	}
	var sameDataDirCount int
	var decoded xlMetaDataDirDecoder
	for _, version := range x.versions {
		if version.header.Type != ObjectType || version.header.VersionID == versionID || !version.header.UsesDataDir() {
			continue
		}
		_, err := decoded.UnmarshalMsg(version.meta)
		if err != nil || decoded.ObjectV2 == nil || decoded.ObjectV2.DataDir != dataDir {
			continue
		}

			metaDataPoolPut(v2bufs[i])
		}
	}

	// Return all the metadata.
	return metaFileInfos, errs
}

// Checking if an object is dangling costs some IOPS; hence implementing this function
// which decides which condition it is useful to check if an object is dangling
//
//	  errs: errors from reading xl.meta in all disks
//	   err: reduced errs
//	bucket: the object name in question

            }

            // decode
            if (!isSmbOrFtpUrl) {
                // file
                try {
                    url = URLDecoder.decode(url.replace("+", "%2B"), urlLinkEncoding);
                } catch (final Exception e) {
                    if (logger.isDebugEnabled()) {
                        logger.warn("Failed to decode {}", url, e);
                    }
                }

 *
 * [idna]: http://www.unicode.org/reports/tr46/#ToASCII
 */
class HttpUrl private constructor(
  /** Either "http" or "https". */
  @get:JvmName("scheme") val scheme: String,
  /**
   * The decoded username, or an empty string if none is present.
   *
   * | URL                              | `username()` |
   * | :------------------------------- | :----------- |
   * | `http://host/`                   | `""`         |

			t.Fatalf("Unexpected err: %#v", err)
		}
		rec := httptest.NewRecorder()
		apiRouter.ServeHTTP(rec, reqI)
		checkRespErr(rec, http.StatusOK)
		decoder := xml.NewDecoder(rec.Body)
		multipartResponse := &InitiateMultipartUploadResponse{}
		err = decoder.Decode(multipartResponse)
		if err != nil {
			t.Fatalf("Error decoding the recorded response Body")
		}
		upID := multipartResponse.UploadID