}
				return errors.New("no data found on stream")
			}
			if errors.Is(err, estream.ErrNoKey) {
				fmt.Println("Skipping", stream.Name, "no private key")
				if err := stream.Skip(); err != nil {
					return fmt.Errorf("stream skip: %w", err)
				}
				continue
			}
			return fmt.Errorf("next stream: %w", err)
		}
		if strings.Contains(stream.Name, "..") || !utf8.ValidString(stream.Name) {

	if err != nil {
		return buf
	}
	if maj == 1 && minor < 1 {
		// First version to carry data.
		return buf
	}
	// Skip header
	_, metaBuf, err = msgp.ReadBytesZC(metaBuf)
	if err != nil {
		storageLogIf(GlobalContext, err)
		return buf
	}
	// Skip CRC
	if maj > 1 || minor >= 2 {
		_, metaBuf, err = msgp.ReadUint32Bytes(metaBuf)
		storageLogIf(GlobalContext, err)
	}

				if z.Quorum == nil {
					z.Quorum = new(int)
				}
				*z.Quorum, err = dc.ReadInt()
				if err != nil {
					err = msgp.WrapError(err, "Quorum")
					return
				}
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *LockArgs) EncodeMsg(en *msgp.Writer) (err error) {

				err = msgp.WrapError(err, "Key")
				return
			}
		case "Context":
			z.Context, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Context")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z BatchJobKeyRotateEncryption) EncodeMsg(en *msgp.Writer) (err error) {

				err = msgp.WrapError(err, "Key")
				return
			}
		case "Value":
			z.Value, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Value")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z BatchJobKV) EncodeMsg(en *msgp.Writer) (err error) {

	if gotSource != expectedSource {
		t.Errorf("expected : %s, got : %s", expectedSource, gotSource)
	}
}

// Test lock race
func TestNSLockRace(t *testing.T) {
	t.Skip("long test skip it")

	ctx := t.Context()

	for i := range 10000 {
		nsLk := newNSLock(false)

		// lk1; ref=1
		if !nsLk.lock(ctx, "volume", "path", "source", "opsID", false, time.Second) {

				if z.Cache == nil {
					z.Cache = new(dataUsageCache)
				}
				err = z.Cache.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Cache")
					return
				}
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *nsScannerOptions) EncodeMsg(en *msgp.Writer) (err error) {

		if r.Flags.Filter.OlderThan > 0 && time.Since(info.ModTime) < r.Flags.Filter.OlderThan {
			// skip all objects that are newer than specified older duration
			return false
		}

		if r.Flags.Filter.NewerThan > 0 && time.Since(info.ModTime) >= r.Flags.Filter.NewerThan {
			// skip all objects that are older than specified newer duration
			return false
		}

						return
					}
				default:
					err = dc.Skip()
					if err != nil {
						err = msgp.WrapError(err, "QueueStats")
						return
					}
				}
			}
		case "ProxyStats":
			err = z.ProxyStats.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "ProxyStats")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)

		expectedResult bool
	}{
		// Test case - 1.
		// Test case with "X-Amz-Content-Sha256" header set, but to empty value but we can't skip.
		{"X-Amz-Content-Sha256", "", "", "", false},

		// Test case - 2.
		// Test case with "X-Amz-Content-Sha256" not set so we can skip.
		{"", "", "", "", true},

		// Test case - 3.
		// Test case with "X-Amz-Content-Sha256" header set to  "UNSIGNED-PAYLOAD"