- '*/testing-01.com'
      port:
        name: http
        number: 80
        protocol: HTTP
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: testing-service-01-test-02
  namespace: istio-system
spec:
  gateways:
    - istio-system/testing-gateway-2
  hosts:
    - testing-01.com # Expected: no validation error because this host exists
  http:
    - match:
        - uri:

            return spec;
        }

        @Override
        public SuiteSpec testNG(String name, TemplateLibraryVersionProvider libraryVersionProvider) {
            final SuiteSpec spec = new SuiteSpec(null, name, SuiteSpec.TestSuiteFramework.TEST_NG, libraryVersionProvider.getVersion("testng"), builder);
            suites.add(spec);
            return spec;
        }
    }

func Test3775(t *testing.T)                  { test3775(t) }
func Test4029(t *testing.T)                  { test4029(t) }
func Test4339(t *testing.T)                  { test4339(t) }
func Test5227(t *testing.T)                  { test5227(t) }
func Test5242(t *testing.T)                  { test5242(t) }
func Test5337(t *testing.T)                  { test5337(t) }

func BenchmarkEqIfaceConcrete(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = i1 == ts
	}
}

func BenchmarkNeEfaceConcrete(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = e != ts
	}
}

func BenchmarkNeIfaceConcrete(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = i1 != ts
	}
}

func BenchmarkConvT2EByteSized(b *testing.B) {
	b.Run("bool", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			e = yes
		}

package runtime_test

import (
	"fmt"
	"testing"
)

const N = 20

func BenchmarkMakeSliceCopy(b *testing.B) {
	const length = 32
	var bytes = make([]byte, 8*length)
	var ints = make([]int, length)
	var ptrs = make([]*byte, length)
	b.Run("mallocmove", func(b *testing.B) {
		b.Run("Byte", func(b *testing.B) {
			var x []byte
			for i := 0; i < b.N; i++ {

func BenchmarkUint32Div1247(b *testing.B)      { bmUint32Div(1247, b) }
func BenchmarkUint32Div9305(b *testing.B)      { bmUint32Div(9305, b) }
func BenchmarkUint32Div13307(b *testing.B)     { bmUint32Div(13307, b) }
func BenchmarkUint32Div52513(b *testing.B)     { bmUint32Div(52513, b) }
func BenchmarkUint32Div60978747(b *testing.B)  { bmUint32Div(60978747, b) }
func BenchmarkUint32Div106956295(b *testing.B) { bmUint32Div(106956295, b) }

// license that can be found in the LICENSE file.

package race_test

import (
	"sync"
	"testing"
)

func TestRaceSliceRW(t *testing.T) {
	ch := make(chan bool, 1)
	a := make([]int, 2)
	go func() {
		a[1] = 1
		ch <- true
	}()
	_ = a[1]
	<-ch
}

func TestNoRaceSliceRW(t *testing.T) {
	ch := make(chan bool, 1)
	a := make([]int, 2)
	go func() {
		a[0] = 1
		ch <- true
	}()

}

func TestEquivalents(t *testing.T) {
	t.Run("P224", func(t *testing.T) {
		testEquivalents(t, nistec.NewP224Point, elliptic.P224())
	})
	t.Run("P256", func(t *testing.T) {
		testEquivalents(t, nistec.NewP256Point, elliptic.P256())
	})
	t.Run("P384", func(t *testing.T) {
		testEquivalents(t, nistec.NewP384Point, elliptic.P384())
	})
	t.Run("P521", func(t *testing.T) {

		f.Skip()
	}
	f.Fuzz(func(*testing.T, []byte) {})
}

func FuzzFail(f *testing.F) {
	if isWorker() {
		f.Fail()
	}
	f.Fuzz(func(*testing.T, []byte) {})
}

func FuzzPanic(f *testing.F) {
	if isWorker() {
		panic("nope")
	}
	f.Fuzz(func(*testing.T, []byte) {})
}

func FuzzNilPanic(f *testing.F) {
	if isWorker() {
		panic(nil)
	}
	f.Fuzz(func(*testing.T, []byte) {})
}

package test

import (
	"testing"
)

var boolres bool

var i64res int64

func BenchmarkDivconstI64(b *testing.B) {
	for i := 0; i < b.N; i++ {
		i64res = int64(i) / 7
	}
}

func BenchmarkModconstI64(b *testing.B) {
	for i := 0; i < b.N; i++ {
		i64res = int64(i) % 7
	}
}

func BenchmarkDivisiblePow2constI64(b *testing.B) {
	for i := 0; i < b.N; i++ {