service.awaitRunning();
      assertThat(service.state()).isNotEqualTo(State.STARTING);
    }

    @Override
    public synchronized void stopping(State from) {
      assertEquals(from, Iterables.getLast(stateHistory));
      stateHistory.add(State.STOPPING);
      if (from == State.STARTING) {
        try {
          service.awaitRunning();
          fail();
        } catch (IllegalStateException expected) {

                    parseHtmlEncodedChar(text);
                } else if (scanner.lookingAt(HTML_ENTITY)) {
                    parseHtmlEntity(text);
                } else {
                    text.append(scanner.getFirst());
                    scanner.next();
                }
            }

            visitor.onText(text.toString());
        }
        visitor.onEnd();
    }

    private void skipComment() {

     */
    static boolean isExternalRepo(ArtifactRepository originalRepository) {
        try {
            URL url = new URL(originalRepository.getUrl());
            return !(isLocal(url.getHost()) || url.getProtocol().equals("file"));
        } catch (MalformedURLException e) {
            // bad url just skip it here. It should have been validated already, but the wagon lookup will deal with it
            return false;

        assertEquals(1, list.size());
        assertEquals("playwright", list.get(0).getFirst());
        assertEquals("http://.*", list.get(0).getSecond().pattern());

        list = crawlerThread.getClientRuleList("playwright:http://.*,playwright:https://.*");
        assertEquals(2, list.size());
        assertEquals("playwright", list.get(0).getFirst());
        assertEquals("http://.*", list.get(0).getSecond().pattern());

    assertThat(Iterators.getLast(iterator, "bar")).isEqualTo("foo");
  }

  public void testGetLast_withDefault_empty() {
    Iterator<String> iterator = emptyIterator();
    assertThat(Iterators.getLast(iterator, "bar")).isEqualTo("bar");
  }

  public void testGetLast_withDefault_empty_null() {
    Iterator<String> iterator = emptyIterator();
    assertThat(Iterators.<@Nullable String>getLast(iterator, null)).isNull();

                .collect(Collectors.groupingBy(Pair::getFirst, Collectors.mapping(Pair::getSecond, Collectors.toList())));
        sourceMap.put("searchField", searchFieldMap);
        final Map<String, List<String>> headerMap = headerList.stream()
                .collect(Collectors.groupingBy(Pair::getFirst, Collectors.mapping(Pair::getSecond, Collectors.toList())));
        sourceMap.put("headers", headerMap);

        }
        return this.transportContext;
    }

    @Override
    protected void parseURL(final URL u, String spec, final int start, int limit) {
        final String host = u.getHost();
        String path, ref;
        int port;

        if (spec.equals("smb://")) {
            spec = "smb:////";
            limit += 2;

    }

    public ReservedPortRange reservePortRange() {
        Pair<Integer, Integer> portRange = getNextPortRange(reservations.size());
        ReservedPortRange range = portRangeFactory.getReservedPortRange(portRange.getLeft(), portRange.getRight());
        reservations.add(range);
        return range;
    }

        defaultResponseHeaders.forEach(header -> callback.accept(header.getFirst(), header.getSecond()));
        final List<Pair<String, String>> headers = responseHeaderMap.get(mimeType);
        if (headers != null) {
            headers.forEach(header -> callback.accept(header.getFirst(), header.getSecond()));
        }
    }

     * @return the last element, or null if the collection is empty
     * @since Java 21
     */
    public static <E> E getLast(final SequencedCollection<E> collection) {
        return collection.isEmpty() ? null : collection.getLast();
    }

    /**
     * Adds an element to the beginning of a sequenced collection.
     *
     * @param <E> the element type