var ErrNotImplemented = errors.New("not implemented")

func (r *RealDependencies) execute(cmd string, ignoreErrors bool, stdin io.Reader, args ...string) error {
	return ErrNotImplemented
}

func (r *RealDependencies) executeXTables(cmd constants.IptablesCmd, iptVer *IptablesVersion, ignoreErrors bool, stdin io.ReadSeeker, args ...string) error {
	return ErrNotImplemented
}

// them after visiting as a slice of errors. If no errors remain after
// filtering, the various visitor methods on Result will return nil for
// err.
func (r *Result) IgnoreErrors(fns ...ErrMatchFunc) *Result {
	for _, fn := range fns {
		r.ignoreErrors = append(r.ignoreErrors, utilerrors.Matcher(fn))
	}
	return r
}

// Mapper returns a copy of the builder's mapper.
func (r *Result) Mapper() *mapper {
	return r.mapper
}

			o.LogOptions.Path = auditPath
			o.PolicyFile = policy
			return o
		},
		expected: "ignoreErrors<log>",
	}, {
		name: "stdout log",
		options: func() *AuditOptions {
			o := NewAuditOptions()
			o.LogOptions.Path = "-"
			o.PolicyFile = policy
			return o
		},
		expected: "ignoreErrors<log>",
	}, {
		name: "create audit log path dir",
		options: func() *AuditOptions {
			o := NewAuditOptions()

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.kotlin.dsl.execution

import java.util.*


enum class EvalOption {
    IgnoreErrors,
    SkipBody
}


typealias EvalOptions = EnumSet<EvalOption>


internal
val defaultEvalOptions: EvalOptions =

    fun kotlinScriptOptions(): EnumSet<EvalOption> =
        if (inLenientMode()) lenientModeScriptOptions
        else defaultEvalOptions
}


private

	ignoreErrors := sets.New[string]()
	allErrs := field.ErrorList{}

	for _, item := range ignorePreflightErrorsFromConfigFile {
		ignoreErrors.Insert(strings.ToLower(item)) // parameters are case insensitive
	}

	for _, item := range ignorePreflightErrorsFromCLI {
		ignoreErrors.Insert(strings.ToLower(item)) // parameters are case insensitive
	}

}

func mount(src, dst string) error {
	return syscall.Mount(src, dst, "", syscall.MS_BIND|syscall.MS_RDONLY, "")
}

func (r *RealDependencies) executeXTables(cmd constants.IptablesCmd, iptVer *IptablesVersion, ignoreErrors bool, stdin io.ReadSeeker, args ...string) error {
	mode := "without lock"
	cmdBin := iptVer.CmdToString(cmd)
	if cmdBin == "" {
		return fmt.Errorf("called without iptables binary, cannot execute!: %+v", iptVer)
	}

                topLevelScript,
                options
            )
        }
    }

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

    private
    fun setupEmbeddedKotlinForBuildscript(scriptHandler: ScriptHandler) {

        scriptSource = scriptSource,
        scriptHandler = scriptHandler,
        targetScope = scriptScope,
        baseScope = baseScope,
        topLevelScript = false,
        options = EnumSet.of(EvalOption.IgnoreErrors, EvalOption.SkipBody)
    )

    return scriptHandler to project.compilationClassPathOf(scriptScope)
}


private
fun kotlinScriptFactoryOf(project: ProjectInternal) =

}

func (i *ignoreErrorsBackend) ProcessEvents(ev ...*auditinternal.Event) bool {
	i.Backend.ProcessEvents(ev...)
	return true
}

func (i *ignoreErrorsBackend) String() string {
	return fmt.Sprintf("ignoreErrors<%s>", i.Backend)
}

func (o *AuditBatchOptions) wrapBackend(delegate audit.Backend) audit.Backend {
	if o.Mode == ModeBlockingStrict {
		return delegate
	}
	if o.Mode == ModeBlocking {