}
	}

	return string(p)
}

// PrefixToPath is the inverse of PathToPrefix, replacing escape sequences with
// the original character.
func PrefixToPath(s string) (string, error) {
	percent := strings.IndexByte(s, '%')
	if percent == -1 {
		return s, nil
	}

	p := make([]byte, 0, len(s))
	for i := 0; i < len(s); {
		if s[i] != '%' {
			p = append(p, s[i])
			i++
			continue
		}
		if i+2 >= len(s) {

 * href="https://url.spec.whatwg.org/#percent-encode">uppercase</a> hexadecimal sequences.
 *
 * @author David Beaumont
 * @since 15.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public final class PercentEscaper extends UnicodeEscaper {

  // In some escapers spaces are escaped to '+'
  private static final char[] PLUS_SIGN = {'+'};

 * href="https://url.spec.whatwg.org/#percent-encode">uppercase</a> hexadecimal sequences.
 *
 * @author David Beaumont
 * @since 15.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public final class PercentEscaper extends UnicodeEscaper {

  // In some escapers spaces are escaped to '+'
  private static final char[] PLUS_SIGN = {'+'};

        this.container.appendChild(line);

        for (let i = 1; i < chars.length + 1; i++) {
            await this._wait(this.typeDelay);
            const percent = Math.round(i / chars.length * 100);
            line.textContent = `${chars.slice(0, i)} ${percent}%`;
			if (percent>progressPercent) {
				break;
			}
        }
    }

    /**
     * Helper function for animation delays, called with `await`.

        append(buf, "committed", () -> mem.getHeapCommitted().getBytes()).append(',');
        append(buf, "max", () -> mem.getHeapMax().getBytes()).append(',');
        append(buf, "percent", () -> mem.getHeapUsedPercent());
        buf.append("},");
        buf.append("\"non_heap\":{");
        append(buf, "used", () -> mem.getNonHeapUsed().getBytes()).append(',');

				Sampling:         0,
			},
			out: &hcm.HttpConnectionManager_Tracing{
				MaxPathTagLength: nil,
				ClientSampling: &xdstype.Percent{
					Value: 100.0,
				},
				RandomSampling: &xdstype.Percent{
					Value: 80.0,
				},
				OverallSampling: &xdstype.Percent{
					Value: 100.0,
				},
				CustomTags: customTracingTags(),
			},
		},
		{

 */
@CompileStatic
class BaselineVersion implements VersionResults {
    private static final double MINIMUM_CONFIDENCE = 0.999
    // 5 percent difference is something we can measure reliably
    private static final double MINIMUM_RELATIVE_MEDIAN_DIFFERENCE = 0.05
    // 20 percent difference is something where we should always fail
    private static final double HIGH_RELATIVE_MEDIAN_DIFFERENCE = 0.2

		{"space vs newline no-percent 0110", "1\n 2", "1 \n2", 0, false}, // fails: space after nl in input but not pattern
		{"space vs newline no-percent 0111", "1\n 2", "1 \n 2", 0, true},
		{"space vs newline no-percent 1000", "1 \n2", "1\n2", 0, true},
		{"space vs newline no-percent 1001", "1 \n2", "1\n 2", 0, true},

	for _, httpRoute := range vs.Http {
		if httpRoute.Fault != nil {
			if httpRoute.Fault.Delay != nil {
				// nolint: staticcheck
				if httpRoute.Fault.Delay.Percent > 0 {
					ctx.Report(gvk.VirtualService,
						msg.NewDeprecated(r, replacedMessage("HTTPRoute.fault.delay.percent", "HTTPRoute.fault.delay.percentage")))
				}
			}
		}
	}
}

func replacedMessage(deprecated, replacement string) string {

			},
			expectedStabilization: utilpointer.Int32(25),
			expectedSelectPolicy:  string(autoscalingv2.MaxPolicySelect),
		},
		{
			annotation:                   "Percent policy is specified",
			rateDownPercent:              1,
			rateDownPercentPeriodSeconds: 2,
			selectPolicy:                 &minPolicy,
			expectedPolicies: []autoscalingv2.HPAScalingPolicy{