}

    public String toString() {
        String ret = proto + ":" + server + "[" + endpoint;
        if (options != null) {
            Iterator iter = options.keySet().iterator();
            while (iter.hasNext()) {
                Object key = iter.next();
                Object val = options.get(key);
                ret += "," + key + "=" + val;
            }
        }
        ret += "]";
        return ret;

name: Test
number: 1234
items:
    - name: item1
      description: first item
    - name: item2

		if e := v.Index(a.iter.index); e.IsValid() {
			x = e.Interface().(ast.Node)
		}

		a.iter.step = 1
		a.apply(parent, name, &a.iter, x)
		a.iter.index += a.iter.step
	}
	a.iter = saved

        // corresponding indices in the pass_ids vector.
        auto iter = pass_names.begin();
        while ((iter = std::find(iter, pass_names.end(), pass->name())) !=
               pass_names.end()) {
          pass_ids[std::distance(pass_names.begin(), iter)] = pass.get();
          iter++;
        }
      }
    }
  }
  return pass_ids;
}

		procs := uint32(0)
		iters := uint64(0)
		b.SetParallelism(3)
		b.RunParallel(func(pb *testing.PB) {
			atomic.AddUint32(&procs, 1)
			for pb.Next() {
				atomic.AddUint64(&iters, 1)
			}
		})
		if want := uint32(3 * runtime.GOMAXPROCS(0)); procs != want {
			t.Errorf("got %v procs, want %v", procs, want)
		}
		if iters != uint64(b.N) {
			t.Errorf("got %v iters, want %v", iters, b.N)
		}
	})
}

            len = name.length();
            if ( len > maxLen ) {
                maxLen = len;
            }

            iter = sorted.listIterator();
            for ( j = 0; iter.hasNext(); j++ ) {
                if ( sort == 0 ) {
                    if ( compareNames(dirents[ i ], name, iter.next()) < 0 ) {
                        break;
                    }
                }
                else if ( sort == 1 ) {

	const N = 13 << 4 // 6.5 * 2 * 2^k
	for i := 0; i < N; i++ {
		m[math.NaN()] = i
	}
	// Trigger growth.
	m[math.NaN()] = N

	// Iterate through map.
	i := 0
	v := reflect.ValueOf(m)
	iter := v.MapRange()
	for iter.Next() {
		if i == 6 {
			// Partway through iteration, clear the map.
			v.Clear()
		} else if i > 6 {
			// If we advance to the next iteration, that's a bug.
			panic("BAD")
		}
		i++
	}

  module_op.walk([&py_function_library, &calibration_options, &status,
                  &statistics_map](mlir::TF::CustomAggregatorOp aggregator_op) {
    mlir::StringRef id = aggregator_op.getId();
    auto iter = statistics_map.find(id);
    if (iter == statistics_map.end()) {
      status = absl::InternalError(
          absl::StrFormat("Calibrated data does not exist. Cannot find "
                          "statistics. value for id: %s",

# RUN: tf-mlir-translate -graphdef-to-mlir -tf-enable-shape-inference-on-import=false %s -tf-input-arrays=iter,val -tf-input-data-types=DT_INT32,DT_FLOAT -tf-input-shapes=':' -tf-output-arrays=StatefulWhile:1,StatelessWhile:1,WhileWithOutputShapes:1 -o - -mlir-print-debuginfo -mlir-print-local-scope | FileCheck %s

# Verify that TensorFlow While and StatelessWhile ops are mapped to the
# composite While op in MLIR with is_stateless attribute set accordingly to

// function values via a struct field.
//
//go:noinline
func ExerciseFuncField(iter int, a1, a2 AddFunc, m1, m2 mult.MultFunc) int {
	ops := struct {
		a AddFunc
		m mult.MultFunc
	}{}

	val := 0
	for i := 0; i < iter; i++ {
		ops.a = a1
		ops.m = m1
		if i%10 == 0 {
			ops.a = a2
			ops.m = m2
		}