void shouldExecuteStrategiesInPriorityOrder() throws Exception {
            // This test verifies that strategies are executed in the order they are provided
            // The actual priority ordering is handled by dependency injection
            UpgradeContext context = createMockContext();
            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), mock(Document.class));

        Crawler.Options options = new Crawler.Options();
        // Don't set sessionId to test default generation

        // Mock the container setup to avoid actual initialization
        try {
            // The process method will generate a default sessionId if not provided
            // We can't easily test the static process method directly without full container setup

        assertTrue(repr.contains("typeOfLock=7"));
        assertTrue(repr.contains("newOplockLevel=2"));
    }

    /**
     * Test decoding of bytes buffer that is too short triggers an exception.
     * Note: The actual implementation throws ArrayIndexOutOfBoundsException
     * when the buffer is too short, not SMBProtocolDecodingException.
     */
    @Test
    void readBytesWireFormatTooShortException() {

   * href="#bitEquals">bitwise equal</a> to the expected value.
   *
   * @param expect the expected value
   * @param update the new value
   * @return {@code true} if successful. False return indicates that the actual value was not
   *     bitwise equal to the expected value.
   */
  public final boolean compareAndSet(double expect, double update) {
    return value.compareAndSet(doubleToRawLongBits(expect), doubleToRawLongBits(update));

     * @throws InstantiationRuntimeException
     *             If the underlying constructor represents an abstract class
     * @throws IllegalAccessRuntimeException
     *             If the number of actual and formal parameters differ, if unwrapping of primitive arguments fails,
     *             or if after unwrapping, the parameter values cannot be converted to the corresponding formal parameter types,

            try {
                if (!outputFile.exists()) {
                    outputFile.createNewFile();
                }
                // Write some dummy content to simulate actual thumbnail
                Files.write(outputFile.toPath(), ("thumbnail-" + thumbnailId).getBytes());
                return true;
            } catch (IOException e) {
                return false;
            }

    checkHelperVersion(NO_UNSAFE, "AtomicReferenceFieldUpdaterAtomicHelper");
    checkHelperVersion(NO_ATOMIC_REFERENCE_FIELD_UPDATER, "SynchronizedHelper");

    // Then, run the actual tests under each alternative classloader:

    /*
     * Under Java 8, there is no need to test the no-VarHandle case here: It's already tested by the

        int dstIndex = 0;

        // When
        int bytesWritten = trans2GetDfsReferral.writeParametersWireFormat(dst, dstIndex);

        // Then
        assertTrue(bytesWritten > 0);
        // The actual encoding depends on DfsReferralRequestBuffer implementation
    }

    @Test
    @DisplayName("writeParametersWireFormat with mock request buffer")
    void testWriteParametersWireFormatWithMock() throws Exception {

        Smb2LeaseKey leaseKey = dirManager.requestDirectoryLease(directoryPath,
                Smb2LeaseState.SMB2_LEASE_READ_CACHING | Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING, scope);

        // Perform actual directory enumeration
        SmbFile[] files = smbFile.listFiles();

        // Update cache if we have a directory lease
        if (leaseKey != null) {

     *
     * Here, we check that we're able to force AbstractFutureState to select SynchronizedHelper, and
     * below, we actually run the AbstractFutureTest methods under that scenario.
     */
    checkHelperVersion(NO_ATOMIC_REFERENCE_FIELD_UPDATER, "SynchronizedHelper");

    // Then, run the actual tests under each alternative classloader:

    /*
     * We don't need to test further under NO_UNSAFE: We verified that it selects