}

    private
    fun getPluginIds(): List<String> {
        val props = Properties()
        propertiesFile.get().asFile.reader().use { input ->
            props.load(input)
        }
        return props.keys.map { it as String }.sorted()
    }

    private
    fun fetchLatestVersions(pluginIds: List<String>): List<TestedVersion> =
        pluginIds
            .map { pluginId ->

            listOf()
        }
    }

    private
    fun getToolchainInstallationPathsProperty(): List<String> {
        return toolchainInstallationPaths.map { listOf("-D$JAVA_INSTALLATIONS_PATHS_PROPERTY.integTest=$it") }.getOrElse(emptyList())
    }

    private
    fun getRepoMirrorSystemProperties(): List<String> = collectMirrorUrls().map {
        "-Dorg.gradle.integtest.mirrors.${it.key}=${it.value}"
    }

    private

            analysisFlags = mapOf(
                JvmAnalysisFlags.javaTypeEnhancementState to JavaTypeEnhancementState(
                    Jsr305Settings(ReportLevel.STRICT, ReportLevel.STRICT)
                ) { ReportLevel.STRICT },
            )
        )
    )

    put(JVMConfigurationKeys.SAM_CONVERSIONS, JvmClosureGenerationScheme.CLASS)
    put(JVMConfigurationKeys.PARAMETERS_METADATA, true)

        // Assert
        assertEquals(0, result);
    }

    @Test
    @DisplayName("toString should return formatted string with pipe name")
    void testToString() {
        // Arrange
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, testPipeName);

        // Act
        String result = transWaitNamedPipe.toString();

        // Assert
        assertNotNull(result);

    void optionsMap_notMutated_verifyNoWrites() {
        // Arrange: create a regular map first, then spy on it
        Map<String, Object> originalMap = new HashMap<>();
        originalMap.put("refreshKrb5Config", "true");

        @SuppressWarnings("unchecked")
        Map<String, Object> spyOpts = spy(originalMap);

        // Reset the spy to clear any prior invocations from setup
        reset(spyOpts);

                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                            "type": "array",
                            "title": "Location",
                        },
                        "msg": {"type": "string", "title": "Message"},
                        "type": {"type": "string", "title": "Error Type"},
                    },

}

// GetRLock tries to get a read lock on lm before the timeout occurs.
func (lm *LRWMutex) GetRLock(ctx context.Context, id string, source string, timeout time.Duration) (locked bool) {
	const isWriteLock = false
	return lm.lockLoop(ctx, id, source, timeout, isWriteLock)
}

func (lm *LRWMutex) lock(id, source string, isWriteLock bool) (locked bool) {
	lm.mu.Lock()
	defer lm.mu.Unlock()

	lm.id = id
	lm.source = source

	}

	if actualName != expectedName {
		t.Errorf("WithSingleConnection() method should get correct value, expect: %v, got %v", expectedName, actualName)
	}
}

func getSetSQL(driverName string) (string, string) {
	switch driverName {
	case mysql.Dialector{}.Name():
		return "SET @testName := ?", "SELECT @testName"
	default:
		return "", ""
	}

            return i;
        }

        /**
         * @param s
         *            the s to set
         */
        public void setS(final String s) {
            this.s = s;
        }

        /**
         * @return the s
         */
        public String getS() {
            return s;
        }
    }

    }

    /**
     *
     */
    public class TestDisposable implements Disposable {
        String name;

        /**
         * @param name
         */
        public TestDisposable(final String name) {
            this.name = name;
        }

        @Override
        public void dispose() {
            ++count;
            names += name;