* @return The object bound to <code>jndiName</code>.
     * @throws NamingRuntimeException
     *             Thrown if the initial context cannot be created.
     */
    public static Object lookup(final InitialContext ctx, final String jndiName) throws NamingRuntimeException {
        assertArgumentNotNull("ctx", ctx);
        assertArgumentNotEmpty("jndiName", jndiName);

        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> new NtlmHttpServletRequest(null, mockPrincipal));
        assertEquals("Request cannot be null", ex.getMessage());
    }

    @Test
    @DisplayName("auth type is always NTLM")
    void testAuthTypeConstant(@Mock HttpServletRequest mockRequest, @Mock Principal mockPrincipal) {

    @Override
    public void run() {
        final Thread run_thread = Thread.currentThread();
        Exception ex0 = null;

        try {
            /* We cannot synchronize (run_thread) here or the caller's
             * thread.wait( timeout ) cannot reaquire the lock and
             * return which would render the timeout effectively useless.
             */
            doConnect();
        } catch (final Exception ex) {

  }

  private Absent() {}

  @Override
  public boolean isPresent() {
    return false;
  }

  @Override
  public T get() {
    throw new IllegalStateException("Optional.get() cannot be called on an absent value");
  }

  @Override
  public T or(T defaultValue) {
    return checkNotNull(defaultValue, "use Optional.orNull() instead of Optional.or(null)");
  }

                                }
                            }
                        }
                    }
                }
            }
        } catch (final IOException e) {
            logger.warn("Cannot load subpackages from {}", basePackage, e);
        }

        subPackages.stream().forEach(protocol -> {
            try {

  RecordedRequest request3 = server.takeRequest();
  assertEquals("/v1/chat/messages/3", request3.getUrl().encodedPath());

  // Shut down the server. Instances cannot be reused.
  server.close();
}
```

### Kotlin
```kotlin
fun test() {
  // Create a MockWebServer. These are lean enough that you can create a new
  // instance for every unit test.

-right>.arrow::before{left:0;border-width:.5rem .5rem .5rem 0;border-right-color:rgba(0,0,0,.25)}.bs-popover-auto[x-placement^=right]>.arrow::after,.bs-popover-right>.arrow::after{left:1px;border-width:.5rem .5rem .5rem 0;border-right-color:#fff}.bs-popover-auto[x-placement^=bottom],.bs-popover-bottom{margin-top:.5rem}.bs-popover-auto[x-placement^=bottom]>.arrow,.bs-popover-bottom>.arrow{top:calc(-.5rem - 1px)}.bs-popover-auto[x-placement^=bottom]>.arrow::before,.bs-popover-bottom>.arrow::before...

        }
    }

    /**
     * Unregisters a scheduled job from the job manager.
     *
     * @param scheduledJob the scheduled job to unregister
     * @throws ScheduledJobException if the job cannot be unregistered
     */
    public void unregister(final ScheduledJob scheduledJob) {
        try {
            final JobManager jobManager = ComponentUtil.getJobManager();

    public void test_main_invalidArguments() {
        // Cannot directly test main as it calls System.exit
        // Test argument parsing instead
        SuggestCreator.Options options = new SuggestCreator.Options();
        assertNotNull(options);
    }

    // Test main method with valid arguments
    public void test_main_validArguments() {
        // Cannot directly test main as it calls System.exit

		User:     accessKey,
	})
	if err != nil {
		c.Fatalf("unable to attach policy: %v", err)
	}
	// 2.3 check user has access to bucket
	c.mustListObjects(ctx, uClient, bucket)
	// 2.3 check that user cannot delete the bucket
	err = uClient.RemoveBucket(ctx, bucket)
	if err == nil || err.Error() != "Access Denied." {
		c.Fatalf("bucket was deleted unexpectedly or got unexpected err: %v", err)
	}