}
      return result.intValue();
    }

    @Override
    public UnmodifiableIterator<C> iterator() {
      return new AbstractIterator<C>() {
        final Iterator<Range<C>> rangeItr = ranges.iterator();
        Iterator<C> elemItr = Iterators.emptyIterator();

        @Override
        @CheckForNull
        protected C computeNext() {

    }

    @Override
    public Iterator<K> iterator() {
      return keySetIterator();
    }

    @Override
    public void clear() {
      CompactHashMap.this.clear();
    }
  }

  Iterator<K> keySetIterator() {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.keySet().iterator();
    }
    return new Itr<K>() {
      @Override

    }
    try {
      Iterator<String> iterator = values.iterator();
      iterator.next();
      iterator.remove();
      fail("UnsupportedOperationException expected");
    } catch (UnsupportedOperationException expected) {
    }

    Set<Entry<Integer, String>> entries = unmod.entrySet();
    try {
      Iterator<Entry<Integer, String>> iterator = entries.iterator();
      iterator.next();

        task = new ResourceCleaningCompilationTask(task, fileManager);
        return task;
    }

    private static boolean emptySourcepathIn(List<String> options) {
        Iterator<String> optionsIter = options.iterator();
        while (optionsIter.hasNext()) {
            String current = optionsIter.next();
            if (current.equals("-sourcepath") || current.equals("--source-path")) {

The new [Preorder] function returns a convenient iterator over all the

        --inputTrackingDisabledCounterForThread
    }
}


private
operator fun <T> ThreadLocal<T>.getValue(thisRef: Any?, property: KProperty<*>) = get()


private

/**
 * Provides efficient access to a property.
 */
interface PropertyDelegate {
    operator fun <T> getValue(receiver: Any?, property: KProperty<*>): T
}


/**
 * Provides efficient access to a mutable dynamic property.
 */
interface MutablePropertyDelegate : PropertyDelegate {
    operator fun <T> setValue(receiver: Any?, property: KProperty<*>, value: T)
}


internal

                }
            });
        }
    }

    @Override
    public Iterator<Lifecycle> iterator() {
        return stream().toList().iterator();
    }

    @Override
    public Stream<Lifecycle> stream() {
        return providers.stream().map(ExtensibleEnumProvider::provides).flatMap(Collection::stream);
    }

{{- if eq .Values.cni.provider "multus" }}
apiVersion: k8s.cni.cncf.io/v1
kind: NetworkAttachmentDefinition
metadata:
  name: {{ template "name" . }}
  namespace: default
  labels:
    operator.istio.io/component: "Cni"

// limitations under the License.

package validate

import (
	"fmt"
	"os"
	"path/filepath"
	"testing"

	"sigs.k8s.io/yaml"

	"istio.io/istio/operator/pkg/helm"
	"istio.io/istio/operator/pkg/object"
	"istio.io/istio/operator/pkg/util"
	"istio.io/istio/pkg/test/env"
)

var repoRootDir string

func init() {
	repoRootDir = env.IstioSrc
}

func TestValidateValues(t *testing.T) {