intellij-script-dependencies-reload.png...

John Howard <******@****.***> 1682567490 -0700

	REG_RAX    = C.REG_RAX
	REG_GS     = C.REG_GS
	REG_FS     = C.REG_FS
	REG_ES     = C.REG_ES
	REG_DS     = C.REG_DS
	REG_TRAPNO = C.REG_TRAPNO
	REG_ERR    = C.REG_ERR
	REG_RIP    = C.REG_RIP
	REG_CS     = C.REG_CS
	REG_RFLAGS = C.REG_RFL
	REG_RSP    = C.REG_RSP
	REG_SS     = C.REG_SS

				t.Fatal(err)
			}
			out = p.BytesCompressed()
			if _, err := p.SetBytes(out); err != nil {
				t.Fatal(err)
			}
		}); allocs > 0 {
			t.Errorf("expected zero allocations, got %0.1f", allocs)
		}
	})
	t.Run("P256", func(t *testing.T) {
		if allocs := testing.AllocsPerRun(10, func() {
			p := nistec.NewP256Point().SetGenerator()
			scalar := make([]byte, 32)
			rand.Read(scalar)

		}
		em := testMetrics{
			usage:      float64(i) / float64(256),
			allocs:     float64(i),
			releases:   0,
			allocTries: 0,
			max:        float64(max),
		}
		expectMetrics(t, cidr, em)
	}
	// Release all
	a.Release(clusterCIDR)
	em = testMetrics{
		usage:      0,
		allocs:     256,
		releases:   256,
		allocTries: 0,
		max:        float64(max),
	}

	enc := NewEncoder(&buf)
	bench := &Bench{7, 3.2, "now is the time", []byte("for all good men")}

	allocs := testing.AllocsPerRun(N, func() {
		err := enc.Encode(bench)
		if err != nil {
			t.Fatal("encode:", err)
		}
	})
	if allocs != 0 {
		t.Fatalf("mallocs per encode of type Bench: %v; wanted 0\n", allocs)
	}
}

func TestCountDecodeMallocs(t *testing.T) {
	if testing.Short() {

index-02-redoc-simple.png...

	const (
		goal   = "/gc/heap/goal:bytes"
		count  = "/gc/cycles/total:gc-cycles"
		allocs = "/gc/heap/allocs:bytes"
		frees  = "/gc/heap/frees:bytes"
	)

	sample := []metrics.Sample{{Name: goal}, {Name: count}, {Name: allocs}, {Name: frees}}
	const (
		GOAL   = 0
		COUNT  = 1
		ALLOCS = 2
		FREES  = 3
	)

	// Assumptions and observations of Go's garbage collector, as of Go 1.17-1.20:

}

func TestMapRangeNoAllocations(t *testing.T) { // Issue 62404
	testenv.SkipIfOptimizationOff(t)
	var m sync.Map
	allocs := testing.AllocsPerRun(10, func() {
		m.Range(func(key, value any) bool {
			return true
		})
	})
	if allocs > 0 {
		t.Errorf("AllocsPerRun of m.Range = %v; want 0", allocs)
	}
}

// TestConcurrentClear tests concurrent behavior of sync.Map properties to ensure no data races.

		{"RegsAMD64.R9", Field, 0},
		{"RegsAMD64.SI", Field, 0},
		{"RegsAMD64.SP", Field, 0},
		{"Reloc", Type, 10},
		{"Reloc.Addr", Field, 10},
		{"Reloc.Extern", Field, 10},
		{"Reloc.Len", Field, 10},
		{"Reloc.Pcrel", Field, 10},
		{"Reloc.Scattered", Field, 10},
		{"Reloc.Type", Field, 10},
		{"Reloc.Value", Field, 10},
		{"RelocTypeARM", Type, 10},
		{"RelocTypeARM64", Type, 10},