when(mockInetAddress.getHostName()).thenReturn(".hostname");
            UniAddress uniAddress = new UniAddress(mockInetAddress);
            // Dot at position 0, which is NOT > 1, so whole string is uppercased
            assertEquals(".HOSTNAME", uniAddress.firstCalledName());
        }

        @Test

```

This way, when you type `python` in the terminal, the system will find the Python program in `C:\opt\custompython\bin` (the last directory) and use that one.

////

So, if you type:

<div class="termy">

```console
$ python
```

</div>

//// tab | Linux, macOS

The system will **find** the `python` program in `/opt/custompython/bin` and run it.

func TestUnlockPanic2(t *testing.T) {
	mu := NewDRWMutex(ds, "test-unlock-panic-2")
	defer func() {
		if recover() == nil {
			t.Fatalf("unlock of unlocked RWMutex did not panic")
		}
		mu.RUnlock(t.Context()) // Unlock, so -test.count > 1 works
	}()
	mu.RLock(id, source)
	mu.Unlock(t.Context())
}

// Borrowed from rwmutex_test.go
func TestRUnlockPanic(t *testing.T) {
	defer func() {
		if recover() == nil {

    for prod and one for tests. However, unlike our other packages, as of this
    writing it has test supersource but no prod supersource.

    GWT happens to use the prod .gwt.xml, so it looks for no supersource for
    tests, either. This causes it to fail to find AtomicLongMapTest.

    Our workaround is to tell GWT that util.concurrent and all other packages

 * }
 *
 * <p>For separator-based splitters that do not use {@code omitEmptyStrings}, an input string
 * containing {@code n} occurrences of the separator naturally yields an iterable of size {@code n +
 * 1}. So if the separator does not occur anywhere in the input, a single substring is returned
 * containing the entire input. Consequently, all splitters split the empty string to {@code [""]}
 * (note: even fixed-length splitters).
 *

   * k <= i < n}.
   *
   * <p>After this method returns, {@code elements} will contain no duplicates, but {@code elements}
   * may be the real array backing the returned set, so do not modify it further.
   *
   * <p>{@code elements} may contain only values of type {@code E}.
   *
   * @throws NullPointerException if any of the first {@code n} elements of {@code elements} is null
   */

import org.testcontainers.junit.jupiter.Testcontainers

@Testcontainers
@Isolated
class BasicLoomTest {
  @JvmField
  @RegisterExtension
  val platform = PlatformRule()

  // Use mock server so we are strictly testing OkHttp client only in this test.
  // We should test MockWebServer later.
  @Container
  val mockServer: MockServerContainer = MockServerContainer(MOCKSERVER_IMAGE)

You can read more about this in the [Advanced User Guide](../advanced/index.md).

## Details { #details }

The first `"/static"` refers to the sub-path this "sub-application" will be "mounted" on. So, any path that starts with `"/static"` will be handled by it.

The `directory="static"` refers to the name of the directory that contains your static files.

 * {@code com.google.common.util.concurrent}) in degenerate class loaders which make certain
 * platform classes unavailable. Then we construct a test suite so we can run the normal
 * AbstractFutureTest test methods in these degenerate classloaders.
 */

@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class AbstractFutureFallbackAtomicHelperTest extends TestCase {

                ? getLoggerForComponent(role)
                : new Slf4jLogger(loggerFactory.getLogger(role + '.' + hint)));
    }

    //
    // Trying to give loggers back is a bad idea. Ceki said so :-)
    // notice to self: what was this method supposed to do?
    //
    /**
     * <b>Warning</b>: ignored.
     */
    @Override
    public void returnComponentLogger(String role) {}

    /**