}
    }

    @Test
    void testConstructor_OtherDcerpcException() throws DcerpcException, IOException {
        // Test case: Constructor with other DcerpcException, should rethrow
        String server = "testServer";
        int access = 123;
        DcerpcException expectedException = new DcerpcException("Other error") {
            @Override
            public int getErrorCode() {

            // Submit a write that will throw inside the writer thread
            w.write(payload, payload.length, out);

            // Give the writer thread time to process and set exception
            w.wait(100);
        }

        // Wait a bit more to ensure exception is captured
        Thread.sleep(100);

        // Act + Assert: checkException should throw the SmbException captured by the thread

        } catch (final JobProcessingException e) {
            // Rethrow JobProcessingException to allow scripts to signal job-specific errors
            // that should be handled by the job framework
            if (logger.isDebugEnabled()) {
                logger.debug("Script raised JobProcessingException", e);
            }
            throw e;
        } catch (final Exception e) {

        verify(tree, times(1)).release(); // closed in constructor
    }

    @Test
    @DisplayName("open() throwing CIFSException triggers close and rethrow")
    void constructorOpenThrows() {
        // Arrange
        stubAcquireReturnsSelf();
        List<FileEntry[]> pages = List.of(new FileEntry[][] { new FileEntry[] { entry("x") } });

        // Act + Assert

        return ByteStreams.toByteArray(in, in.getChannel().size());
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    }

    @Override
    public String toString() {
      return "Files.asByteSource(" + file + ")";
    }
  }

  /**

        return ByteStreams.toByteArray(in, in.getChannel().size());
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    }

    @Override
    public String toString() {
      return "Files.asByteSource(" + file + ")";
    }
  }

  /**

        jarOut.putNextEntry(new ZipEntry(entry));
        Resources.copy(ClassPathTest.class.getResource(entry), jarOut);
        jarOut.closeEntry();
      }
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  private static Manifest manifest(String content) throws IOException {
    InputStream in = new ByteArrayInputStream(content.getBytes(US_ASCII));

        jarOut.putNextEntry(new ZipEntry(entry));
        Resources.copy(ClassPathTest.class.getResource(entry), jarOut);
        jarOut.closeEntry();
      }
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  private static Manifest manifest(String content) throws IOException {
    InputStream in = new ByteArrayInputStream(content.getBytes(US_ASCII));

                if (!strict) {
                    throw e;
                }

                options.put(ModelProcessor.IS_STRICT, Boolean.FALSE);

                try {
                    model = modelProcessor.read(modelSource.getInputStream(), options);
                } catch (ModelParseException ne) {
                    // still unreadable even in non-strict mode, rethrow original error
                    throw e;

  }

  // Set up a closeable to expect to be closed, and optionally to throw an
  // exception.
  private void setupCloseable(boolean shouldThrow) throws IOException {
    mockCloseable = mock(Closeable.class);
    if (shouldThrow) {
      doThrow(new IOException("This should only appear in the logs. It should not be rethrown."))
          .when(mockCloseable)
          .close();
    }
  }