@ValidateTypeFailure
    public Integer crudMode;

    /** Input terms (comma-separated) that will be mapped to the output term */
    @Required
    @Size(max = 1000)
    public String inputs;

    /** Output term that input terms will be mapped to */
    @Size(min = 1, max = 1000)
    public String output;

    /**
     * Initializes the form with default values for creating a new mapping dictionary entry.
     */

    @ValidateTypeFailure
    public Integer crudMode;

    /** The input terms that should be considered synonymous */
    @Required
    @Size(max = 1000)
    public String inputs;

    /** The output synonyms that should be matched for the input terms */
    @Required
    @Size(max = 1000)
    public String outputs;

    /**
     * Initializes the form with default values for creating a new synonym entry.
     */

  int charSplitter(int reps) {
    int total = 0;

    for (int i = 0; i < reps; i++) {
      total += Iterables.size(CHAR_SPLITTER.split(input));
    }

    return total;
  }

  @Benchmark
  int stringSplitter(int reps) {
    int total = 0;

    for (int i = 0; i < reps; i++) {
      total += Iterables.size(STRING_SPLITTER.split(input));
    }

    return total;
  }

    List<Object> values = new ArrayList<>(map.values());
    assertEquals(2 * entries.size(), alternatingKeysAndValues.length);
    assertEquals(2 * keys.size(), alternatingKeysAndValues.length);
    assertEquals(2 * values.size(), alternatingKeysAndValues.length);
    for (int i = 0; i < map.size(); i++) {
      Object expectedKey = alternatingKeysAndValues[2 * i];

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String permissions;

    /** The boost score multiplier applied to elevated documents */
    @Required
    @ValidateTypeFailure
    public Float boost;

    /** The username of who created this elevate word entry */
    @Size(max = 1000)
    public String createdBy;

    this.forward = forward;
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return forward.contains(object);
  }

  @Override
  public int size() {
    return forward.size();
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return forward.descendingIterator();
  }

  @Override
  ImmutableSortedSet<E> headSetImpl(E toElement, boolean inclusive) {

      tableSize <<= 1;
      return (tableSize > 0) ? tableSize : MAX_TABLE_SIZE;
    }
    return tableSize;
  }

  static boolean needsResizing(int size, int tableSize, double loadFactor) {
    return size > loadFactor * tableSize && tableSize < MAX_TABLE_SIZE;
  }

        Set set = project1.getArtifacts();
        assertNotNull(set, "No artifacts");
        assertFalse(set.isEmpty(), "No Artifacts");
        assertTrue(set.size() == 3, "Set size should be 3, is " + set.size());

        for (Object aSet : set) {
            Artifact artifact = (Artifact) aSet;
            assertFalse(artifact.getArtifactId().equals("t07-d"));

  fun runningCalls(): List<Call> = (runningSyncCalls + runningAsyncCalls.map { it.call }).unmodifiable()

  @Synchronized
  fun queuedCallsCount(): Int = readyAsyncCalls.size

  @Synchronized
  fun runningCallsCount(): Int = runningAsyncCalls.size + runningSyncCalls.size

  @JvmName("-deprecated_executorService")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "executorService"),

        map = null;
    }

    /**
     * @throws Exception
     */
    @Test
    public void testSize() throws Exception {
        assertThat(map.size(), equalTo(3));
        map.put("3", "test3");
        assertThat(map.size(), equalTo(4));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testIsEmpty() throws Exception {
        assertThat(map.isEmpty(), is(not(true)));