</c:when>
                                                        <c:when test="${data.jobStatus == 'fail'}">
																		<span class="badge bg-danger"><la:message
                                                                                key="labels.joblog_status_fail"/></span>

          null -> return // no open event
          true -> return // found open event
          false -> return@loop // this is not the open event so continue
        }
      }
      Assertions.fail<Any>("event $e without matching start event")
    }
  }

  override fun connectStart(
    route: Route,
    call: Call,
  ) = logEvent(ConnectionEvent.ConnectStart(System.nanoTime(), route, call))

  /**
   * What to do once a plan has executed.
   *
   * If [nextPlan] is not-null, another attempt should be made by following it. If [throwable] is
   * non-null, it should be reported to the user should all further attempts fail.
   *
   * The two values are independent: results can contain both (recoverable error), neither
   * (success), just an exception (permanent failure), or just a plan (non-exceptional retry).
   */

    // TODO: write a test that shows pooled connections detect HTTP/1.0 (vs. HTTP/1.1)
    fail("TODO")
  }

  @Test
  @Disabled
  fun postBodiesRetransmittedOnAuthProblems() {
    fail("TODO")
  }

  @Test
  @Disabled
  fun cookiesAndTrailers() {
    // Do cookie headers get processed too many times?
    fail("TODO")
  }

  @Test
  fun emptyRequestHeaderValueIsAllowed() {

    // Verify that the listener executed in a reasonable amount of time.
    Assert.assertTrue(countDownLatch.await(1L, SECONDS));

    try {
      future.get();
      Assert.fail("This call was supposed to throw an ExecutionException");
    } catch (ExecutionException expected) {
      Assert.assertSame(expectedCause, expected.getCause());
    }
  }

  public void assertTimeout() throws Exception {

    /**
     * Flag indicating an unlock operation to release a previously held lock.
     */
    public static final int SMB2_LOCKFLAG_UNLOCK = 0x4;

    /**
     * Flag indicating the lock should fail immediately if it cannot be granted.
     */
    public static final int SMB2_LOCKFLAG_FAIL_IMMEDIATELY = 0x10;

    private final long offset;
    private final long length;
    private final int flags;

    /**

export MC_HOST_foo=http://foo:foobar123@localhost:9000
mc ls foo/test
mc cat foo/test/issue

# 3. Attempt to upload an object as user `foo` - this will fail with a permissions error.
mc cp /etc/issue myminio/test/issue2

        Query termQuery = new TermQuery(new Term("field", "value"));
        QueryContext context = new QueryContext("test", false);

        try {
            queryCommand.execute(context, termQuery, 1.0f);
            fail("Should throw InvalidQueryException for non-phrase query");
        } catch (InvalidQueryException e) {
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }

     * and will cause {@link #build} to fail.
     */
    @CanIgnoreReturnValue
    public <T extends B> Builder<B> put(Class<T> key, T value) {
      mapBuilder.put(key, value);
      return this;
    }

    /**
     * Associates all of {@code map's} keys and values in the built map. Duplicate keys are not
     * allowed, and will cause {@link #build} to fail.
     *

        "about:blank" -> testData.input!!.toHttpUrlOrNull()
        else -> testData.base!!.toHttpUrl().resolve(testData.input!!)
      }

    if (testData.expectParseFailure()) {
      assertThat(url, "Expected URL to fail parsing").isNull()
      return
    }

    assertThat(url, "Expected URL to parse successfully, but was null")
      .isNotNull()
    val effectivePort =
      when {