default:
                return new CompositeFileSystemSnapshot(snapshots);
        }
    }

    @Override
    public Stream<FileSystemLocationSnapshot> roots() {
        return snapshots.stream()
            .flatMap(FileSystemSnapshot::roots);
    }

    @Override
    public SnapshotVisitResult accept(FileSystemSnapshotHierarchyVisitor visitor) {
        for (FileSystemSnapshot snapshot : snapshots) {

  private lateinit var rootCa: HeldCertificate
  private lateinit var certificate: HeldCertificate
  private val dns = FakeDns()
  private lateinit var url: HttpUrl
  private lateinit var serverIps: List<InetAddress>

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
    platform.assumeHttp2Support()
    platform.assumeNotBouncyCastle()
    rootCa =
      HeldCertificate.Builder()

			certMap: map[string][]string{"foo.domain.com": {validRootCert}},
		},
		{
			name:    "Successful validation with multiple roots",
			certMap: map[string][]string{"foo.domain.com": {validRootCert, validRootCert2}},
		},
		{
			name: "Successful validation with multiple roots multiple mappings",
			certMap: map[string][]string{
				"foo.domain.com": {validRootCert, validRootCert2},
				"bar.domain.com": {validRootCert2},

const (
	FlagCharts = "charts"
)

// ConfigAndEnvProcessing uses spf13/viper for overriding CLI parameters
func ConfigAndEnvProcessing() error {
	configPath := filepath.Dir(root.IstioConfig)
	baseName := filepath.Base(root.IstioConfig)
	configType := filepath.Ext(root.IstioConfig)
	configName := baseName[0 : len(baseName)-len(configType)]
	if configType != "" {
		configType = configType[1:]
	}

// limitations under the License.

package main

import (
	"flag"

	"github.com/spf13/cobra"

	"istio.io/istio/pkg/collateral"
	"istio.io/istio/pkg/version"
)

// getRootCmd returns the root of the cobra command-tree.
func getRootCmd(args []string) *cobra.Command {
	rootCmd := &cobra.Command{
		Use:   "operator",
		Short: "The Istio operator.",
		Args:  cobra.ExactArgs(0),

}

func addFlags(cmd *cobra.Command, rootArgs *RootArgs) {
	cmd.PersistentFlags().BoolVarP(&rootArgs.DryRun, "dry-run", "",
		false, "Console/log output only, make no changes.")
}

// GetRootCmd returns the root of the cobra command-tree.
func GetRootCmd(ctx cli.Context, args []string) *cobra.Command {
	rootCmd := &cobra.Command{
		Use:          "mesh",
		Short:        "Command line Istio install utility.",
		SilenceUsage: true,

        if (cacheableWork.shouldInvalidateOutputsBeforeLoad()) {
            ImmutableList.Builder<String> roots = ImmutableList.builder();
            cacheableWork.visitOutputTrees((name, type, root) -> roots.add(root.getAbsolutePath()));
            fileSystemAccess.invalidate(roots.build());
        }
        return buildCache.load(cacheKey, cacheableWork);
    }

                roots == []
            }
            with(inputFileProperties.inputArtifact) {
                hash != null
                attributes == ['DIRECTORY_SENSITIVITY_DEFAULT', 'FINGERPRINTING_STRATEGY_ABSOLUTE_PATH', 'LINE_ENDING_SENSITIVITY_DEFAULT']
                with(Iterables.getOnlyElement(roots)) {
                    hash != null

        protected static class Property {

            private final String hash;
            private final Set<String> attributes;
            private final List<Entry> roots = new ArrayList<>();

            public Property(String hash, Set<String> attributes) {
                this.hash = hash;
                this.attributes = attributes;
            }

        when:
        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "has default roots"() {
        given:
        def supplier = new LinuxInstallationSupplier()

        expect:
        supplier.roots.length > 1
    }

    def "supplies no installations for non-existing directory"() {
        given: