* a different Properties object/file to be used as the source of properties for
     * use by the jCIFS library. The Properties must be set <i>before jCIFS
     * classes are accessed</i> as most jCIFS classes load properties statically once.
     * Using this method will also override properties loaded
     * using the <code>-Djcifs.properties=</code> commandline parameter.
     */

    /**

   * which loaded -> ReferenceMap.class which has a static -> FinalizableReferenceQueue instance
   *
   * Even if no other references to classes from the application class loader remain, the Finalizer
   * thread keeps an indirect strong reference to the queue in ReferenceMap, which keeps the

                    alias("process-classes", AFTER + COMPILE),
                    alias("generate-test-sources", TEST_SOURCES),
                    alias("process-test-sources", AFTER + TEST_SOURCES),
                    alias("generate-test-resources", TEST_RESOURCES),
                    alias("process-test-resources", AFTER + TEST_RESOURCES),
                    alias("process-test-classes", AFTER + TEST_COMPILE),

    }

    private String getGradleProjectPathFor(Version version) {
        // We have Gradle projects set up to check out and build unreleased versions based on the our branching
        // conventions described in this classes javadoc
        if (version.equals(currentVersion)) {
            return ":distribution";
        }

        Map<Integer, List<Version>> releasedMajorGroupedByMinor = getReleasedMajorGroupedByMinor();

      Platform.get().log("Saving cookies failed for " + url.resolve("/...")!!, WARN, e)
    }
  }

  override fun loadForRequest(url: HttpUrl): List<Cookie> {
    val cookieHeaders =
      try {
        // The RI passes all headers. We don't have 'em, so we don't pass 'em!
        cookieHandler.get(url.toUri(), emptyMap<String, List<String>>())
      } catch (e: IOException) {

            // Act & Assert
            assertThrows(NullPointerException.class, () -> resp.readBytesWireFormat(null, 0));
        }

        @Test
        @DisplayName("Insufficient buffer causes ArrayIndexOutOfBoundsException")
        void shortBuffer_throwsAIOOBE() {
            // Arrange: length 1 means readInt2 will access index 1 and fail
            byte[] buffer = new byte[1];

   * (is a subtype of) {@code clazz}. Example:
   *
   * {@snippet :
   * List<Class<?>> classes = Arrays.asList(Object.class, String.class, Number.class, Long.class);
   * return Iterables.filter(classes, subtypeOf(Number.class));
   * }
   *
   * The code above returns an iterable containing {@code Number.class} and {@code Long.class}.
   *

            expected = NtStatus.NT_STATUS_UNSUCCESSFUL;
        }
        assertEquals(expected, ex.getNtStatus(), "Status should match mapping or fallback");
    }

    /**
     * Verify that root causes are stored and returned correctly.
     */
    @Test
    @DisplayName("Root cause propagation")
    void testRootCausePropagation() {
        Throwable root = mock(Throwable.class);

            exclude("**/build/testclusters/**/extract/**")
          }
            .files
            .findAll { Files.isRegularFile(it.toPath()) }

          if (fileSet.empty) {
            // In cases where we don't match any workspace files, exclude everything
            ant.exclude(name: "**/*")
          } else {
            fileSet.each {
              ant.include(name: projectDir.toPath().relativize(it.toPath()))

            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
            // Expected when null listener is set
        }
    }

    // Test helper classes
    private static class TestScriptEngine implements ScriptEngine {
        private String lastScript;
        private Map<String, Object> lastParams;
        private final String prefix;