verifyPropertyValue(propertyKey, filteredValue); // null checked
                return filterPropertyAsDefault(filteredValue); // not null here
            }

            private String getFromCache(final String propertyKey) {
                try {
                    return cache.get(propertyKey,

    }

    /**
     * Gets the Security Identifier.
     *
     * @return the SID associated with this instance
     */
    public SID getId() {
        return this.id;
    }

    /**
     * Gets the attribute flags associated with the SID.
     *
     * @return the attribute flags
     */
    public int getAttributes() {
        return this.attributes;
    }

        String className = getClass().getPackage().getName();

        return className.substring(className.lastIndexOf('.') + 1);
    }

    protected File projectFile(String name) {
        return projectFile("maven", name);
    }

    protected File projectFile(String groupId, String artifactId) {
        return new File(getLocalRepositoryPath(), "/" + groupId + "/poms/" + artifactId + "-1.0.pom");
    }

          || c < safeMinChar) {
        return escapeSlow(s, i);
      }
    }
    return s;
  }

  /**
   * Escapes a single Unicode code point using the replacement array and safe range values. If the
   * given character does not have an explicit replacement and lies outside the safe range then
   * {@link #escapeUnsafe} is called.
   *

        corsHandlerFactory.add("*", wildcardHandler);

        // Execute & Verify - specific origin should return specific handler
        assertEquals(specificHandler, corsHandlerFactory.get(specificOrigin));

        // Execute & Verify - unknown origin should return wildcard handler
        assertEquals(wildcardHandler, corsHandlerFactory.get("https://unknown.com"));
    }

        // Stub the getPath method to return a specific value
        when(mockDir.getPath()).thenReturn("/share/folder/");

        // Implementation uses dir.getPath() to check if file should be in that path
        SmbFilenameFilter filter = (dir, name) -> {
            if (dir == null)
                return false;
            String path = dir.getPath();

    }
  }

  private fun testUri(
    codePoint: Int,
    codePointString: String,
    encoding: UrlComponentEncodingTester.Encoding,
    component: Component,
  ) {
    if (codePoint == '%'.code) return
    val encoded = encoding.encode(codePoint)
    val httpUrl = component.urlString(encoded).toHttpUrl()
    val uri = httpUrl.toUri()
    val toAndFromUri = uri.toHttpUrlOrNull()

    /**
     * Executes and optionally caches a request using the provided supplier function. If caching is enabled
     * for this session, the result will be cached and subsequent identical requests will return the cached
     * value without re-executing the supplier.
     * <p>
     * The caching behavior is determined by the cache retention specified in the request's metadata.

    private static SamrPolicyHandle createMockPolicyHandle() {
        return mock(SamrPolicyHandle.class);
    }

    @Nested
    @DisplayName("Constructor parameter handling")
    class ConstructorParameterHandling {

        static Stream<Arguments> provideParameters() {
            return Stream.of(Arguments.of("\\\\example\\\\server", 0x000F0000), Arguments.of(null, 0), Arguments.of("\\\\localhost", -1),

  }

  @Override
  public boolean tryLock() {
    return delegate().tryLock();
  }

  @Override
  public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    return delegate().tryLock(time, unit);
  }

  @Override
  public void unlock() {
    delegate().unlock();
  }

  @Override
  public Condition newCondition() {
    return delegate().newCondition();
  }