@Override
  protected Map<String, Integer> makePopulatedMap() {
    return ImmutableMap.of("one", 1);
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "minus one";
  }

  @Override
  protected Integer getValueNotInPopulatedMap() {
    return -1;
  }

    )
  }

  @Test fun executeRepeated() {
    val delays = mutableListOf(50.µs, 150.µs, -1L)
    redQueue.schedule("task", 100.µs) {
      log += "run@${taskFaker.nanoTime}"
      return@schedule delays.removeAt(0)
    }

    taskFaker.advanceUntil(0.µs)
    assertThat(log).containsExactly()

    taskFaker.advanceUntil(100.µs)
    assertThat(log).containsExactly("run@100000")

    int sum = 0;
    for (Entry<?> entry : entries) {
      sum += entry.getCount();
    }
    return sum;
  }

  private enum SubMultisetSpec {
    TAIL_CLOSED {
      @Override
      <E> List<Entry<E>> expectedEntries(int targetEntry, List<Entry<E>> entries) {
        return entries.subList(targetEntry, entries.size());
      }

      @Override
      <E> SortedMultiset<E> subMultiset(

    @Override
    protected int getDefaultPort() {
        return SmbConstants.DEFAULT_PORT;
    }

    @Override
    public URLConnection openConnection(final URL u) throws IOException {
        if (log.isDebugEnabled()) {
            log.debug("Opening file " + u);
        }
        return new SmbFile(u, getTransportContext());
    }

    /**
     * @return
     */
    private CIFSContext getTransportContext() {

 */
@Deprecated
public class FileProfileActivator extends DetectedProfileActivator implements LogEnabled {
    private Logger logger;

    @Override
    protected boolean canDetectActivation(Profile profile) {
        return profile.getActivation() != null && profile.getActivation().getFile() != null;
    }

    @Override
    public boolean isActive(Profile profile) {
        Activation activation = profile.getActivation();

    /**
     * Whether this metadata should be stored alongside the artifact.
     *
     * @return whether this metadata should be stored alongside the artifact
     */
    boolean storedInArtifactVersionDirectory();

    /**
     * Whether this metadata should be stored alongside the group.
     *
     * @return whether this metadata should be stored alongside the group
     */
    boolean storedInGroupDirectory();

    assertEquals(
        "next() should still return first element after peeking", "A", peekingIterator.next());

    assertEquals("Should be able to peek() at middle element", "B", peekingIterator.peek());
    assertEquals(
        "Should be able to peek() middle element multiple times", "B", peekingIterator.peek());
    assertEquals(
        "next() should still return middle element after peeking", "B", peekingIterator.next());

        functionScoreQueryBuilder.boostMode(CombineFunction.REPLACE);
        return functionScoreQueryBuilder;
    }

    /**
     * Builds the OpenSearch rescorer for popular words.
     * @return The QueryRescorerBuilder instance.
     */
    protected QueryRescorerBuilder buildRescore() {
        return new QueryRescorerBuilder(

            return scriptFile.getAbsolutePath() + " $INPUT_FILE $OUTPUT_FILE";
        }
    }

    private String getCommandStdout(final File scriptFile) {
        if (File.separator.equals("/")) {
            // Unix
            return "sh " + scriptFile.getAbsolutePath() + " $INPUT_FILE";
        } else {
            // Windows
            return scriptFile.getAbsolutePath() + " $INPUT_FILE";
        }
    }

      table.put(
          (String) data[i], (Integer) data[i + 1], nullableCellValue((Character) data[i + 2]));
    }
  }

  protected boolean supportsRemove() {
    return true;
  }

  protected boolean supportsNullValues() {
    return false;
  }

  public void testClear() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    if (supportsRemove()) {
      table.clear();