// When
            Class<?>[] securityExceptions = getSecurityMethod.getExceptionTypes();
            Class<?>[] ownerExceptions = getOwnerUserMethod.getExceptionTypes();

            // Then
            assertEquals(1, securityExceptions.length, "getSecurity() should declare IOException");
            assertEquals(IOException.class, securityExceptions[0], "Should declare IOException");

                        } else {
                            return false;
                        }
                    } catch (ReflectiveOperationException | SecurityException e) {
                        return false;
                    }
                })
                .map(Method::getName)
                .toList();

        Config.prp = new Properties(prp);
        try {
            Config.prp.putAll(System.getProperties());
        } catch (final SecurityException se) {
            if (LogStream.level > 1) {
                log.println("SecurityException: jcifs.smb1 will ignore System properties");
            }
        }
    }

    /**
     * Load the <code>Config</code> with properties from the stream

     * This is a simplified test that verifies the basic flow without full NTLM protocol simulation.
     * @throws IOException
     * @throws SecurityException
     */
    @Test
    void testSuccessfulHandshake() throws IOException, SecurityException {
        // This test is simplified to verify basic handshake behavior
        // Full NTLM handshake testing would require more complex mocking

    for (String entry : Splitter.on(PATH_SEPARATOR.value()).split(JAVA_CLASS_PATH.value())) {
      try {
        try {
          urls.add(new File(entry).toURI().toURL());
        } catch (SecurityException e) { // File.toURI checks to see if the file is a directory
          urls.add(new URL("file", null, new File(entry).getAbsolutePath()));
        }
      } catch (MalformedURLException e) {

    for (String entry : Splitter.on(PATH_SEPARATOR.value()).split(JAVA_CLASS_PATH.value())) {
      try {
        try {
          urls.add(new File(entry).toURI().toURL());
        } catch (SecurityException e) { // File.toURI checks to see if the file is a directory
          urls.add(new URL("file", null, new File(entry).getAbsolutePath()));
        }
      } catch (MalformedURLException e) {

  private static final Method DELEGATE_METHOD;

  static {
    try {
      DELEGATE_METHOD = ForwardingObject.class.getDeclaredMethod("delegate");
      DELEGATE_METHOD.setAccessible(true);
    } catch (SecurityException e) {
      throw new RuntimeException(e);
    } catch (NoSuchMethodException e) {
      throw new AssertionError(e);
    }
  }

  /**

        // Verify witness service is authorized
        if (!isAuthorizedWitnessServer(witnessServer)) {
            throw new SecurityException("Unauthorized witness server: " + witnessServer);
        }
    }
    
    public void validateNotification(WitnessNotification notification) throws SecurityException {
        // Validate notification authenticity

  }

  /** Loads Finalizer.class. */
  interface FinalizerLoader {

    /**
     * Returns Finalizer.class or null if this loader shouldn't or can't load it.
     *
     * @throws SecurityException if we don't have the appropriate privileges
     */
    @Nullable Class<?> loadFinalizer();
  }

  /**
   * Tries to load Finalizer from the system class loader. If Finalizer is in the system class path,

    for (String entry : Splitter.on(PATH_SEPARATOR.value()).split(JAVA_CLASS_PATH.value())) {
      try {
        try {
          urls.add(new File(entry).toURI().toURL());
        } catch (SecurityException e) { // File.toURI checks to see if the file is a directory
          urls.add(new URL("file", null, new File(entry).getAbsolutePath()));
        }
      } catch (MalformedURLException e) {