}
	if y != (T{}) {
		t.Errorf("map value not zero")
	}
}

type empty struct {
}

func TestEmptyKeyAndValue(t *testing.T) {
	a := make(map[int]empty, 4)
	b := make(map[empty]int, 4)
	c := make(map[empty]empty, 4)
	a[0] = empty{}
	b[empty{}] = 0
	b[empty{}] = 1
	c[empty{}] = empty{}

	if len(a) != 1 {
		t.Errorf("empty value insert problem")
	}

    private final AtomicInteger counter = new AtomicInteger(0);
    private final ConcurrentMap<Object, Integer> uids =
        Platform.tryWeakKeys(new MapMaker()).makeMap();

    private Integer getUid(Object obj) {
      Integer uid = uids.get(obj);
      if (uid == null) {
        // One or more integer values could be skipped in the event of a race

			})
		}
	}
}

type vmCase struct {
	name string
	from echo.Instance
	to   echo.Instances
	host string
}

func DNSTestCases(t TrafficContext) {
	makeSE := func(ips ...string) string {
		return tmpl.MustEvaluate(`
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: dns
spec:
  hosts:
  - "fake.service.local"

	lockRankStruct
	// Futex-based impl treats it as uint32 key,
	// while sema-based impl as M* waitm.
	// Used to be a union, but unions break precise GC.
	key uintptr
}

// sleep and wakeup on one-time events.
// before any calls to notesleep or notewakeup,
// must call noteclear to initialize the Note.
// then, exactly one thread can call notesleep
// and exactly one thread can call notewakeup (once).

	})
	return file_workloadapi_workload_proto_rawDescData
}

var file_workloadapi_workload_proto_enumTypes = make([]protoimpl.EnumInfo, 6)
var file_workloadapi_workload_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
var file_workloadapi_workload_proto_goTypes = []interface{}{
	(WorkloadStatus)(0),             // 0: istio.workload.WorkloadStatus

					break
				}
				// if we don't already have a value, and contain structs, add an empty item so we can recurse
				item := reflect.New(visit.value.Type().Elem()).Elem()
				visit.value.Set(reflect.MakeMap(visit.value.Type()))
				visit.value.SetMapIndex(reflect.New(visit.value.Type().Key()).Elem(), item)
				toVisit = append(toVisit, testPath{path: visit.path + "[*]", value: item})

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
      in.defaultReadObject();
      MapMaker mapMaker = readMapMaker(in);
      delegate = mapMaker.makeMap();
      readEntries(in);
    }

    private Object readResolve() {
      return delegate;
    }
  }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
      in.defaultReadObject();
      MapMaker mapMaker = readMapMaker(in);
      delegate = mapMaker.makeMap();
      readEntries(in);
    }

    private Object readResolve() {
      return delegate;
    }
  }

		{"AwayFromZero", Const, 5},
		{"Below", Const, 5},
		{"ErrNaN", Type, 5},
		{"Exact", Const, 5},
		{"Float", Type, 5},
		{"Int", Type, 0},
		{"Jacobi", Func, 5},
		{"MaxBase", Const, 0},
		{"MaxExp", Const, 5},
		{"MaxPrec", Const, 5},
		{"MinExp", Const, 5},
		{"NewFloat", Func, 5},
		{"NewInt", Func, 0},
		{"NewRat", Func, 0},
		{"ParseFloat", Func, 5},
		{"Rat", Type, 0},

    "true" or "1", this environment variable makes `tf.nn.bias_add` operate
    deterministically (i.e. reproducibly), but currently only when XLA JIT
    compilation is *not* enabled. Setting `TF_DETERMINISTIC_OPS` to "true" or
    "1" also makes cuDNN convolution and max-pooling operate deterministically.
    This makes Keras Conv\*D and MaxPool\*D layers operate deterministically in