Mirror:           &networking.Destination{},
				MirrorPercentage: &networking.Percent{Value: 0.0},
			},
			want: nil,
		},
		{
			name: "mirrorpercentage with actual percent",
			route: &networking.HTTPRoute{
				Mirror:           &networking.Destination{},
				MirrorPercentage: &networking.Percent{Value: 50.0},
			},
			want: &core.RuntimeFractionalPercent{

        public long used;
        public long committed;
        public long max;
        public short percent;
    }

    public static class JvmMemoryNonHeapObj {
        public long used;
        public long committed;
        public long max;
        public short percent;
    }

    public static class JvmPoolObj {
        public String key;
        public long count;

        return thrashingThreshold;
    }

    public boolean isAboveHeapUsageThreshold(int percent) {
        return heapUsageThreshold != -1 && percent >= heapUsageThreshold;
    }

    public boolean isAboveNonHeapUsageThreshold(int percent) {
        return nonHeapUsageThreshold != -1 && percent >= nonHeapUsageThreshold;
    }

    public boolean isAboveGcRateThreshold(double gcEventsPerSec) {

    def "knows percentage change"() {
        expect:
        percentChange(Amount.valueOf(current, Duration.SECONDS), Amount.valueOf(previous, Duration.SECONDS)) == percent

        where:
        current  | previous | percent
        1        | 1        | 0
        3        | 1        | 200
        1        | 3        | -66.67
        2        | 3        | -33.33
        5        | 4        | 25

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()
    GradleHandle gradle

    def setup() {
        server.start()
    }

    def "shows progress bar and percent phase completion"() {
        createDirs("a", "b", "c", "d")
        settingsFile << """
            ${server.callFromBuild('settings')}
            include "a", "b", "c", "d"
        """
        buildFile << """

        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

		fmt.Fprintf(os.Stderr, "error: %s\n", msg)
	}
	fmt.Fprintf(os.Stderr, "usage: go tool covdata [command]\n")
	fmt.Fprintf(os.Stderr, `
Commands are:

textfmt     convert coverage data to textual format
percent     output total percentage of statements covered
pkglist     output list of package import paths
func        output coverage profile information for each function
merge       merge data files together

      <h2>{{.Name}}</h2>{{"" -}}
      <p class="filename">{{.File}}</p>{{"\n" -}}
      <pre onClick="pprof_toggle_asm(event)">{{"\n" -}}
        {{printf "  Total:  %10s %10s (flat, cum) %s" .Flat .Cumulative .Percent -}}
        {{range .Lines -}}{{"\n" -}}
          {{/* source line */ -}}
          <span class=line>{{printf " %6d" .Line}}</span>{{" " -}}
          <span class={{.HTMLClass}}>