new SetMultimapTestSuiteBuilder.MultimapAsMapGetGenerator<K, V>(
                  parentBuilder.getSubjectGenerator()))
          .withFeatures(features)
          .named(parentBuilder.getName() + ".asMap[].get[key]")
          .suppressing(parentBuilder.getSuppressedTests())
          .createTestSuite();
    }
  }

        sourceClassesMapping.put('YourClass.groovy', 'org.gradle.YourClass')
        sourceClassesMapping.put('YourOtherClass.groovy', 'org.gradle.YourClass')

        converter = new DefaultSourceFileClassNameConverter(Multimaps.asMap(sourceClassesMapping))
    }

    def 'can get class names by file'() {
        expect:
        converter.getClassNames(file) == classes

        where:
        file                | classes

              new SetMultimapTestSuiteBuilder.MultimapAsMapGetGenerator<K, V>(
                  parentBuilder.getSubjectGenerator()))
          .withFeatures(features)
          .named(parentBuilder.getName() + ".asMap[].get[key]")
          .suppressing(parentBuilder.getSuppressedTests())
          .createTestSuite();
    }
  }

}

// ValidateIOPCAConfig validates if the IstioOperator CA configs are applicable to the K8s cluster
func ValidateIOPCAConfig(client kube.Client, iop *iopv1alpha1.IstioOperator) error {
	globalI := iop.Spec.Values.AsMap()["global"]
	global, ok := globalI.(map[string]any)
	if !ok {
		// This means no explicit global configuration. Still okay
		return nil
	}
	ca, ok := global["pilotCertProvider"].(string)
	if !ok {

    }

    @Override
    public String get(String namespace, String name) {
        return extraInfo.get(new NamespaceId(namespace, name));
    }

    @Override
    public Map<QName, String> asMap() {
        Map<QName, String> map = new LinkedHashMap<>();
        for (Map.Entry<NamespaceId, String> entry : extraInfo.entrySet()) {

        + ", nodes: "
        + nodes()
        + ", edges: "
        + edgeValueMap(this);
  }

  private static <N, V> Map<EndpointPair<N>, V> edgeValueMap(final ValueGraph<N, V> graph) {
    return Maps.asMap(
        graph.edges(),
        edge ->
            // requireNonNull is safe because the endpoint pair comes from the graph.
            requireNonNull(graph.edgeValueOrDefault(edge.nodeU(), edge.nodeV(), null)));
  }

    }

    private void optimizeScopes(Multimap<Object, GeneratedIdeaScope> scopesByDependencyKey) {
        for (Map.Entry<Object, Collection<GeneratedIdeaScope>> entry : scopesByDependencyKey.asMap().entrySet()) {
            optimizeScopes(entry.getValue());
        }
    }

    private void applyScopesToDependencies(Collection<Dependency> deps, Multimap<Object, GeneratedIdeaScope> scopesByDependencyKey) {

    new EqualsTester()
        .addEqualityGroup(multimap())
        .addEqualityGroup(getSubjectGenerator().create())
        .testEquals();
  }

  public void testHashCodeMatchesAsMap() {
    assertEquals(multimap().asMap().hashCode(), multimap().hashCode());
  }

            encoder.writeSmallInt(outputPropertyHashes.keySet().size());
            for (Map.Entry<String, Collection<HashCode>> entry : outputPropertyHashes.asMap().entrySet()) {
                encoder.writeString(entry.getKey());
                Collection<HashCode> hashes = entry.getValue();
                encoder.writeSmallInt(hashes.size());

    } else {
      return SetTestSuiteBuilder.using(
              new MultimapAsMapGetGenerator<K, V>(parentBuilder.getSubjectGenerator()))
          .withFeatures(features)
          .named(parentBuilder.getName() + ".asMap[].get[key]")
          .suppressing(parentBuilder.getSuppressedTests())
          .createTestSuite();
    }
  }

  @Override
  TestSuite computeEntriesTestSuite(
      FeatureSpecificTestSuiteBuilder<