OutputPaths:         []string{defaultOutputPath},
			ErrorOutputPaths:    []string{defaultErrorOutputPath},
			defaultOutputLevels: "default:info,grpc:none",
			stackTraceLevels:    levelToString[NoneLevel],
			RotationMaxAge:      defaultRotationMaxAge,
			RotationMaxSize:     defaultRotationMaxSize,
			RotationMaxBackups:  defaultRotationMaxBackups,
		}},

		{"--log_stacktrace_level default:none", Options{

        }
        s.addField("inputPaths", inputPathsArray);

        NSArray outputPathsArray = new NSArray(outputPaths.size());
        for (int i = 0; i < outputPaths.size(); i++) {
            outputPathsArray.setValue(i, new NSString(outputPaths.get(i)));
        }
        s.addField("outputPaths", outputPathsArray);

        NSString shellPathString;
        if (shellPath == null) {

}

// Options defines the set of options supported by Istio's component logging package.
type Options struct {
	// OutputPaths is a list of file system paths to write the log data to.
	// The special values stdout and stderr can be used to output to the
	// standard I/O streams. This defaults to stdout.
	OutputPaths []string

	// ErrorOutputPaths is a list of file system paths to write logger errors to.

 */

package org.gradle.execution.plan;

import java.util.HashSet;
import java.util.Set;

class MutationInfo {
    private final Set<Node> nodesYetToConsumeOutput = new HashSet<>();
    final Set<String> outputPaths = new HashSet<>();
    final Set<String> destroyablePaths = new HashSet<>();
    boolean hasFileInputs;
    boolean hasOutputs;
    boolean hasLocalState;
    boolean hasValidationProblem;

	}

	o = DefaultOptions()
	o.logCallers = "foobar"
	err = Configure(o)
	if err != nil {
		t.Error("Got success, expected failure")
	}

	o = DefaultOptions()
	// using invalid filename
	o.OutputPaths = []string{"//"}
	err = Configure(o)
	if err == nil {
		t.Errorf("Got success, expecting error")
	}

	o = DefaultOptions()
	o.ErrorOutputPaths = []string{"//"}
	err = Configure(o)
	if err == nil {

            mutations.outputPaths.add(outputLocation.getAbsolutePath());
            mutations.hasOutputs = true;
        });
    }

    private void addLocalStateFilesToMutations(FileCollection localStateFiles) {
        final MutationInfo mutations = getMutationInfo();
        localStateFiles.forEach(file -> {
            mutations.outputPaths.add(file.getAbsolutePath());

        node.resolveMutations();
        mutations.hasValidationProblem = nodeValidator.hasValidationProblems(node);
        accessHierarchies.getOutputHierarchy().recordNodeAccessingLocations(node, mutations.outputPaths);
        accessHierarchies.getDestroyableHierarchy().recordNodeAccessingLocations(node, mutations.destroyablePaths);
    }

	errSink, closeErrorSink, err := zap.Open(options.ErrorOutputPaths...)
	if err != nil {
		return nil, nil, nil, err
	}

	var outputSink zapcore.WriteSyncer
	if len(options.OutputPaths) > 0 {
		outputSink, _, err = zap.Open(options.OutputPaths...)
		if err != nil {
			closeErrorSink()
			return nil, nil, nil, err
		}
	}

	var sink zapcore.WriteSyncer
	if rotaterSink != nil && outputSink != nil {

        this.inputHierarchy = inputHierarchy;
    }

    public void detectMissingDependencies(LocalTaskNode node, TypeValidationContext validationContext) {
        for (String outputPath : node.getMutationInfo().outputPaths) {
            inputHierarchy.getNodesAccessing(outputPath).stream()
                .filter(consumerNode -> hasNoSpecifiedOrder(node, consumerNode))
                .filter(MissingTaskDependencyDetector::isEnabled)

		}
	}
	// End previous result parsing

	return &conf, nil
}

func GetLoggingOptions(cfg *Config) *log.Options {
	loggingOptions := log.DefaultOptions()
	loggingOptions.OutputPaths = []string{"stderr"}
	loggingOptions.JSONEncoding = true
	if cfg != nil {
		// Tee all logs to UDS. Stdout will go to kubelet (hard to access, UDS will be read by the CNI DaemonSet and exposed
		// by normal `kubectl logs`