};

        SmbException ex = assertThrows(SmbException.class, () -> filter.accept(mockDir, "x"));
        assertEquals("boom", ex.getMessage(), "Exception message should be preserved");
        verifyNoInteractions(mockDir);
    }

    /**
     * Interaction with dependency: implementation can use directory's methods to make decisions.
     * Tests a filter that uses directory path information.

        byte[] encrypted = storage.encryptCredentials(plaintext);
        char[] decrypted = storage.decryptCredentials(encrypted);

        assertArrayEquals(plaintext, decrypted, "Unicode should be preserved");

        // Clean up
        Arrays.fill(plaintext, '\0');
        Arrays.fill(decrypted, '\0');
    }

    @Test

    static Stream<Arguments> nameProvider() {
        return Stream.of(Arguments.of("", "empty string is allowed"), Arguments.of(" ", "single space is preserved"),
                Arguments.of("复杂名.txt", "unicode name is preserved"), Arguments.of(null, "null name is passed through"));
    }

    @ParameterizedTest(name = "getName returns as-set: [{0}] - {1}")
    @MethodSource("nameProvider")

 *
 * <p>This class does <i>not</i> forward the {@code hashCode} and {@code equals} methods through to
 * the backing object, but relies on {@code Object}'s implementation. This is necessary to preserve
 * the symmetry of {@code equals}. Custom definitions of equality are usually based on an interface,
 * such as {@code Set} or {@code List}, so that the implementation of {@code equals} can cast the

        for (String pipeName : pipeNames) {
            TransWaitNamedPipe pipe = new TransWaitNamedPipe(pipeName);
            assertEquals(pipeName, pipe.name, "Pipe name should be preserved: " + pipeName);
            assertEquals(ServerMessageBlock.SMB_COM_TRANSACTION, pipe.command);
            assertEquals(SmbComTransaction.TRANS_WAIT_NAMED_PIPE, pipe.subCommand);
        }
    }

        // Act
        SMBSignatureValidationException ex = new SMBSignatureValidationException("msg", mocked);

        // Assert
        assertSame(mocked, ex.getCause(), "Mocked cause should be preserved");
        verifyNoInteractions(mocked);
    }

    // Reflection-based check: ensure serialVersionUID remains the declared constant
    @Test
    @DisplayName("serialVersionUID matches declared constant")

 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	_, isEncrypted := crypto.IsEncrypted(mi.UserDefined)

	// Read compression metadata preserved in the init multipart for the decision.
	_, isCompressed := mi.UserDefined[ReservedMetadataPrefix+"compression"]
	// Compress only if the compression is enabled during initial multipart.
	var idxCb func() []byte

                    assertTrue(e instanceof TransportException);
                }
            });
        }

        @Test
        @DisplayName("Should preserve IOException behavior")
        void testIOExceptionBehavior() {
            String message = "IO operation failed";
            TransportException exception = new TransportException(message);

import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.testing.SerializableTester;
import org.junit.Ignore;

/**
 * Basic reserialization test for collection types that must preserve {@code equals()} behavior when
 * reserialized. (Sets and Lists, but not bare Collections.)
 *
 * @author Louis Wasserman
 */
@GwtCompatible