@GwtCompatible
@Immutable(containerOf = {"R", "C", "V"})
final class SparseImmutableTable<R, C, V> extends RegularImmutableTable<R, C, V> {
  static final ImmutableTable<Object, Object, Object> EMPTY =
      new SparseImmutableTable<>(ImmutableList.of(), ImmutableSet.of(), ImmutableSet.of());

  private final ImmutableMap<R, ImmutableMap<C, V>> rowMap;
  private final ImmutableMap<C, ImmutableMap<R, V>> columnMap;

    private final LifeCyclePluginAnalyzer lifeCyclePluginAnalyzer;
    private final DefaultLifecycles defaultLifeCycles;
    private final LifecycleTaskSegmentCalculator lifecycleTaskSegmentCalculator;
    private final LifecycleExecutionPlanCalculator lifecycleExecutionPlanCalculator;
    private final MojoExecutor mojoExecutor;
    private final LifecycleStarter lifecycleStarter;

    @Inject

    public static final String VENDOR_ADOPTIUM = "adoptium";
    public static final String VENDOR_OPENJDK = "openjdk";

    private static final String REPO_NAME_PREFIX = "jdk_repo_";
    private static final String EXTENSION_NAME = "jdks";
    public static final String JDK_TRIMMED_PREFIX = "(jdk-?\\d.*)|(zulu-?\\d.+).jdk";
    public static final String ZULU_LINUX_AARCH_PATTERN = "zulu.*linux_aarch64";

    private final Logger logger = LoggerFactory.getLogger(getClass());

    private final ExecutionEventCatapult eventCatapult;

    private final DefaultLifecycles defaultLifeCycles;

    private final BuildListCalculator buildListCalculator;

    private final LifecycleDebugLogger lifecycleDebugLogger;

    private final LifecycleTaskSegmentCalculator lifecycleTaskSegmentCalculator;

import java.lang.reflect.Method;

/**
 * Context for an exception thrown by a subscriber.
 *
 * @since 16.0
 */
public class SubscriberExceptionContext {
  private final EventBus eventBus;
  private final Object event;
  private final Object subscriber;
  private final Method subscriberMethod;

  /**
   * @param eventBus The {@link EventBus} that handled the event and the subscriber. Useful for

/**
 * An ordering that orders elements by applying an order to the result of a function on those
 * elements.
 */
@GwtCompatible
final class ByFunctionOrdering<F extends @Nullable Object, T extends @Nullable Object>
    extends Ordering<F> implements Serializable {
  final Function<F, ? extends T> function;
  final Ordering<T> ordering;

  ByFunctionOrdering(Function<F, ? extends T> function, Ordering<T> ordering) {

 *
 * @author Bob Lee
 * @since 10.0
 */
@GwtCompatible
final class FunctionalEquivalence<F, T> extends Equivalence<F> implements Serializable {

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

  private final Function<? super F, ? extends @Nullable T> function;
  private final Equivalence<T> resultEquivalence;

  FunctionalEquivalence(

        exception.expectMessage(is("index=2"));
        final ArrayIterator<Integer> itr = new ArrayIterator<Integer>(new Integer[] { 1, 2 });
        itr.next();
        itr.next();
        itr.next();
    }

    /**
     *
     */
    @Test
    public void testHasNext() {
        final ArrayIterator<String> itr = new ArrayIterator<String>("A", "B");

     */
    @Test
    public void testToCalendar() throws Exception {
        final Date date = new Date();
        final Calendar cal = CalendarConversionUtil.toCalendar(date);
        assertEquals(date, cal.getTime());
    }

    /**
     *
     * @throws Exception
     */
    @Test
    public void testLocalize() throws Exception {
        final Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("JST"));

 *
 * @author Louis Wasserman
 */
@GwtCompatible
class FilteredKeyMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMultimap<K, V> implements FilteredMultimap<K, V> {
  final Multimap<K, V> unfiltered;
  final Predicate<? super K> keyPredicate;

  FilteredKeyMultimap(Multimap<K, V> unfiltered, Predicate<? super K> keyPredicate) {
    this.unfiltered = checkNotNull(unfiltered);