*/
@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{

	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			percent := (x + y) % 100
			switch {
			case percent < 10: // 10% of pixels are translucent (have alpha >0 and <255)
				img.Set(x, y, color.NRGBA{uint8(x), uint8(y), uint8(x * y), uint8(percent)})
			case percent < 40: // 30% of pixels are transparent (have alpha == 0)
				img.Set(x, y, color.NRGBA{uint8(x), uint8(y), uint8(x * y), 0})

  fun toUriWithControlCharacters() {
    // Percent-encoded in the path.
    assertThat("http://host/a\u0000b".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/a%00b"))
    assertThat("http://host/a\u0080b".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/a%C2%80b"))
    assertThat("http://host/a\u009fb".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/a%C2%9Fb"))
    // Percent-encoded in the query.

		}
		dekCacheInterArrivals.WithLabelValues(transformationType).Observe(start.Sub(lastToStorage).Seconds())
		lastToStorage = start
	}
}

func RecordDekCacheFillPercent(percent float64) {
	dekCacheFillPercent.Set(percent)
}

func RecordDekSourceCacheSize(providerName string, size int) {
	DekSourceCacheSize.WithLabelValues(providerName).Set(float64(size))
}

		baseline := measureSqr(i, nruns, lower)
		testval := measureSqr(i, nruns, upper)
		pos := baseline > testval
		delta := baseline - testval
		percent := delta * 100 / baseline
		fmt.Printf("words = %3d deltaT = %10s (%4d%%) is %s better: %v", i, delta, percent, upper, pos)
		if i == from {
			initPos = pos
		}
		if threshold == 0 && pos != initPos {
			threshold = i
			fmt.Printf("  threshold  found")
		}

making the helloworld service ready for autoscaling.

Enable autoscaling on both versions of the service:

```bash
kubectl autoscale deployment helloworld-v1 --cpu-percent=50 --min=1 --max=10
kubectl autoscale deployment helloworld-v2 --cpu-percent=50 --min=1 --max=10
kubectl get hpa
```

## Generate load

```bash
./loadgen.sh &
./loadgen.sh & # run it twice to generate lots of load
```

	}
	d := &dstate{
		cmd: cmd,
		cm:  &cmerge.Merger{},
	}
	// For these modes (percent, pkglist, func, etc), use a relaxed
	// policy when it comes to counter mode clashes. For a percent
	// report, for example, we only care whether a given line is
	// executed at least once, so it's ok to (effectively) merge
	// together runs derived from different counter modes.