`What IS a Caucus-race?' said Alice; not that she wanted much
to know, but the Dodo had paused as if it thought that SOMEBODY
ought to speak, and no one else seemed inclined to say anything.

  `Why,' said the Dodo, `the best way to explain it is to do it.'
(And, as you might like to try the thing yourself, some winter
day, I will tell you how the Dodo managed it.)

  `What IS a Caucus-race?' said Alice; not that she wanted much
to know, but the Dodo had paused as if it thought that SOMEBODY
ought to speak, and no one else seemed inclined to say anything.

  `Why,' said the Dodo, `the best way to explain it is to do it.'
(And, as you might like to try the thing yourself, some winter
day, I will tell you how the Dodo managed it.)

	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return o, err
	}
	want := uint32(5)
	if hdrVer > 2 {
		want += 2
	}
	if zb0001 != want {
		err = msgp.ArrayError{Wanted: want, Got: zb0001}
		return o, err
	}
	bts, err = msgp.ReadExactBytes(bts, (z.VersionID)[:])
	if err != nil {
		err = msgp.WrapError(err, "VersionID")

  //
  // - @PolyNull means "@Nullable or @Nonnull"
  //   (That would be unsound for an input Iterable<@Nullable Foo>. So, if we wanted to use
  //   @PolyNull, we would have to restrict this method to non-null <T>. But it has users who pass
  //   iterables with null elements.)
  //
  // - @JointlyNullable means "@Nullable or no annotation"

starting the implementation. There are often a number of ways to fix a problem
and it is important to find the right approach before spending time on a PR
that cannot be merged.

We add the `help wanted` label to existing GitHub issues for which community
contributions are particularly welcome, and we use the `good first issue` label
to mark issues that we think will be suitable for new contributors.

			t.Errorf("test %d, readGNUSparsePAXHeaders(): got %v, want %v", i, got, v.wantMap)
		}
		if err != v.wantErr {
			t.Errorf("test %d, readGNUSparsePAXHeaders() = %v, want %v", i, err, v.wantErr)
		}
		if hdr.Size != v.wantSize {
			t.Errorf("test %d, Header.Size = %d, want %d", i, hdr.Size, v.wantSize)
		}
		if hdr.Name != v.wantName {
			t.Errorf("test %d, Header.Name = %s, want %s", i, hdr.Name, v.wantName)
		}

	// Validate all test cases.
	for i, testCase := range testCases {
		// Initialize a new xlStorage layer.
		_, err := newLocalXLStorage(testCase.name)
		if err != testCase.err {
			t.Fatalf("TestXLStorage %d failed wanted: %s, got: %s", i+1, err, testCase.err)
		}
	}
}

// TestXLStorageMakeVol - TestXLStorage validate the logic for creation of new xlStorage volume.
// Asserts the failures too against the expected failures.

	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 7 {
		err = msgp.ArrayError{Wanted: 7, Got: zb0001}
		return
	}
	z.MuxID, err = dc.ReadUint64()
	if err != nil {
		err = msgp.WrapError(err, "MuxID")
		return
	}
	z.Seq, err = dc.ReadUint32()
	if err != nil {

		case encrypted:
			decSize, err := sio.DecryptedSize(uint64(n))
			if err == nil {
				actualSize = int64(decSize)
			}
		default:
			actualSize = n
		}
	}
	// If ServerSideChecksum is wanted for this object, it takes precedence
	// over opts.WantChecksum.
	if opts.WantServerSideChecksumType.IsSet() {
		serverSideChecksum := r.RawServerSideChecksumResult()
		if serverSideChecksum != nil {

			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Totals")
				return
			}
			if zb0002 != uint32(60) {
				err = msgp.ArrayError{Wanted: uint32(60), Got: zb0002}
				return
			}
			for za0001 := range z.Totals {
				err = z.Totals[za0001].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Totals", za0001)
					return