// Should match first included path
        assertTrue(pattern.match("/test/path"));

        // Should match second included path
        assertTrue(pattern.match("/another/path"));

        // Should not match first excluded path
        assertFalse(pattern.match("/exclude/path"));

        // Should not match second excluded path

   * concurrent maps whose content may change while the method is running.
   *
   * <p>The serialized output consists of the number of entries, first key, first value, second key,
   * second value, and so on.
   */
  static <K extends @Nullable Object, V extends @Nullable Object> void writeMap(
      Map<K, V> map, ObjectOutputStream stream) throws IOException {

                callCount++;
                throw new RuntimeException("Error " + callCount);
            }
        };
        ComponentUtil.register(mockSearchLogHelper, "searchLogHelper");

        // First execution
        String result1 = aggregateLogJob.execute();
        assertNotNull(result1);
        assertTrue(result1.contains("Error 1"));

        // Second execution

          fileSystem.source(this@asRequestBody).use { source -> sink.writeAll(source) }
        }
      }

    @JvmStatic
    @Deprecated(
      message = "Moved to extension function. Put the 'content' argument first to fix Java",
      replaceWith =
        ReplaceWith(
          expression = "content.toRequestBody(contentType)",
          imports = ["okhttp3.RequestBody.Companion.toRequestBody"],
        ),

$(function() {
  $('input[type="text"],select,textarea', ".login-box,section.content")
    .first()
    .focus();
  $(".form-group .has-error")
    .first()
    .next("input,select,textarea")
    .focus();

  $("section.content input").keypress(function(e) {
    var $submitButton;
    if (e.which === 13) {
      $submitButton = $("input#submit, button#submit");
      if ($submitButton.length > 0) {
        $submitButton[0].submit();
      }

   * Returns an immutable multimap containing the specified entries. The returned multimap iterates
   * over keys in the order they were first encountered in the input, and the values for each key
   * are iterated in the order they were encountered. If two values for the same key are {@linkplain
   * Object#equals equal}, the first value encountered is used.
   *
   * @throws NullPointerException if any key, value, or entry is null
   * @since 19.0
   */

        String sessionId = "test_replace";
        List<String> cmdList1 = Arrays.asList("echo", "first");
        List<String> cmdList2 = Arrays.asList("echo", "second");
        Consumer<ProcessBuilder> pbCall = pb -> {
            pb.redirectErrorStream(true);
        };

        try {
            // Start first process
            JobProcess jobProcess1 = processHelper.startProcess(sessionId, cmdList1, pbCall);

  private static Ordering<String> createExplicitComparator(String[] elements) {
    // Collapse equal elements, which Ordering.explicit() doesn't support, while
    // maintaining the ordering by first occurrence.
    Set<String> elementsPlus = new LinkedHashSet<>();
    elementsPlus.add(BEFORE_FIRST);
    elementsPlus.add(BEFORE_FIRST_2);
    elementsPlus.addAll(asList(elements));
    elementsPlus.add(AFTER_LAST);

# /---------------------------------------------------------------------------
# sourceCopyright: (NotRequired - Default '')
#
# The copyright for all class sources.
# This property is NOT map style.
# You should specify before your first generating.
#
#/*
# * Copyright(c) DBFlute TestCo.,TestLtd. All Rights Reserved.
# */

@GwtCompatible
@NullMarked
public class AbstractIteratorTest extends TestCase {

  public void testDefaultBehaviorOfNextAndHasNext() {

    // This sample AbstractIterator returns 0 on the first call, 1 on the
    // second, then signals that it's reached the end of the data
    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          private int rep;

          @Override