@Override
    public String call() {
      return "foo";
    }
  }

  /** Simple same thread listening executor service that doesn't handle shutdown. */
  private static class TestListeningExecutorService extends AbstractListeningExecutorService {

    @Override
    public void execute(Runnable runnable) {
      assertThat(runnable).isInstanceOf(TrustedListenableFutureTask.class);
      runnable.run();
    }

      for (shift in (lengthByteCount - 1) * 8 downTo 0 step 8) {
        sink.writeByte((length shr shift).toInt())
      }
    }

    // Write the payload.
    sink.writeAll(content)
  }

  /**
   * Execute [block] with a new namespace for type hints. Type hints from the enclosing type are no
   * longer usable by the current type's members.
   */
  fun <T> withTypeHint(block: () -> T): T {
    typeHintStack.add(null)

    static class ExecResult {
        String stdout
        String stderr
        int returnCode
    }

    static ExecResult exec(String command) {
        Process process = command.execute()
        def stdoutFuture = readStreamAsync(process.inputStream)
        def stderrFuture = readStreamAsync(process.errorStream)

        int returnCode = process.waitFor()
        String stdout = stdoutFuture.get()

    void testGetRemoteUser() {
        // Arrange: Define the expected user name from the principal
        String expectedUserName = "testUser";
        when(mockPrincipal.getName()).thenReturn(expectedUserName);

        // Act: Call the method under test
        String actualUserName = ntlmRequest.getRemoteUser();

        // Assert: Verify that the returned user name is the expected one

        @Test
        void knownErrorCodes() {
            assertEquals(71, WinError.ERROR_REQ_NOT_ACCEP, "ERROR_REQ_NOT_ACCEP expected 71");
            assertEquals(230, WinError.ERROR_BAD_PIPE, "ERROR_BAD_PIPE expected 230");
            assertEquals(6118, WinError.ERROR_NO_BROWSER_SERVERS_FOUND, "ERROR_NO_BROWSER_SERVERS_FOUND expected 6118");
        }
    }

    @Nested
    @DisplayName("Array content checks")
    class ArrayChecks {

    void constructorMasksValue(int input) {
        NdrShort ns = new NdrShort(input);
        // NdrShort masks to 0xFF (8 bits) in its constructor
        int expected = input & 0xFF;
        assertEquals(expected, ns.value, "value should be masked to 0xFF before storing");
    }

    /**
     * Round-trip encode/decode for a selection of representative values.
     */
    @ParameterizedTest

        .url("https://www.googleapis.com/urlshortener/v1/url?key=" + GOOGLE_API_KEY)
        .post(jsonRequestBody)
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

  public void addListener(Runnable listener, Executor executor) {
    checkNotNull(listener, "Runnable was null.");
    checkNotNull(executor, "Executor was null.");
    try {
      executor.execute(listener);
    } catch (Exception e) { // sneaky checked exception
      // ListenableFuture's contract is that it will not throw unchecked exceptions, so log the bad
      // runnable and/or executor and swallow it.
      log.get()
          .log(

# Testando Dependências com Sobreposição (Overrides)

## Sobrepondo dependências durante os testes

Existem alguns cenários onde você deseje sobrepor uma dependência durante os testes.

Você não quer que a dependência original execute (e nenhuma das subdependências que você possa ter).

            fail("Should throw ScheduledJobException");
        } catch (ScheduledJobException e) {
            assertEquals("No job.", e.getMessage());
        } catch (Exception e) {
            // Expected due to missing dependencies in test environment
            assertTrue(true);
        }
    }

    public void test_register_with_cron_null_scheduledJob() {
        try {