texts[i] = fragments[i].string();
            }
            final String value = StringUtils.join(texts, ELLIPSIS);
            if (StringUtil.isNotBlank(value) && !ComponentUtil.getFessConfig().endsWithFullstop(value)) {
                return value + ELLIPSIS;
            }
            return value;
        }
        return null;
    }

    /**

    @Test
    public void test_getMapValue_exists() {
        final Map<String, Object> inner = Map.of("key", "value");
        final Map<String, Object> map = Map.of("nested", inner);
        final Map<String, Object> result = coordinatorHelper.getMapValue(map, "nested");
        assertNotNull(result);
        assertEquals("value", result.get("key"));
    }

    @Test
    public void test_getMapValue_notMap() {

public class AbstractFutureTest extends TestCase {
  public void testSuccess() throws ExecutionException, InterruptedException {
    Object value = new Object();
    assertThat(
            new AbstractFuture<Object>() {
              {
                set(value);
              }
            }.get())
        .isEqualTo(value);
  }

  public void testException() throws InterruptedException {
    Throwable failure = new Throwable();

    public int getPropertyDescSize() {
        return propertyDescCache.size();
    }

    @Override
    public Iterable<PropertyDesc> getPropertyDescs() {
        return unmodifiableCollection(propertyDescCache.values());
    }

    @Override
    public boolean hasFieldDesc(final String fieldName) {
        assertArgumentNotEmpty("fieldName", fieldName);

        return fieldDescCache.containsKey(fieldName);
    }

/**
 * LinkedHashMap that enforces its maximum size and logs events in a StatsCounter object and an
 * optional RemovalListener.
 *
 * @param <K> the base key type
 * @param <V> the base value type
 */
final class CapacityEnforcingMap<K, V> extends LinkedHashMap<K, Timestamped<V>> {

  private final StatsCounter statsCounter;
  private final @Nullable RemovalListener<? super K, ? super V> removalListener;

 * under the License.
 */
package org.apache.maven.api.cache;

import org.apache.maven.api.annotations.Experimental;

/**
 * Enumeration defining different retention periods for cached data.
 * Each value represents a specific scope and lifetime for cached items.
 *
 * @since 4.0.0
 */
@Experimental
public enum CacheRetention {
    /**
     * Data should be persisted across Maven invocations.
     * Suitable for:

public interface SuperPomProvider {

    /**
     * Gets the super POM for the specified model version. The returned model is supposed to be read-only, i.e. if the
     * caller intends to make updates to the model the return value must be cloned before updating to ensure the
     * modifications don't affect future retrievals of the super POM.
     *
     * @param version The model version to retrieve the super POM for (e.g. "4.0.0"), must not be {@code null}.

      # done in quick succession.
      - generic-webhook-trigger:
          post-content-params:
            - type: JSONPath
              key: ref
              value: '$.ref'
          regex-filter-text: '$ref'
          regex-filter-expression: "^refs/heads/%BRANCH%$"
          cause: Push to GitHub (refs/heads/%BRANCH%)
          silent-response: true
    scm:
      - git:

            mockedStatic.close();
        }
    }

    private static void setPrivateField(Object target, String name, Object value) throws Exception {
        Field f = target.getClass().getDeclaredField(name);
        f.setAccessible(true);
        f.set(target, value);
    }

    static ASN1ObjectIdentifier[] supportedMechs() {
        return Kerb5Context.SUPPORTED_MECHS;
    }

    @ParameterizedTest

    private static final Logger logger = LogManager.getLogger(IndexUpdateCallbackImpl.class);

    /**
     * Default constructor for index update callback implementation.
     * Creates a new instance with default values.
     */
    public IndexUpdateCallbackImpl() {
        // Default constructor
    }

    /** Atomic counter for the number of documents processed */
    protected AtomicLong documentSize = new AtomicLong(0);