CurlException exception = new CurlException("Final message", intermediateCause);

        assertEquals("Final message", exception.getMessage());
        assertSame(intermediateCause, exception.getCause());
        assertSame(rootCause, exception.getCause().getCause());
    }

    @Test
    public void testToString() {
        String message = "Test error message";

        BufferCache cache2 = context.getBufferCache();

        // Then - should be same instances
        assertSame(config1, config2, "Configuration should be consistent");
        assertSame(dfs1, dfs2, "DFS resolver should be consistent");
        assertSame(cache1, cache2, "Buffer cache should be consistent");
    }

    @Test
    @DisplayName("Context should provide working resource creation")

    try {
      try {
        throw exception;
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    } catch (Throwable expected) {
      assertSame(exception, expected);
    }

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());

    assertTrue(suppressor.suppressions.isEmpty());
  }

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.IOException;

import org.junit.jupiter.api.DisplayName;

            byte[] challenge = new byte[] { 1, 2, 3 };
            UniAddress dc = mock(UniAddress.class);

            NtlmChallenge nc = new NtlmChallenge(challenge, dc);

            assertSame(challenge, nc.challenge);
            assertSame(dc, nc.dc);
        }

        @Test
        @DisplayName("Constructor accepts null challenge")
        void testConstructorAcceptsNullChallenge() {

  public void testStrong_simplistic() {
    String canonical = "a";
    String not = new String("a");

    Interner<String> pool = Interners.newStrongInterner();
    assertSame(canonical, pool.intern(canonical));
    assertSame(canonical, pool.intern(not));
  }

  public void testStrong_null() {
    Interner<String> pool = Interners.newStrongInterner();

        List<Rule> rules = ruleManager.getRules();
        assertEquals(3, rules.size());

        // All should be the same instance
        assertSame(testRule, rules.get(0));
        assertSame(testRule, rules.get(1));
        assertSame(testRule, rules.get(2));
    }

    /**
     * Test property changes after registration
     */
    public void test_propertyChangesAfterRegistration() {

    original.put(1, "foo", 'a');
    assertSame(original.columnKeySet(), transpose.rowKeySet());
    assertSame(original.rowKeySet(), transpose.columnKeySet());
    assertSame(original.columnMap(), transpose.rowMap());
    assertSame(original.rowMap(), transpose.columnMap());
    assertSame(original.values(), transpose.values());
    assertEquals(original.row(1), transpose.column(1));

package jcifs.pac;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;

import org.junit.jupiter.api.Test;

/**
 * Tests for the PACDecodingException class.
 */
class PACDecodingExceptionTest {

    /**
     * Test the default constructor.
     */
    @Test
    void testDefaultConstructor() {