}

    /**
     * {@link BigDecimal}を文字列に変換します。
     *
     * @param dec
     *            変換元の{@link BigDecimal}
     * @return 変換された文字列
     */
    public static String toString(final BigDecimal dec) {
        return dec.toPlainString();
    }

    /**
     * {@link BigDecimal}を正規化します。
     *
     * @param dec
     *            変換元の{@link BigDecimal}
     * @return 正規化されたデータ
     */

					}
					buf := bytes.NewBuffer(nil)
					if _, err = msgp.CopyToJSON(buf, bytes.NewReader(b)); err != nil {
						return err
					}

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

type tester interface {
	Fatal(args ...interface{})
}

func loadCompressed(t tester, file string) (js []byte) {
	dec, err := zstd.NewReader(nil)
	if err != nil {
		t.Fatal(err)
	}
	defer dec.Close()
	js, err = os.ReadFile(filepath.Join("testdata", file+".json.zst"))
	if err != nil {
		t.Fatal(err)
	}
	js, err = dec.DecodeAll(js, nil)
	if err != nil {
		t.Fatal(err)
	}

	return js
}

var testCases = []struct {

	respBody, err := client.callGet(ctx, storageRESTMethodReadVersion, values, nil, -1)
	if err != nil {
		return fi, err
	}
	defer xhttp.DrainBody(respBody)

	dec := msgpNewReader(respBody)
	defer readMsgpReaderPoolPut(dec)

	err = fi.DecodeMsg(dec)
	return fi, err
}

// ReadXL - reads all contents of xl.meta of a file.

		}
		defer gz.Close()
		r = gz
	case formatS2:
		r = s2.NewReader(bf)
	case formatZstd:
		// Limit to 16 MiB per stream.
		dec, err := zstd.NewReader(bf, zstd.WithDecoderMaxWindow(16<<20))
		if err != nil {
			return err
		}
		defer dec.Close()
		r = dec
	case formatBZ2:
		ctx, cancel := context.WithCancel(ctx)
		defer cancel()
		r = pbzip2.NewReader(ctx, bf, pbzip2.DecompressionOptions(

	"github.com/minio/minio/internal/s3select/jstream"
)

func getJSONStructs(b []byte) ([]interface{}, error) {
	dec := jstream.NewDecoder(bytes.NewBuffer(b), 0).ObjectAsKVS().MaxDepth(100)
	var result []interface{}
	for parsedVal := range dec.Stream() {
		result = append(result, parsedVal.Value)
	}
	if err := dec.Err(); err != nil {
		return nil, err
	}
	return result, nil
}

func TestJsonpathEval(t *testing.T) {

	}
	return nil
}

// UnmarshalXML - decodes XML data.
func (d *DeleteReplication) UnmarshalXML(dec *xml.Decoder, start xml.StartElement) (err error) {
	// Make subtype to avoid recursive UnmarshalXML().
	type deleteReplication DeleteReplication
	drep := deleteReplication{}

	if err := dec.DecodeElement(&drep, &start); err != nil {
		return err
	}
	if len(drep.Status) == 0 {
		drep.Status = Disabled
	}

// Nothing will be read from the stream yet.
func newMetacacheReader(r io.Reader) *metacacheReader {
	dec := s2DecPool.Get().(*s2.Reader)
	dec.Reset(r)
	mr := msgpNewReader(dec)
	return &metacacheReader{
		mr: mr,
		closer: func() {
			dec.Reset(nil)
			s2DecPool.Put(dec)
			readMsgpReaderPoolPut(mr)
		},
		creator: func() error {
			v, err := mr.ReadByte()
			if err != nil {

	gob.NewEncoder(&buf).Encode(v)
	encoded := buf.Bytes()
	b.Log("Size:", buf.Len(), "bytes")
	b.SetBytes(1)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		dec := gob.NewDecoder(bytes.NewBuffer(encoded))
		err := dec.Decode(&v)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkEncodeDiskInfoMsgp(b *testing.B) {
	v := DiskInfo{
		Total:     1000,
		Free:      1000,

	case dataUsageCacheVerV2:
		// Zstd compressed.
		dec, err := zstd.NewReader(r, zstd.WithDecoderConcurrency(2))
		if err != nil {
			return err
		}
		defer dec.Close()

		dold := &dataUsageCacheV2{}
		if err = dold.DecodeMsg(msgp.NewReader(dec)); err != nil {
			return err
		}
		d.Info = dold.Info