import org.gradle.kotlin.dsl.accessors.AccessorsClassPath
import org.gradle.kotlin.dsl.provider.ClassPathModeExceptionCollector
import org.gradle.kotlin.dsl.provider.KotlinScriptClassPathProvider
import org.gradle.kotlin.dsl.provider.runCatching
import org.gradle.kotlin.dsl.resolver.SourceDistributionResolver
import org.gradle.kotlin.dsl.resolver.SourcePathProvider
import org.gradle.kotlin.dsl.support.ImplicitImports
import org.gradle.kotlin.dsl.support.filter

    fun collect(error: Exception) {
        collection.add(error)
    }

    override fun stop() {
        collection.clear()
    }
}


inline fun <T> ClassPathModeExceptionCollector.runCatching(f: () -> T): T? =
    try {
        f()
    } catch (e: Exception) {
        collect(e)
        null

    private
    fun awaitExceptionFrom(scope: IOScope) =
        await atMost ONE_SECOND untilNotNull { exceptionOrNullFrom { scope.io { } } }

    private
    fun exceptionOrNullFrom(action: () -> Unit) = runCatching(action).exceptionOrNull()

    private
    fun withAsyncIOScopeFactory(
        settings: AsyncIOScopeSettings = JavaSystemPropertiesAsyncIOScopeSettings(),
        action: DefaultAsyncIOScopeFactory.() -> Unit

            val regularPointer = ktSymbol.runCatching {
                createPointerForTest(disablePsiBasedSymbols = false)
            }.let {
                if (directiveToIgnoreSymbolRestore == null) it.getOrThrow() else it.getOrNull()
            } ?: return null

            assertSymbolPointer(regularPointer, testServices)
            val nonPsiPointer = ktSymbol.runCatching {

        val accessorsClassPath =
            classPathModeExceptionCollector.runCatching {
                accessorsClassPath(scriptClassPath)
            } ?: AccessorsClassPath.empty

        val additionalImports =
            classPathModeExceptionCollector.runCatching {
                additionalImports()
            } ?: emptyList()

            }
            process(group)
        }
    }

    private
    fun process(group: List<AsyncModelRequest>) {
        val (mostRecentRequest, k) = group.first()
        val result = runCatching { fetch(mostRecentRequest) }
        resumeAll(supersededRequestsFrom(group), Result.success(null))
        resume(k, result)
    }

    private

            )
        }
    }

    private
    inline fun withOptions(options: EvalOptions, action: () -> Unit) {
        if (EvalOption.IgnoreErrors in options)
            classPathModeExceptionCollector.runCatching(action)
        else
            action()
    }

    private
    fun setupEmbeddedKotlinForBuildscript(scriptHandler: ScriptHandler) {
        embeddedKotlinProvider.pinEmbeddedKotlinDependenciesOn(

            action: DynamicObject.() -> DynamicInvokeResult,
            resultNotFoundExceptionProvider: DynamicObject.() -> GroovyRuntimeException
        ): Any? {
            val result = runCatching {
                withDelegateDynamicCallIgnoringProblem(action, resultNotFoundExceptionProvider)
            }

            val memberKind = "extension"
            return when {

		{
			inDesc: "success both are int32 types",
			inV1:   int32(42),
			inV2:   int32(43),
			want:   true,
		},
		{
			inDesc: "fail unmatching int types",
			inV1:   int16(42),
			inV2:   int32(43),
			want:   false,
		},
		{
			inDesc: "fail unmatching int and string type",
			inV1:   int32(42),
			inV2:   "42",
			want:   false,
		},
		{
			inDesc: "fail EnumType and int64 types",

// the pattern is not found, it returns -1.
func (f *stringFinder) next(text string) int {
	i := len(f.pattern) - 1
	for i < len(text) {
		// Compare backwards from the end until the first unmatching character.
		j := len(f.pattern) - 1
		for j >= 0 && text[i] == f.pattern[j] {
			i--
			j--
		}
		if j < 0 {
			return i + 1 // match
		}
		i += max(f.badCharSkip[text[i]], f.goodSuffixSkip[j])