*/
    public static String create() {
        final StringBuilder buf = new StringBuilder(BASE.length() * 2);
        buf.append(BASE);
        final int lowTime = (int) (System.currentTimeMillis() >> 32);
        StringUtil.appendHex(buf, lowTime);
        StringUtil.appendHex(buf, RANDOM.nextInt());
        return buf.toString();
    }

    private static byte[] getAddress() {
        try {

			}
		case "ActualSize":
			z.ActualSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "ActualSize")
				return
			}
		case "ModTime":
			z.ModTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "ModTime")
				return
			}
		case "index":
			z.Index, err = dc.ReadBytes(z.Index)
			if err != nil {
				err = msgp.WrapError(err, "Index")
				return
			}

		}
		return
	}

	// New object info
	fileObjInfo := ObjectInfo{
		Bucket:      bucket,
		Name:        object,
		Size:        int64(file.UncompressedSize64),
		ModTime:     zipObjInfo.ModTime,
		ContentType: mime.TypeByExtension(filepath.Ext(object)),
	}

	var rc io.ReadCloser

	if file.UncompressedSize64 > 0 {
		// There may be number of header bytes before the content.

	"strings"
	"time"
)

var (
	goroutinesRE, searchRE *regexp.Regexp

	// User input flags
	searchText           string
	goTime, less, margin time.Duration
)

func init() {
	flag.DurationVar(&less, "less", 0, "goroutine waiting less than the specified time")
	flag.DurationVar(&goTime, "time", 0, "goroutine waiting for exactly the specified time")
	flag.DurationVar(&margin, "margin", 0, "margin time")

        assertEquals(systemHelper.getCurrentTimeAsLong() > systemHelper.eolTime, systemHelper.isEoled());
        final SystemHelper helper1 = new SystemHelper() {
            @Override
            public long getCurrentTimeAsLong() {
                return systemHelper.eolTime + 1000L;
            }
        };
        helper1.eolTime = systemHelper.eolTime;
        assertTrue(helper1.isEoled());

	fileMod := time.Unix(1000000000, 0).UTC()
	fs := fakeFS{
		"/": &fakeFileInfo{
			dir:     true,
			modtime: dirMod,
			ents: []*fakeFileInfo{
				{
					basename: "b",
					modtime:  fileMod,
					contents: contents,
				},
				{
					basename: "a",
					modtime:  fileMod,
					contents: contents,
				},
			},
		},
	}

	return
}

func (z xlMetaV2VersionHeaderV2) MarshalJSON() (o []byte, e error) {
	tmp := struct {
		VersionID string
		ModTime   time.Time
		Signature string
		Type      uint8
		Flags     uint8
	}{
		VersionID: hex.EncodeToString(z.VersionID[:]),
		ModTime:   time.Unix(0, z.ModTime),
		Signature: hex.EncodeToString(z.Signature[:]),
		Type:      z.Type,
		Flags:     z.Flags,
	}
	return json.Marshal(tmp)

	}
	if errBuf.Len() > 0 {
		t.Log(errBuf)
	}

	info, err = os.Stat(fn)
	if err != nil {
		t.Fatal(err)
	}
	if !info.ModTime().Equal(past) {
		t.Errorf("after rewrite mod time is %v, want %v", info.ModTime(), past)
	}

func (m *Metrics) Report(w io.Writer) {
	if m == nil {
		return
	}

	m.closeMark()

	gcString := ""
	if m.gc == GC {
		gcString = "_GC"
	}

	var totTime time.Duration
	for _, curMark := range m.marks {
		dur := curMark.endT.Sub(curMark.startT)
		totTime += dur
		fmt.Fprintf(w, "%s 1 %d ns/op", makeBenchString(curMark.name+gcString), dur.Nanoseconds())
		fmt.Fprintf(w, "\t%d B/op", curMark.endM.TotalAlloc-curMark.startM.TotalAlloc)

		return
	}
	defer f.Close()
	gz, err := NewReader(f)
	if err != nil {
		t.Errorf("cannot read gzip file %s: %s", path, err)
		return
	}
	defer gz.Close()
	if !gz.ModTime.IsZero() {
		t.Errorf("gzip file %s has non-zero mtime (%s)", path, gz.ModTime)
	}