/**
 * Handles inheritance of model values.
 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */
@SuppressWarnings({"checkstyle:methodname"})
@Named
@Singleton
@Deprecated(since = "4.0.0")
public class DefaultInheritanceAssembler implements InheritanceAssembler {

    private InheritanceModelMerger merger = new InheritanceModelMerger();

import static java.util.Arrays.stream;

/**
 * We want to be able to do BWC tests for unreleased versions without relying on and waiting for snapshots.
 * For this we need to check out and build the unreleased versions.
 * Since these depend on the current version, we can't name the Gradle projects statically, and don't know what the
 * unreleased versions are when Gradle projects are set up, so we use "build-unreleased-version-*" as placeholders

        assertTrue(thumbPath.toString().contains("thumbnails"));
    }

    @Test
    public void test_getSitePath() {
        Path sitePath = ResourceUtil.getSitePath("site.xml");
        assertNotNull(sitePath);
        assertTrue(sitePath.toString().contains("site"));
    }

    @Test
    public void test_getPluginPath() {
        Path pluginPath = ResourceUtil.getPluginPath("plugin.jar");
        assertNotNull(pluginPath);

        // This test verifies that the handler resolution mechanism correctly skips the 'jcifs'
        // package when it is listed in the 'java.protocol.handler.pkgs' system property.
        // We use mock handlers since actual system handlers might not be available in test environment.
        System.setProperty("java.protocol.handler.pkgs", "jcifs");
        setupMockProtocolHandlers();
        URL url = new URL("http://example.com/resource");

        // When
        request.setFileId(testFileId);

        // Then - verify through internal state (would need getter or reflection in real scenario)
        // Since we can't directly verify the internal state, we create a new request to test
        Smb2CloseRequest newRequest = new Smb2CloseRequest(mockConfig, testFileId);

        // Verify time was read correctly (accounting for UTime conversion)
        long readTime = (Long) getFieldValue(response, "lastWriteTime");
        // UTime is seconds since 1970, so we need to compare at second precision
        assertEquals(lastWriteTime / 1000, readTime / 1000);
    }

    @Test
    void testReadParameterWordsWireFormatWithZeroWordCount() {

                    .maxExpansions(fessConfig.getQueryBoostFuzzyContentExpansionsAsInteger()));
        }
        return defaultQuery;
    }

    /**
     * Converts a site field query to a prefix query for site filtering.
     *
     * @param fessConfig the Fess configuration
     * @param context the query context
     * @param termQuery the term query to convert
     * @param boost the boost value to apply

      }

      WrappedIterator(Iterator<V> delegateIterator) {
        this.delegateIterator = delegateIterator;
      }

      /**
       * If the delegate changed since the iterator was created, the iterator is no longer valid.
       */
      void validateIterator() {
        refreshIfEmpty();
        if (delegate != originalDelegate) {

 * very compact {@code Striped<Lock>} of {@code availableProcessors() * 4} stripes, instead of
 * possibly thousands of locks which could be created in a {@code Map<K, Lock>} structure.
 *
 * @author Dimitris Andreou
 * @since 13.0
 */
@J2ktIncompatible
@GwtIncompatible
public abstract class Striped<L> {
  /**
   * If there are at least this many stripes, we assume the memory usage of a ConcurrentMap will be

     *
     * @return success count
     */
    public int getSuccessCount() {
        return successCount.get();
    }

    /**
     * Get time since last state change
     *
     * @return milliseconds since last state change
     */
    public long getTimeSinceLastStateChange() {
        return System.currentTimeMillis() - lastStateChangeTime.get();
    }

    /**