namespace: ns2
spec:
  hosts:
    - random-1.host.example
  # expect address to be auto allocated
  ports:
    - number: 80
      name: http
      protocol: HTTP
  resolution: DNS
---
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: service-dns-with-addr
  namespace: ns2
spec:
  hosts:
    - random-2.host.example
  addresses:
    - 9.9.9.9
  ports:

	return valid, em, index, nil
}

// nonZeroRandomBytes fills the given slice with non-zero random octets.
func nonZeroRandomBytes(s []byte, random io.Reader) (err error) {
	_, err = io.ReadFull(random, s)
	if err != nil {
		return
	}

	for i := 0; i < len(s); i++ {
		for s[i] == 0 {
			_, err = io.ReadFull(random, s[i:i+1])
			if err != nil {
				return
			}

import java.util.LinkedList;
import java.util.Random;

@Fork(4)
@Threads(2)
@Warmup(iterations = 10)
@State(Scope.Benchmark)
public class CachedConstructorsBenchmark {

    private final static Class<?>[] CLAZZ_ARRAY = new Class<?>[]{ArrayList.class, LinkedList.class, String.class, HashMap.class};
    private final static int ARR_LEN = 1024;
    private final static Random RANDOM = new Random();

  - devicePath: /dev/disk/by-id/some-random-clusterb9772-pvc-c2435a06-14d7-11e7-9baf-42010a800049
    name: kubernetes.io/pd/some-random-clusterb9772-pvc-c2435a06-14d7-11e7-9baf-42010a800049
  - devicePath: /dev/disk/by-id/some-random-clusterb9772-pvc-8bf50554-fd42-11e6-94d4-42010a800049
    name: kubernetes.io/pd/some-random-clusterb9772-pvc-8bf50554-fd42-11e6-94d4-42010a800049

  - devicePath: /dev/disk/by-id/some-random-clusterb9772-pvc-c2435a06-14d7-11e7-9baf-42010a800049
    name: kubernetes.io/pd/some-random-clusterb9772-pvc-c2435a06-14d7-11e7-9baf-42010a800049
  - devicePath: /dev/disk/by-id/some-random-clusterb9772-pvc-8bf50554-fd42-11e6-94d4-42010a800049
    name: kubernetes.io/pd/some-random-clusterb9772-pvc-8bf50554-fd42-11e6-94d4-42010a800049

  int[] queries = new int[ARRAY_SIZE];

  @BeforeExperiment
  void setUp() {
    Random random = new Random();
    multisets.clear();
    for (int i = 0; i < ARRAY_SIZE; i++) {
      HashMultiset<Integer> multiset = HashMultiset.<Integer>create();
      multisets.add(multiset);
      queries[i] = random.nextInt();
      multiset.add(queries[i]);
    }
  }

  @Benchmark
  int add(int reps) {

  location: MESH_INTERNAL
  workloadSelector:
    labels:
      app: random-{{$i}}

---
{{- end }}

---
{{- range $j := until .Instances }}
apiVersion: networking.istio.io/v1alpha3
kind: WorkloadEntry
metadata:
  name: random-{{$j}}
spec:
  serviceAccount: random
  address: 10.10.10.10
  labels:
    app: random-{{mod $j $.Services}}
---

  private final SpecialRandom random;
  private final double hitRate;
  private final int size;

  private final Set<Element> valuesInSet;
  private final Element[] queries;

  CollectionBenchmarkSampleData(int size) {
    this(true, new SpecialRandom(), 1.0, size);
  }

  CollectionBenchmarkSampleData(
      boolean isUserTypeFast, SpecialRandom random, double hitRate, int size) {

type ObjectKey [32]byte

// GenerateKey generates a unique ObjectKey from a 256 bit external key
// and a source of randomness. If random is nil the default PRNG of the
// system (crypto/rand) is used.
func GenerateKey(extKey []byte, random io.Reader) (key ObjectKey) {
	if random == nil {
		random = rand.Reader
	}
	if len(extKey) != 32 { // safety check
		logger.CriticalIf(context.Background(), errors.New("crypto: invalid key length"))

  @Param({"20", "2000"})
  int size;

  @Param({"2", "20"})
  int nonAlphaRatio; // one non-alpha char per this many chars

  @Param boolean noWorkToDo;

  Random random;
  String testString;

  @BeforeExperiment
  void setUp() {
    random = new Random(0xdeadbeef); // fix the seed so results are comparable across runs

    int nonAlpha = size / nonAlphaRatio;
    int alpha = size - nonAlpha;