systemHelper.filterPathEncoding = "UTF-8";

        String result = systemHelper.encodeUrlFilter("test{}|\\");
        assertEquals("test{}|\\", result);

        result = systemHelper.encodeUrlFilter("test^path");
        assertEquals("test^path", result);

        result = systemHelper.encodeUrlFilter("test space");
        assertEquals("test+space", result);
    }

    @Test

            final IAuthenticationResult result = app.acquireToken(parameters).get(acquisitionTimeout, TimeUnit.MILLISECONDS);
            if (result == null) {
                throw new SsoLoginException("authentication result was null");
            }
            return result;
        } catch (final Exception e) {
            throw new SsoLoginException("Failed to get a token.", e);

        byte[] clientData = hex("A0A1A2A3A4");

        // Act
        byte[] result = NtlmUtil.computeResponse(key, serverChallenge, clientData, 0, clientData.length);

        // Assert: result = mac(16) + clientData
        assertEquals(16 + clientData.length, result.length);
        assertArrayEquals(clientData, Arrays.copyOfRange(result, 16, 16 + clientData.length));
    }

    @Test

        if isinstance(route, routing.APIRoute):
            result = get_openapi_path(
                route=route,
                operation_ids=operation_ids,
                model_name_map=model_name_map,
                field_mapping=field_mapping,
                separate_input_output_schemas=separate_input_output_schemas,
            )
            if result:
                path, security_schemes, path_definitions = result

                Authentication result = new Authentication(
                        authCtx.get(AuthenticationContext.USERNAME), authCtx.get(AuthenticationContext.PASSWORD));
                result.setPrivateKey(authCtx.get(AuthenticationContext.PRIVATE_KEY_PATH));
                result.setPassphrase(authCtx.get(AuthenticationContext.PRIVATE_KEY_PASSPHRASE));
                authCtx.close();

        cleanUpDaemons()
    }

    fun newDaemonListener() =
        object : TestListener {
            override fun beforeTest(test: TestDescriptor) = Unit
            override fun afterTest(test: TestDescriptor, result: TestResult) = Unit
            override fun beforeSuite(suite: TestDescriptor) {
                if (suite.parent == null) {
                    forEachJavaProcess { pid, _ ->

 * attempts to the current point use this function.
 *
 * ```java
 * private int responseCount(Response response) {
 *   int result = 1;
 *   while ((response = response.priorResponse()) != null) {
 *     result++;
 *   }
 *   return result;
 * }
 * ```
 *
 * [1]: https://tools.ietf.org/html/rfc2817
 */
fun interface Authenticator {
  /**

  }

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  public <T extends @Nullable Object> ListenableFuture<T> submit(
      Runnable task, @ParametricNullness T result) {
    return (ListenableFuture<T>) super.submit(task, result);
  }

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  public <T extends @Nullable Object> ListenableFuture<T> submit(Callable<T> task) {

          (state, o) -> state.add((o == null) ? NULL_PLACEHOLDER : o),
          ToOptionalState::combine,
          state -> {
            Object result = state.getElement();
            return (result == NULL_PLACEHOLDER) ? null : result;
          },
          Collector.Characteristics.UNORDERED);

  /**
   * A collector that takes a stream containing exactly one element and returns that element. The

			expected: []int{1, 2, 3},
		},
	}

	for _, testcase := range tests {
		t.Run(testcase.name, func(t *testing.T) {
			result := RTrimSlice(testcase.input, testcase.trimLen)
			if !AssertEqual(result, testcase.expected) {
				t.Errorf("RTrimSlice(%v, %d) = %v; want %v", testcase.input, testcase.trimLen, result, testcase.expected)
			}
		})
	}
}

//go:noinline
func fileWithLineNumWrappedInnerForTest() string {