def convertsClassNameToLink() {
        when:
        def link = converter.resolve('someName', classMetaData, listener)

        then:
        format(link) == '<someLinkElement/>'
        _ * nameResolver.resolve('someName', classMetaData) >> 'org.gradle.SomeClass'
        _ * linkRenderer.link({it.name == 'org.gradle.SomeClass'}, listener) >> parse('<someLinkElement/>')
    }

            "type": "prometheus",
            "uid": "${datasource}"
          },
          "expr": "round(sum(irate(istio_requests_total{reporter=~\"$qrep\",destination_service=~\"$service\"}[5m])), 0.001)",
          "format": "time_series",
          "intervalFactor": 1,
          "refId": "A",
          "step": 4
        }
      ],
      "title": "Client Request Volume",
      "type": "stat"
    },
    {

func NewSDSWriter(w io.Writer, format Format) SDSWriter {
	return &sdsWriter{
		w:      w,
		output: format,
	}
}

// sdsWriter is provided concrete implementation of SDSWriter
type sdsWriter struct {
	w      io.Writer
	output Format
}

// PrintSecretItems uses the user supplied output format to determine how to display the diffed secrets

			if err := tr.handleSparseFile(hdr, rawHdr); err != nil {
				return nil, err
			}

			// Set the final guess at the format.
			if format.has(FormatUSTAR) && format.has(FormatPAX) {
				format.mayOnlyBe(FormatUSTAR)
			}
			hdr.Format = format
			return hdr, nil // This is a file, so stop
		}
	}
}

// handleRegularFile sets up the current file reader and padding such that it

	}

	zipFile, err := os.Create("format.json.zip")
	if err != nil {
		log.Fatalf("failed to create format.json.zip: %v", err)
	}
	defer zipFile.Close()
	fmtZipW := zip.NewWriter(zipFile)
	defer fmtZipW.Close()
	for _, pool := range pools { // for each pool
		setCount, setDriveCount := pool.SetCount, pool.DrivesPerSet
		format := newFormatErasureV3(setCount, setDriveCount)
		format.ID = deploymentID

                            "type": "string",
                            "format": "date-time",
                        },
                        "end_datetime": {
                            "title": "End Datetime",
                            "type": "string",
                            "format": "date-time",
                        },
                        "repeat_at": IsDict(

			wantFormat.mayBe(FormatUSTAR) // PAX implies USTAR allowed too
		}
		format.mayOnlyBe(wantFormat) // Set union of formats allowed and format wanted
	}
	if format == FormatUnknown {
		switch h.Format {
		case FormatUSTAR:
			err = headerError{"Format specifies USTAR", whyNoUSTAR, whyOnlyPAX, whyOnlyGNU}
		case FormatPAX:
			err = headerError{"Format specifies PAX", whyNoPAX, whyOnlyGNU}
		case FormatGNU:

// format, after successful validation.
//   - i'th position is the set index
//   - j'th position is the disk index in the current set
func findDiskIndex(refFormat, format *formatErasureV3) (int, int, error) {
	if err := formatErasureV3Check(refFormat, format); err != nil {
		return 0, 0, err
	}

	if format.Erasure.This == offlineDiskUUID {

    private final Date startTime;

    private final String format;

    private String formattedDate;

    public BuildTimestampValueSource(Date startTime, String format) {
        super(false);
        this.startTime = startTime;
        this.format = format;
    }

    public Object getValue(String expression) {

    return result
  }
  synchronized(BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS) {
    for (i in 0 until BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS.size) {
      var format: DateFormat? = BROWSER_COMPATIBLE_DATE_FORMATS[i]
      if (format == null) {
        format =
          SimpleDateFormat(BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS[i], Locale.US).apply {