// another (constant) declaration.
func (check *Checker) arity(pos syntax.Pos, names []*syntax.Name, inits []syntax.Expr, constDecl, inherited bool) {
	l := len(names)
	r := len(inits)

	const code = WrongAssignCount
	switch {
	case l < r:
		n := inits[l]
		if inherited {
			check.errorf(pos, code, "extra init expr at %s", n.Pos())
		} else {
			check.errorf(n, code, "extra init expr %s", n)

		// number of initializers must match
		if len(info.InitOrder) != len(test.inits) {
			t.Errorf("package %s: got %d initializers; want %d", name, len(info.InitOrder), len(test.inits))
			continue
		}

		// initializers must match
		for i, want := range test.inits {
			got := info.InitOrder[i].String()
			if got != want {

	inittrace: setting inittrace=1 causes the runtime to emit a single line to standard
	error for each package with init work, summarizing the execution time and memory
	allocation. No information is printed for inits executed as part of plugin loading
	and for packages without both user defined and compiler generated init work.
	The format of this line is subject to change. Currently, it is:
		init # @#ms, # ms clock, # bytes, # allocs

		// number of initializers must match
		if len(info.InitOrder) != len(test.inits) {
			t.Errorf("package %s: got %d initializers; want %d", name, len(info.InitOrder), len(test.inits))
			continue
		}

		// initializers must match
		for i, want := range test.inits {
			got := info.InitOrder[i].String()
			if got != want {

            }
            return -1;
        }

        public void add(ScaledUnits<Q> units) {
            this.units.add(units);
            Collections.sort(this.units);
        }
    }

    private static class ScaledUnits<Q> extends Units<Q> {
        private final BaseUnits<Q> baseUnits;

        }
        int diff = units.compareTo(other.units);
        if (diff == 0) {
            return new Amount<>(value.add(other.value), units);
        }
        if (diff < 0) {
            return new Amount<>(value.add(other.units.scaleTo(other.value, units)), units);
        }
        return new Amount<>(units.scaleTo(value, other.units).add(other.value), other.units);
    }

        5.9     | Fruit.apples  | 2      | Fruit.oranges
    }

    def "can add amounts with same units"() {
        expect:
        Amount.valueOf(a, units) + Amount.valueOf(b, units) == Amount.valueOf(c, units)

        where:
        a    | b     | c      | units
        0    | 0     | 0      | Fruit.apples
        1    | 2     | 3      | Fruit.apples
        1    | 2     | 3      | Fruit.oranges

import java.math.BigDecimal;

public class DataAmount {
    public static final Units<DataAmount> BYTES = Units.base(DataAmount.class, "B");
    public static final Units<DataAmount> KILO_BYTES = BYTES.times(1024, "kB");
    public static final Units<DataAmount> MEGA_BYTES = KILO_BYTES.times(1024, "MB");
    public static final Units<DataAmount> GIGA_BYTES = MEGA_BYTES.times(1024, "GB");

import java.math.BigDecimal;

public class Duration {
    public static final Units<Duration> MILLI_SECONDS = Units.base(Duration.class, "ms");
    public static final Units<Duration> SECONDS = MILLI_SECONDS.times(1000, "s");
    public static final Units<Duration> MINUTES = SECONDS.times(60, "m");
    public static final Units<Duration> HOURS = MINUTES.times(60, "h");

    public static Amount<Duration> millis(long millis) {

		pkgs = append(pkgs, importpath)
	}
	slices.Sort(pkgs)
	for _, importpath := range pkgs {
		p := fm.pm[importpath]
		units := make([]extcu, 0, len(p.unitTable))
		for u := range p.unitTable {
			units = append(units, u)
		}
		p.sortUnits(units)
		for _, u := range units {
			count := p.unitTable[u]
			file := p.funcs[u.fnfid].file
			if _, err := fmt.Fprintf(w, "%s:%d.%d,%d.%d %d %d\n",