val server = field.get(null) as? MockWebServer ?: continue

      // Put the instance in the store, so JUnit closes it for us in afterAll.
      store.put(field, server)

      server.start()
    }
  }

  override fun beforeEach(context: ExtensionContext) {
    val testInstance = context.testInstance.get()
    val store = context.getStore(Namespace.create(StartStop::class.java))

    val instanceFields =

     * @param comments
     *            Comments.
     */
    public static void store(final Properties props, final OutputStream out, final String comments) {
        assertArgumentNotNull("props", props);
        assertArgumentNotNull("out", out);

        try {
            props.store(out, comments);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }

// where X, Y, Z are all the stages including current stage
// For example, for the stage PullRequestFeedback, the custom value will be "PartOf=PullRequestFeedback,ReadyForNightly,ReadyForRelease"
private fun Stage.getBuildScanCustomValues(): List<String> =
    StageName
        .values()
        .slice(this.stageName.ordinal until StageName.READY_FOR_RELEASE.ordinal + 1)
        .map { it.uuid }

	if stmt.Stmt != nil {
		return stmt.Stmt.Close()
	}
	return nil
}

// Store defines an interface for managing the caching operations of SQL statements (Stmt).
// This interface provides methods for creating new statements, retrieving all cache keys,
// getting cached statements, setting cached statements, and deleting cached statements.
type Store interface {
	// New creates a new Stmt object and caches it.
	// Parameters:

    model: CIBuildModel,
    performanceTestBucketProvider: PerformanceTestBucketProvider,
    stage: Stage,
    performanceTestCoverage: PerformanceTestCoverage,
) : PerformanceTestProject(
        model,
        performanceTestCoverage,
        performanceTestBucketProvider.createPerformanceTestsFor(stage, performanceTestCoverage),
    )

class ManuallySplitPerformanceTestProject(
    model: CIBuildModel,

     *
     * @param failureUrl the FailureUrl entity to store or update
     */
    public void store(final FailureUrl failureUrl) {

        failureUrlBhv.insertOrUpdate(failureUrl, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**
     * Deletes a failure URL entity from the data store.
     *

 */
public interface DataStore {

    /**
     * Store the data.
     * @param config The data configuration.
     * @param callback The callback.
     * @param initParamMap The initial parameters.
     */
    void store(DataConfig config, IndexUpdateCallback callback, DataStoreParams initParamMap);

    /**
     * Stop the data store.
     */
    void stop();

        }

    }

    /**
     * Inner thread class for executing data store crawling operations.
     * Each thread handles crawling for a single data configuration,
     * processing documents and updating the search index.
     *
     * <p>The thread manages:</p>
     * <ul>
     *   <li>Data store initialization and document processing</li>
     *   <li>Index update operations through callbacks</li>

- Kubernetes cluster with `kubectl` configured.

- Acquire TLS certificates, either from a CA or [create self-signed certificates](https://docs.min.io/community/minio-object-store/operations/network-encryption.html).

        // Add some info to map
        crawlingInfoHelper.putToInfoMap("url_count", "100");
        crawlingInfoHelper.putToInfoMap("error_count", "5");

        // Store with create=true
        crawlingInfoHelper.store(sessionId, true);

        // Verify infoMap is cleared
        assertNull(crawlingInfoHelper.infoMap);
    }

    public void test_store_existing() {