assertEquals("0 GB", format.format(_50_kilobytes, ScaleUnit.GIGABYTE));

        long _999_kilobytes = 999L * 1000L;
        assertEquals("999 kB", format.format(_999_kilobytes));
        assertEquals("999000 B", format.format(_999_kilobytes, ScaleUnit.BYTE));
        assertEquals("999 kB", format.format(_999_kilobytes, ScaleUnit.KILOBYTE));
        assertEquals("1.0 MB", format.format(_999_kilobytes, ScaleUnit.MEGABYTE));

		{"-1", time.Unix(-1, -0e0+0e0), true},
		{"-1.999000", time.Unix(-1, -1e9+1e6), true},
		{"-1.999999", time.Unix(-1, -1e9+1e3), true},
		{"-1.999999999", time.Unix(-1, -1e9+1e0), true},
		{"0.000000001", time.Unix(0, 1e0+0e0), true},
		{"0.000001", time.Unix(0, 1e3+0e0), true},
		{"0.001000", time.Unix(0, 1e6+0e0), true},
		{"0", time.Unix(0, 0e0), true},
		{"0.999000", time.Unix(0, 1e9-1e6), true},

		failed = true
		print(name, ".M(1000, 99) = ", b, ", ", x, " want 99, ", 1000+inc, "\n")
	}
	
	CheckF("(i="+name+")", i.M, inc)
}

func CheckF(name string, f func(int, byte) (byte, int), inc int) {
	b, x := f(1000, 99)
	if b != 99 || x != 1000+inc {
		failed = true
		print(name, "(1000, 99) = ", b, ", ", x, " want 99, ", 1000+inc, "\n")
	}
}

func checkI(name string, i tinter, inc int) {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

var x uint16 = 0xffff
var y uint16 = 0xfffe
var a uint16 = 0x7000
var b uint16 = 0x9000

func main() {
	// Make sure we truncate to smaller-width types after evaluating expressions.
	// This is a problem for arm where there is no 16-bit comparison op.
	if ^x != 0 {
		panic("^uint16(0xffff) != 0")
	}

	{"bytes=-500", 10000, []httpRange{{9500, 500}}},
	{"bytes=9500-", 10000, []httpRange{{9500, 500}}},
	{"bytes=0-0,-1", 10000, []httpRange{{0, 1}, {9999, 1}}},
	{"bytes=500-600,601-999", 10000, []httpRange{{500, 101}, {601, 399}}},
	{"bytes=500-700,601-999", 10000, []httpRange{{500, 201}, {601, 399}}},

	// Match Apache laxity:
	{"bytes=   1 -2   ,  4- 5, 7 - 8 , ,,", 11, []httpRange{{1, 2}, {4, 2}, {7, 2}}},
}

        when:
        boolean serverError = new HttpErrorStatusCodeException('GET', 'http://localhost:8080/', statusCode, '')

        then:
        serverError

        where:
        statusCode << [499, 600]
    }

		return sum
	})
	done := make(chan bool)
	for i := 0; i < 10; i++ {
		go func() {
			const want = 499500
			got := once()
			if got != want {
				fmt.Println("want", want, "got", got)
			}
			done <- true
		}()
	}
	for i := 0; i < 10; i++ {
		<-done
	}
	// Output:
	// Computed once: 499500
}

// This example uses OnceValues to read a file just once.
func ExampleOnceValues() {

    double dummy = 0.0;
    for (int i = 0; i < reps; i++) {
      dummy += algorithm.singleQuantile(99, 100, dataset(i));
    }
    return dummy;
  }

  @Benchmark
  double percentiles90And99(int reps) {
    double dummy = 0.0;
    for (int i = 0; i < reps; i++) {
      dummy += algorithm.multipleQuantiles(ImmutableSet.of(90, 99), 100, dataset(i)).get(90);
    }
    return dummy;
  }

  @Benchmark

		mku(10, 11, 2),
		mku(15, 11, 1),
	}
	fn2units := []coverage.CoverableUnit{
		mku(20, 25, 3),
		mku(30, 31, 2),
		mku(33, 40, 7),
	}
	fn3units := []coverage.CoverableUnit{
		mku(99, 100, 1),
	}
	fm.SetPackage("my/pack1")
	for k, u := range fn1units {
		fm.AddUnit("p.go", "f1", false, u, uint32(k))
	}
	for k, u := range fn2units {
		fm.AddUnit("q.go", "f2", false, u, 0)

	// 0x5000-0x5fff:    319    962    261      0
	// 0x6000-0x6fff:    322    375    177      0
	// 0x7000-0x7fff:    601    279    214      0
	// 0x8000-0x8fff:   3478    227    273      0
	// 0x9000-0x9fff:   2260    234    329      0
	// 0xa000-0xafff:    921    282    373      0
	// 0xb000-0xbfff:    321    335    397      0
	// 0xc000-0xcfff:    229    388    298      0
	// 0xd000-0xdfff:    260    414    277      0