fi := newFileInfo(pathJoin(bucket, object), dataDrives, parityDrives)
	fi.VersionID = opts.VersionID
	if opts.Versioned && fi.VersionID == "" {
		fi.VersionID = mustGetUUID()
	}

	fi.DataDir = mustGetUUID()
	fi.Checksum = opts.WantChecksum.AppendTo(nil, nil)
	if opts.EncryptFn != nil {
		fi.Checksum = opts.EncryptFn("object-checksum", fi.Checksum)
	}
	uniqueID := mustGetUUID()

		}

		// If asked to save data.
		if len(fi.Data) > 0 || fi.Size == 0 {
			x.data.replace(fi.VersionID, fi.Data)
		}

		if fi.TransitionStatus != "" {
			ventry.ObjectV2.MetaSys[metaTierStatus] = []byte(fi.TransitionStatus)
		}
		if fi.TransitionedObjName != "" {
			ventry.ObjectV2.MetaSys[metaTierObjName] = []byte(fi.TransitionedObjName)
		}
		if fi.TransitionVersionID != "" {

				return fi, errFileVersionNotFound
			}
		}
		return fi, err
	}

	fi, err = getFileInfo(buf, volume, path, versionID, readData, true)
	if err != nil {
		return fi, err
	}

	if len(fi.Data) == 0 {
		// We did not read inline data, so we have no references.
		defer metaDataPoolPut(buf)
	}

	if readData {
		if len(fi.Data) > 0 || fi.Size == 0 {
			if fi.InlineData() {

						if opts.LatestOnly {
							fi, err := entry.fileInfo(bucket)
							if err != nil {
								cancel()
								return
							}
							if opts.Filter != nil {
								if opts.Filter(fi) {
									if !send(fi.ToObjectInfo(bucket, fi.Name, vcfg != nil && vcfg.Versioned(fi.Name))) {
										return
									}
								}
							} else {

		t.Fatalf("Unable to create a file \"as-file\", %s", err)
	}

	fi, err := xlStorage.ReadVersion(context.Background(), "", "exists-legacy", "as-file", "", ReadOptions{})
	if err != nil {
		t.Fatalf("Unable to read older 'xl.json' content: %s", err)
	}

	if !fi.XLV1 {
		t.Fatal("Unexpected 'xl.json' content should be correctly interpreted as legacy content")
	}
}

      },
      "reading_analyzer_fi" : {
        "type" : "custom",
        "tokenizer" : "standard"
      },
      "reading_term_analyzer_fi" : {
        "type" : "custom",
        "tokenizer" : "standard"
      },
      "normalize_analyzer_fi" : {
        "type" : "custom",
        "tokenizer" : "keyword",
        "char_filter" : ["mapping_char"],

      },
      "reading_analyzer_fi" : {
        "type" : "custom",
        "tokenizer" : "standard"
      },
      "reading_term_analyzer_fi" : {
        "type" : "custom",
        "tokenizer" : "standard"
      },
      "normalize_analyzer_fi" : {
        "type" : "custom",
        "tokenizer" : "keyword",
        "char_filter" : ["mapping_char"],

      },
      "reading_analyzer_fi" : {
        "type" : "custom",
        "tokenizer" : "standard"
      },
      "reading_term_analyzer_fi" : {
        "type" : "custom",
        "tokenizer" : "standard"
      },
      "normalize_analyzer_fi" : {
        "type" : "custom",
        "tokenizer" : "keyword",
        "char_filter" : ["mapping_char"],

      d="$${d#bazel-out/*/bin/}"

      if [[ $${d} == *local_config_* ]]; then
        continue
      fi

      if [[ $${d} == external* ]]; then
        extname="$${d#*external/}"
        extname="$${extname%%/*}"
        if [[ $${TF_SYSTEM_LIBS:-} == *$${extname}* ]]; then
          continue
        fi

        d="$${d#*external/farmhash_archive/src}"
        d="$${d#*external/$${extname}/}"

		},
		{
			"a/b/c",
			time.Date(2021, 4, 19, 12, 29, 59, 0, timeZone(-7*time.Hour)).UTC(),
		},
	} {
		fi, err := fs.Stat(z, test.name)
		if err != nil {
			t.Errorf("%s: %v", test.name, err)
			continue
		}
		if got := fi.ModTime(); !got.Equal(test.want) {
			t.Errorf("%s: got modtime %v, want %v", test.name, got, test.want)
		}
	}
}