// a.T.m instead of b.T.m.
func F1(i interface{ m() }) { i.m() }

// The interface method calling convention depends on interface method
// sets being sorted in the same order across compilation units.  In
// the test case below, at the call to b.F2(b.T{}) in c.go, the
// interface method set is sorted as { a.m(); b.m() }.
//
// However, while compiling package b, its package path is set to "",

 * Read for instance http://docs.codehaus.org/display/MAVEN/Deterministic+Lifecycle+Planning
 * </p>
 * <p>
 * In their current implementation they are "bolted" onto the lifecycle by separating them
 * into TaskSegments. This class represents the execution context of one such task segment.
 * </p>
 * <p>

}

func installSimulator(appdir string) error {
	cmd := exec.Command(
		"xcrun", "simctl", "install",
		"booted", // Install to the booted simulator.
		appdir,
	)
	if out, err := cmd.CombinedOutput(); err != nil {
		os.Stderr.Write(out)
		return fmt.Errorf("xcrun simctl install booted %q: %v", appdir, err)
	}
	return nil
}

func uninstallDevice(bundleID string) error {
	cmd := idevCmd(exec.Command(

            // We sort based on the original classpath to we keep the original order,
            // we also rely on the fact that for ordered streams `sorted()` method has stable sort.
            .sorted((first, second) -> ordering.compare(first.originalIdentifier, second.originalIdentifier))
            .map(artifact -> artifact.file)
            .collect(Collectors.toList());
    }

    /**
     * Returns a comparator that groups opposite option pairs together.
     *
     * <p>Options are sorted in the natural order of their names,
     * except for disable options which are sorted after their opposite option.
     * For example, {@code "--foo"} and {@code "--no-foo"} are grouped together
     * and are sorted after {@code "--bar"} and {@code "--no-bar"}.
     *

			if err != nil {
				t.Fatal(err)
			}
		}
		adopted, err := history.ReleaseControllerRevision(test.parent, test.revision)
		if !test.err {
			if err != nil {
				t.Errorf("%s: %s", test.name, err)
			}
			if adopted == nil {
				return
			}
			if metav1.IsControlledBy(adopted, test.parent) {
				t.Errorf("%s: release failed", test.name)
			}
		}

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Basic implementation of the {@link SortedSetMultimap} interface. It's a wrapper around {@link
 * AbstractMapBasedMultimap} that converts the returned collections into sorted sets. The {@link
 * #createCollection} method must return a {@code SortedSet}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault

	const C0 = 0

	// C1 should be second. 
	const C1 = 1

	// C2 should be third. 
	const C2 = 2

	// 
	const (
		// Single const declarations inside ()'s are considered ungrouped
		// and show up in sorted order.
		Cungrouped = 0
	)


VARIABLES
	// VBx variables should appear before VAx variables. 
	var (
		VB2	int	// before VB1
		VB1	int	// before VB0
		VB0	int	// at end
	)

 *  Reports failure with no other action.
 */
#define CU_ASSERT(value) \
  { CU_assertImplementation((value), __LINE__, #value, __FILE__, "", CU_FALSE); }

/** Simple assertion.
 *  Reports failure and causes test to abort.
 */
#define CU_ASSERT_FATAL(value) \
  { CU_assertImplementation((value), __LINE__, #value, __FILE__, "", CU_TRUE); }

/** Simple assertion.
 *  Reports failure with no other action.
 */

	// this annotation is added automatically.
	annotation.IoIstioRev.Name: true,

	// TODO below are ambient related annotations that are not yet known to be stable.
	// They are added automatically, and should not be alerted on.
	// Delete these related annotations once they are stable.
	// Ref: https://github.com/istio/api/pull/2695
	constants.AmbientWaypointForTrafficTypeLabel: true,
	constants.AmbientRedirection:                 true,
}