assertEquals("[2001:db8::1]", IpAddressUtil.formatForUrl("2001:db8::1"));
        assertEquals("[fe80::1]", IpAddressUtil.formatForUrl("fe80::1"));

        // IPv6 addresses already with brackets - should not double-wrap
        assertEquals("[::1]", IpAddressUtil.formatForUrl("[::1]"));
        assertEquals("[2001:db8::1]", IpAddressUtil.formatForUrl("[2001:db8::1]"));

        // IPv4 addresses - should remain unchanged

        principalVector.add(new DERTaggedObject(true, 1, new DERSequence(principalNameVector)));
        v.add(new DERTaggedObject(true, 3, new DERSequence(principalVector)));

        // Wrap in APPLICATION tag as expected by KerberosEncData
        DERSequence seq = new DERSequence(v);
        return new DERTaggedObject(false, BERTags.APPLICATION, 3, seq).getEncoded();
    }

    @Test

    Class<?> sepFwrC = sepLoader.loadClass(MyFinalizableWeakReference.class.getName());
    Constructor<?> sepFwrCons = sepFwrC.getConstructor(Object.class, sepFrqC);
    // The object that we will wrap in FinalizableWeakReference is a Stopwatch.
    Class<?> sepStopwatchC = sepLoader.loadClass(Stopwatch.class.getName());
    assertThat(sepLoader).isSameInstanceAs(sepStopwatchC.getClassLoader());

         * simply rethrow an exception (e.getCause()) that may in rare cases have come from another
         * thread. To accomplish both goals, we wrap that IllegalArgumentException in a new
         * instance.
         */
        throw new IllegalArgumentException(e.getCause().getMessage(), e.getCause());
      }
      /*

    Class<?> sepFwrC = sepLoader.loadClass(MyFinalizableWeakReference.class.getName());
    Constructor<?> sepFwrCons = sepFwrC.getConstructor(Object.class, sepFrqC);
    // The object that we will wrap in FinalizableWeakReference is a Stopwatch.
    Class<?> sepStopwatchC = sepLoader.loadClass(Stopwatch.class.getName());
    assertThat(sepLoader).isSameInstanceAs(sepStopwatchC.getClassLoader());

        void testMessagePreservation() {
            String originalMessage = "Original error";
            TransportException original = new TransportException(originalMessage);

            // Wrap in another exception
            TransportException wrapper = new TransportException("Wrapper", original);

            assertEquals("Wrapper", wrapper.getMessage());
            assertEquals(original, wrapper.getRootCause());

        assertNotNull(conn);
        assertTrue(conn instanceof SmbFile, "Connection should be an instance of SmbFile");
        SmbFile file = (SmbFile) conn;
        assertEquals(url, file.getURL(), "Returned SmbFile should wrap the given URL");
        assertSame(mockCtx, file.getContext(), "SmbFile must use the provided CIFSContext");
        verify(mockCtx, atLeastOnce()).getConfig(); // interaction with dependency
    }

    @Test

    public Throwable getRootCause() {
        return this.getCause();
    }

    /**
     * @param e
     * @return a CIFS exception wrapped in an SmbException
     */
    static SmbException wrap(final CIFSException e) {
        if (e instanceof SmbException) {
            return (SmbException) e;
        }
        return new SmbException(e.getMessage(), e);
    }

	}()
	enc := json.NewEncoder(buf)
	err = enc.Encode(j.val)
	if err != nil {
		return b, err
	}
	return msgp.AppendBytes(b, buf.Bytes()), nil
}

// UnmarshalMsg will JSON marshal the value and wrap as a msgp byte array.
// Nil values are supported.
func (j *JSON[T]) UnmarshalMsg(bytes []byte) ([]byte, error) {
	if bytes, err := msgp.ReadNilBytes(bytes); err == nil {
		if j.val != nil {
			j.p.pool.Put(j.val)

    private final Object connectionLock = new Object();

    /**
     * Creates a new RDMA transport wrapping the given delegate transport.
     *
     * @param delegate the underlying SMB transport to wrap
     * @param context the CIFS context for configuration
     */
    public RdmaTransport(SmbTransportInternal delegate, CIFSContext context) {
        this.delegate = delegate;