You can read more about this in the [Advanced User Guide](../advanced/index.md){.internal-link target=_blank}.

## 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.

    /**
     * Default constructor for creating a new rank fusion searcher instance.
     * This constructor initializes the searcher with default values.
     * The searcher name will be lazily initialized when first accessed.
     */
    public RankFusionSearcher() {
        // Default constructor - name will be initialized lazily
    }

    /**
     * Returns the name of this searcher.

        trustManagerFactory.init(keyStoreFactory.loadOrCreateKeyStore())
        val trustManager = trustManagerFactory.trustManagers.first() as X509TrustManager

        sslSocketFactory(socketFactory, trustManager)
      }
  }

        int written = instance.writeParameterWordsWireFormat(dst, 0);
        assertEquals(2, written, "writeParameterWordsWireFormat should write exactly 2 bytes");
        // SMBUtil.writeInt2 writes the low byte first (little‑endian)
        assertEquals((byte) (TEST_SID & 0xFF), dst[0]);
        assertEquals((byte) ((TEST_SID >> 8) & 0xFF), dst[1]);
    }

    @Test
    void testNegativeSidWrapsCorrectly() {
        // -1 == 0xFFFF

     * comparator.
     *
     * <p>The sort order is stable, that is, if two entries have values that compare as equivalent,
     * the entry that was inserted first will be first in the built map's iteration order.
     *
     * @throws IllegalStateException if this method was already called
     * @since 19.0
     */
    @CanIgnoreReturnValue

   *
   * @since 19.0
   */
  public static HashFunction concatenating(
      HashFunction first, HashFunction second, HashFunction... rest) {
    // We can't use Lists.asList() here because there's no hash->collect dependency
    List<HashFunction> list = new ArrayList<>();
    list.add(first);
    list.add(second);
    Collections.addAll(list, rest);

          node.setNext(oldHead);
          if (casWaiters(oldHead, node)) {
            while (true) {
              OverflowAvoidingLockSupport.parkNanos(this, remainingNanos);
              // Check interruption first, if we woke up due to interruption we need to honor that.
              if (Thread.interrupted()) {
                removeWaiter(node);
                throw new InterruptedException();
              }

    }

    public void test_multiple_instances() {
        HotThreadMonitorTarget target1 = new HotThreadMonitorTarget();
        HotThreadMonitorTarget target2 = new HotThreadMonitorTarget();

        assertNotNull("First instance should not be null", target1);
        assertNotNull("Second instance should not be null", target2);
        assertNotSame("Instances should be different objects", target1, target2);
    }

	"fmt"
	"os"
	"path/filepath"
	"strings"
)

var (
	Debug      = flag.Bool("debug", false, "dump instructions as they are parsed")
	OutputFile = flag.String("o", "", "output file; default foo.o for /a/b/c/foo.s as first argument")
	TrimPath   = flag.String("trimpath", "", "remove prefix from recorded source file paths")
	Shared     = flag.Bool("shared", false, "generate code that can be linked into a shared library")

        // Test modifying ID value multiple times
        TestDictionaryItem item = new TestDictionaryItem();

        // Initial value
        assertEquals(0L, item.getId());

        // First modification
        item.id = 50L;
        assertEquals(50L, item.getId());

        // Second modification
        item.id = 100L;
        assertEquals(100L, item.getId());