*/
        List<String> genericList(List<Integer> param);

        /**
         * @param param
         * @return 戻り値
         */
        @SuppressWarnings("rawtypes")
        Map rawMap(Map param);

        /**
         * @param param
         * @return 戻り値
         */
        Map<String, Class<?>> genericMap(Map<Integer, String> param);

    }

  }

  private Striped<Lock> striped;
  private int[] stripes;
  private List<Integer> bulkGetSet;

  @BeforeExperiment
  void setUp() {
    this.striped = impl.get(numStripes);
    stripes = new int[numStripes];
    for (int i = 0; i < numStripes; i++) {
      stripes[i] = i;
    }
    List<Integer> asList = Ints.asList(stripes);
    Collections.shuffle(asList, new Random(0xdeadbeef));

        registerModifiedProperty("replacement");
        this.replacement = value;
    }

    public Integer getSortOrder() {
        checkSpecifiedProperty("sortOrder");
        return sortOrder;
    }

    public void setSortOrder(Integer value) {
        registerModifiedProperty("sortOrder");
        this.sortOrder = value;
    }

    public String getUpdatedBy() {

  protected volatile boolean throwException = false;

  protected final ListenableFutureTask<Integer> task =
      ListenableFutureTask.create(
          new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
              runLatch.countDown();
              taskLatch.await();
              if (throwException) {

        // Boosters should be executed in priority order (3, 2, 1)
        List<Integer> executionOrder = PriorityTrackingBooster.getExecutionOrder();
        assertEquals(3, executionOrder.size());
        assertEquals(Integer.valueOf(3), executionOrder.get(0));
        assertEquals(Integer.valueOf(2), executionOrder.get(1));
        assertEquals(Integer.valueOf(1), executionOrder.get(2));
    }

  @Override
  public void add(int index, @ParametricNullness E element) {
    delegate().add(index, element);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean addAll(int index, Collection<? extends E> elements) {
    return delegate().addAll(index, elements);
  }

  @Override
  @ParametricNullness
  public E get(int index) {
    return delegate().get(index);
  }

  @Override

    xLongs = new long[SAMPLE_SIZE];
    yLongs = new long[SAMPLE_SIZE];
    constant = new int[SAMPLE_SIZE];
    for (int i = 0; i < SAMPLE_SIZE; i++) {
      xInts[i] = random.nextInt(Integer.MAX_VALUE);
      yInts[i] = random.nextInt(Integer.MAX_VALUE);
      xLongs[i] = random.nextLong() & NONNEGATIVE_LONG_MASK;
      yLongs[i] = random.nextLong() & NONNEGATIVE_LONG_MASK;
      constant[i] = random.nextInt();
    }
  }

  }

  public static final class ExceptionWithoutThrowableConstructor extends Exception {
    public ExceptionWithoutThrowableConstructor(String s) {
      super(s);
    }
  }

  public static final class ExceptionWithWrongTypesConstructor extends Exception {
    public ExceptionWithWrongTypesConstructor(Integer i, String s) {
      super(s);
    }
  }

     */
    public static Object convertPrimitiveWrapper(final Class<?> type, final Object o) {
        if (type == int.class) {
            final Integer i = IntegerConversionUtil.toInteger(o);
            if (i != null) {
                return i;
            }
            return Integer.valueOf(0);
        } else if (type == double.class) {
            final Double d = DoubleConversionUtil.toDouble(o);
            if (d != null) {

  static final class ElementSet<E> extends ImmutableSet.Indexed<E> {
    private final List<Entry<E>> entries;
    // TODO(cpovirk): @Weak?
    private final Multiset<E> delegate;

    ElementSet(List<Entry<E>> entries, Multiset<E> delegate) {
      this.entries = entries;
      this.delegate = delegate;
    }

    @Override
    E get(int index) {
      return entries.get(index).getElement();
    }

    @Override