assertEquals("Deleted 0 thumbnail files.", result);
        assertEquals(30L * 24 * 60 * 60 * 1000L, thumbnailManager.getPurgeExpiry());
    }

    // Test execute with successful purge (single file deleted)
    @Test
    public void test_execute_singleFileDeleted() {
        thumbnailManager.setPurgeCallCount(1);

        String result = purgeThumbnailJob.execute();

    }

    @Test
    public void test_search_withSimpleQuery() {
        final String query = "singleKeyword";
        final IntentDetectionResult result = IntentDetectionResult.search(query, "single keyword search");

        assertEquals(ChatIntent.SEARCH, result.getIntent());
        assertEquals("singleKeyword", result.getQuery());
    }

    @Test
    public void test_search_withFessQuery() {

     *            name associated with SIDs will be required, the SID_FLAG_RESOLVE_SIDS
     *            flag should be used which causes all group member SIDs to be resolved
     *            together in a single more efficient operation.
     * @return a map of group SID to member SIDs
     * @throws CIFSException if there is an error retrieving local groups
     */

	// err will only be returned after decoded has been closed.
	err          *error
	readCloser   io.ReadCloser
	onReaderExit func()

	exitReader chan struct{}
	readerWg   sync.WaitGroup
}

// Read - reads single record.
func (r *Reader) Read(dst sql.Record) (sql.Record, error) {
	v, ok := <-r.decoded
	if !ok {
		if r.err != nil && *r.err != nil {
			return nil, errJSONParsingError(*r.err)
		}
		return nil, io.EOF
	}

    return incorporateRequirements(clonedClassRequirements, declaredRequirements, testerMethod);
  }

  /**
   * Find all the constraints explicitly or implicitly specified by a single tester annotation.
   *
   * @param testerAnnotation a tester annotation
   * @return the requirements specified by the annotation
   * @throws ConflictingRequirementsException if the requirements are mutually inconsistent.

   * if necessary. The returned map contains entries that were already cached, combined with newly
   * loaded entries; it will never contain null keys or values.
   *
   * <p>Caches loaded by a {@link CacheLoader} will issue a single request to {@link
   * CacheLoader#loadAll} for all keys which are not already present in the cache. All entries
   * returned by {@link CacheLoader#loadAll} will be stored in the cache, over-writing any

        final String clusterName = UUID.randomUUID().toString();
        runner.onBuild((number, settingsBuilder) -> {
            settingsBuilder.put("http.cors.enabled", true);
            settingsBuilder.put("discovery.type", "single-node");
        }).build(newConfigs().clusterName(clusterName).numOfNode(1));

        // wait for yellow status
        runner.ensureYellow();

        assertNotNull(param.getValues());
        assertEquals(0, param.getValues().length);
    }

    @Test
    public void test_constructor_withSingleValue() {
        // Test with single value
        String name = "singleParam";
        String[] values = { "onlyValue" };
        RequestParameter param = new RequestParameter(name, values);

        assertEquals(name, param.getName());

    }

    // Test execute with empty list
    @Test
    public void test_execute_emptyList() {
        String result = scoreUpdater.execute();
        assertEquals("", result);
    }

    // Test execute with single booster
    @Test
    public void test_execute_singleBooster() {
        TestScoreBooster booster = new TestScoreBooster(100L);
        scoreUpdater.addScoreBooster(booster);

package okhttp3

import kotlin.reflect.KClass
import okio.IOException
import okio.Timeout

/**
 * A call is a request that has been prepared for execution. A call can be canceled. As this object
 * represents a single request/response pair (stream), it cannot be executed twice.
 */
interface Call : Cloneable {
  /** Returns the original request that initiated this call. */
  fun request(): Request

  /**