assertEquals("instance1", transformer1.getName());
        assertEquals("changed2", transformer2.getName());
        assertEquals("instance3", transformer3.getName());
    }

    /**
     * Test name boundary cases
     */
    public void test_name_boundaryCases() {
        // Single character
        testTransformer.setName("a");
        assertEquals("a", testTransformer.getName());

        // Single space

    filesystem, it will continue to be available.

  The question remaining is: Which level of offline mode will we support? It
  seems reasonable to assume that users will be able to tell when localhost is
  not active (in most cases, localhost should be available, even if the rest of
  the network is not). Therefore, let's concentrate on the state where no
  network <beyond localhost> exists, and leave the more extreme state to users

   * into 29 bits):
   *
   * <ul>
   *   <li>If the IPv6 address contains an embedded IPv4 address, the function hashes that.
   *   <li>Otherwise, it hashes the upper 64 bits of the IPv6 address.
   * </ul>
   *
   * <p>A "coerced" IPv4 address is equivalent to itself.
   *

        url = "http://hoge//a/.././//index.html";
        assertEquals("http://hoge/index.html", htmlTransformer.normalizeUrl(url));

        // invalid cases
        url = "http://hoge/index.html;jsessionid";
        assertEquals("http://hoge/index.html;jsessionid", htmlTransformer.normalizeUrl(url));

        url = "http://hoge/index.html;jsessionid?a=1#HOGE";

            // Then: Should return binding's string representation
            assertEquals("mockBindingString", result);
        }
    }

    @Nested
    @DisplayName("Edge Cases and Error Handling")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle null binding toString")
        void testToStringWithNullBinding() {
            // Given: Handle with null binding

/// info | Info

Wie Sie unten sehen werden, ähnelt dies sehr dem Verhalten vor Version 0.106.0, jedoch mit mehreren Verbesserungen und Bugfixes für Sonderfälle.

///

#### Anwendungsfälle mit frühem Exit-Code { #use-cases-with-early-exit-code }

Es gibt einige Anwendungsfälle mit spezifischen Bedingungen, die vom alten Verhalten profitieren könnten, den Exit-Code von Abhängigkeiten mit `yield` vor dem Senden der Response auszuführen.

* The client doesn't have enough privileges for that operation.
* The client doesn't have access to that resource.
* The item the client was trying to access doesn't exist.
* etc.

In these cases, you would normally return an **HTTP status code** in the range of **400** (from 400 to 499).

        void testGetReferrals() {
            assertNotNull(buffer.getReferrals());
            assertEquals(3, buffer.getReferrals().length);
        }
    }

    @Nested
    @DisplayName("Edge Cases and Boundary Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle maximum values")
        void testMaximumValues() {
            byte[] testBuffer = new byte[8];

            assertNotNull(result);
            assertTrue(result.contains("SmbInfoAllocation")); // Note: toString() uses this name
        }
    }

    @Nested
    @DisplayName("Edge Cases and Error Handling")
    class EdgeCasesTests {

        @Test
        @DisplayName("Should handle null buffer in decode")
        void testNullBuffer() {

import org.mockito.Mockito;

import jcifs.Configuration;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;

/**
 * Security-focused test cases for Smb2NegotiateResponse input validation.
 * Tests various malformed input scenarios to ensure proper validation and
 * protection against buffer overflow, integer overflow, and other attacks.
 */