}

    /**
     * Determines whether a type represented by a class object is
     * convertible to another type represented by a class object using a
     * method invocation conversion, without matching object and primitive
     * types. This method is used to determine the more specific type when
     * comparing signatures of methods.
     *
     * @param formal the formal parameter type to which the actual

        this.preloadSizeForCharset = preloadSizeForCharset;
    }

    /**
     * Gets the pattern for matching invalid URLs.
     *
     * @return the invalid URL pattern
     */
    public Pattern getInvalidUrlPattern() {
        return invalidUrlPattern;
    }

    /**
     * Sets the pattern for matching invalid URLs.
     *
     * @param invalidUrlPattern the invalid URL pattern to set
     */

    /**
     * Retrieves a paginated list of elevate words based on the provided pager criteria.
     *
     * @param elevateWordPager the pager containing pagination and filtering criteria
     * @return list of elevate words matching the criteria
     */
    public List<ElevateWord> getElevateWordList(final ElevateWordPager elevateWordPager) {

        final PagingResultBean<ElevateWord> elevateWordList = elevateWordBhv.selectPage(cb -> {

            }
        }
        assertThrows(ClassCastException.class, () -> transport.unwrap(OtherTransport.class));
    }

    @Test
    @DisplayName("getSmbSession creates and then reuses matching session")
    void getSmbSession_createAndReuse() {
        // Arrange: minimal credentials chain so SmbSessionImpl constructor succeeds
        CredentialsInternal creds = mock(CredentialsInternal.class);

            <li>{@code exists(path)}: Checks if a file matching the given glob pattern exists.</li>
            <li>{@code missing(path)}: Checks if a file matching the given glob pattern does not exist.</li>
            <li>{@code inrange(version, range)}: Checks if the given version is within the specified version range.</li>

        for (int i = 0; i < 1000; i++) {
            urlFilter.addInclude("https://site" + i + ".com/.*");
            urlFilter.addExclude(".*\\.exclude" + i + "$");
        }

        // Test matching performance
        assertTrue(urlFilter.match("https://site500.com/page"));
        assertFalse(urlFilter.match("https://site500.com/file.exclude500"));
        assertFalse(urlFilter.match("https://unknown.com/page"));

    /** Cache key for cache message */
    protected static final String CACHE_MSG = "cache_msg";

    /** Pattern for matching local file paths */
    protected static final Pattern LOCAL_PATH_PATTERN = Pattern.compile("^file:/+[a-zA-Z]:");

    /** Pattern for matching shared folder paths */
    protected static final Pattern SHARED_FOLDER_PATTERN = Pattern.compile("^file:/+[^/]\\.");

            ?: throw ProtocolException("expected a value at $reader")

        val choice =
          choices.firstOrNull { it.matches(peekedHeader) }
            ?: throw ProtocolException(
              "expected a matching choice but was $peekedHeader at $reader",
            )

        return choice to choice.fromDer(reader)
      }

      override fun toDer(
        writer: DerWriter,

val Project.testJavaVendor: Provider<JvmVendorSpec>
    get() = propertyFromAnySource(TEST_JAVA_VENDOR).map { vendorName -> VENDOR_MAPPING.getOrElse(vendorName) { -> JvmVendorSpec.matching(vendorName) } }


val Project.testJavaVersion: String
    get() = propertyFromAnySource(TEST_JAVA_VERSION).getOrElse(JavaVersion.current().majorVersion)


val Project.testSplitIncludeTestClasses: String

	Filter       func(info FileInfo) bool // return WalkFilter returns 'true/false'
	Marker       string                   // set to skip until this object
	LatestOnly   bool                     // returns only latest versions for all matching objects
	AskDisks     string                   // dictates how many disks are being listed
	VersionsSort WalkVersionsSortOrder    // sort order for versions of the same object; default: Ascending order in ModTime