final List<Map<String, Object>> logList = readLogItems("joblog");
        final List<Map<String, Object>> resList = new ArrayList<>();
        for (Map<String, Object> elem : logList) {
            if (elem.containsKey("job_name") && elem.get("job_name").equals(namePrefix + "Scheduler")) {
                resList.add(elem);
            }
        }
        return resList;
    }

        while (tg.getParent() == null) {
            tg = tg.getParent();
        }

        ThreadGroup[] tgList = new ThreadGroup[tg.activeGroupCount()];
        tg.enumerate(tgList);

        boolean seen = false;

        for (ThreadGroup aTgList : tgList) {
            if (!aTgList.getName().equals(DefaultArtifactResolver.DaemonThreadCreator.THREADGROUP_NAME)) {
                continue;
            }

        final List<Map<String, Object>> logList = readJobLog(NAME_PREFIX);
        logger.info("logList: {}", logList);
        assertEquals(1, logList.size());
    }

    private void testDeleteJobLog() {
        final List<Map<String, Object>> logList = readJobLog(NAME_PREFIX);
        logger.info("logList: {}", logList);
        for (Map<String, Object> elem : logList) {

  public void testSubList_startNegative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().subList(-1, 0));
  }

  public void testSubList_endTooLarge() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().subList(0, getNumElements() + 1));
  }

  public void testSubList_startGreaterThanEnd() {
    try {
      getList().subList(1, 0);
      fail("subList(1, 0) should throw");

   */
  public void testAddAtIndex_unsupportedPresent() {
    assertThrows(UnsupportedOperationException.class, () -> getList().add(0, e0()));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  public void testAddAtIndex_supportedNotPresent() {
    getList().add(0, e3());
    expectAdded(0, e3());
  }

  @CollectionFeature.Require(FAILS_FAST_ON_CONCURRENT_MODIFICATION)

       * are off).
       */
      KeyList<K, V> keyList = requireNonNull(keyToKeyList.remove(node.getKey()));
      keyList.count = 0;
      modCount++;
    } else {
      // requireNonNull is safe (under the conditions listed in the comment in the branch above).
      KeyList<K, V> keyList = requireNonNull(keyToKeyList.get(node.getKey()));
      keyList.count--;

      if (node.previousSibling == null) {

    int index = aValidIndex();
    E initialValue = getList().get(index);
    assertEquals(
        "set(i, x) should return the old element at position i.",
        initialValue,
        getList().set(index, newValue));
    assertEquals("After set(i, x), get(i) should return x", newValue, getList().get(index));
    assertEquals("set() should not change the size of a list.", getNumElements(), getList().size());
  }

  private ArrayTable(ArrayTable<R, C, V> table) {
    rowList = table.rowList;
    columnList = table.columnList;
    rowKeyToIndex = table.rowKeyToIndex;
    columnKeyToIndex = table.columnKeyToIndex;
    @SuppressWarnings("unchecked")
    @Nullable V[][] copy = (@Nullable V[][]) new Object[rowList.size()][columnList.size()];
    array = copy;
    for (int i = 0; i < rowList.size(); i++) {

        assertTrue(pythonJob.argList.isEmpty());

        PythonJob result = pythonJob.arg("arg1");

        assertSame(pythonJob, result);
        assertEquals(1, pythonJob.argList.size());
        assertEquals("arg1", pythonJob.argList.get(0));

        pythonJob.arg("arg2");
        assertEquals(2, pythonJob.argList.size());
        assertEquals("arg2", pythonJob.argList.get(1));
    }

        resetCollection();
        return getList().listIterator();
      }

      @Override
      protected void verify(List<E> elements) {
        expectContents(elements);
      }
    }.test();
  }

  public void testListIterator_tooLow() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().listIterator(-1));
  }

  public void testListIterator_tooHigh() {