* this map with the more specific generic type {@code Map<K, Set<V>>}, call {@link
   * Multimaps#asMap(SetMultimap)} instead.
   */
  @Override
  Map<K, Collection<V>> asMap();

  /**
   * Compares the specified object to this multimap for equality.
   *

    assertEqualIgnoringOrder(values, multimap().get(key));

    if (!values.isEmpty()) {
      assertEqualIgnoringOrder(values, multimap().asMap().get(key));
      assertFalse(multimap().isEmpty());
    } else {
      assertNull(multimap().asMap().get(key));
    }

    assertEquals(values.size(), multimap().get(key).size());

    assertEquals(values.size() > 0, multimap().containsKey(key));

                this.data = [:]
            } else {
                def d = data.findAll { k, v -> v != null }
                // GeneralData already contains asMap property; it is removed for clarity
                if (d['asMap'] instanceof Map) {
                    this.data = d['asMap'] as Map<String, Object>
                } else {
                    this.data = d
                }
            }
        }

  }

  private static <N, E> NetworkConnections<N, E> connectionsOf(Network<N, E> network, N node) {
    if (network.isDirected()) {
      Map<E, N> inEdgeMap = Maps.asMap(network.inEdges(node), sourceNodeFn(network));
      Map<E, N> outEdgeMap = Maps.asMap(network.outEdges(node), targetNodeFn(network));
      int selfLoopCount = network.edgesConnecting(node, node).size();
      return network.allowsParallelEdges()

   * interface.
   *
   * @since 14.0 (present with return type {@code SortedMap} since 2.0)
   */
  @Override
  public NavigableMap<K, Collection<V>> asMap() {
    return (NavigableMap<K, Collection<V>>) super.asMap();
  }

  /**
   * @serialData key comparator, value comparator, number of distinct keys, and then for each
   *     distinct key: the key, number of values for that key, and key values

  }

  private static <N, E> NetworkConnections<N, E> connectionsOf(Network<N, E> network, N node) {
    if (network.isDirected()) {
      Map<E, N> inEdgeMap = Maps.asMap(network.inEdges(node), sourceNodeFn(network));
      Map<E, N> outEdgeMap = Maps.asMap(network.outEdges(node), targetNodeFn(network));
      int selfLoopCount = network.edgesConnecting(node, node).size();
      return network.allowsParallelEdges()

        nonZeroKeys.add(key);
      }
    }
    assertEquals(ITERATIONS, map.size());
    assertTrue(map.asMap().containsValue(0L));

    map.removeAllZeros();
    assertFalse(map.asMap().containsValue(0L));
    assertEquals(ITERATIONS / 2, map.size());
    assertEquals(nonZeroKeys, map.asMap().keySet());
  }

  public void testClear() {
    AtomicLongMap<Object> map = AtomicLongMap.create();

        }
        if (problem.additionalData?.asMap.size() == 1) {
            println "    additionalData.asMap == [ '${problem.additionalData.asMap.keySet().iterator().next()}' : '${problem.additionalData.asMap.values().iterator().next()}' ]"
        } else if (problem.additionalData?.asMap.size() > 1) {
            println "    additionalData.asMap == ["
            problem.additionalData.asMap.each { key, value ->

            contextualLabel == 'Cannot locate tasks that match \':a:javadocJar\' as task \'javadocJar\' not found in project \':a\'. Some candidates are: \'javadoc\'.'
            additionalData.asMap == [ 'requestedPath' : ':a:javadocJar']
        }

        when:
        buildFile << '''
            subprojects {
                java { withJavadocJar() }
            }
        '''
        then:

func Namespace(iops *v1alpha1.IstioOperatorSpec) string {
	if iops.Namespace != "" {
		return iops.Namespace
	}
	if iops.Values == nil {
		return ""
	}
	v := iops.Values.AsMap()
	if v[globalKey] == nil {
		return ""
	}
	vg := v[globalKey].(map[string]any)
	n := vg[istioNamespaceKey]
	if n == nil {
		return ""
	}
	return n.(string)
}