// first time for this instance of [Once]. In other words, given
//
//	var once Once
//
// if once.Do(f) is called multiple times, only the first call will invoke f,
// even if f has a different value in each invocation. A new instance of
// Once is required for each function to execute.
//
// Do is intended for initialization that must be run exactly once. Since f

		t.Errorf("once failed outside run: %d is not 1", *o)
	}
}

func TestOncePanic(t *testing.T) {
	var once Once
	func() {
		defer func() {
			if r := recover(); r == nil {
				t.Fatalf("Once.Do did not panic")
			}
		}()
		once.Do(func() {
			panic("failed")
		})
	}()

	once.Do(func() {
		t.Fatalf("Once.Do called twice")
	})
}

func BenchmarkOnce(b *testing.B) {
	var once Once
	f := func() {}

package sync

// OnceFunc returns a function that invokes f only once. The returned function
// may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceFunc(f func()) func() {
	var (
		once  Once
		valid bool
		p     any
	)
	// Construct the inner closure just once to reduce costs on the fast path.
	g := func() {
		defer func() {
			p = recover()

}

func ExampleOnce() {
	var once sync.Once
	onceBody := func() {
		fmt.Println("Only once")
	}
	done := make(chan bool)
	for i := 0; i < 10; i++ {
		go func() {
			once.Do(onceBody)
			done <- true
		}()
	}
	for i := 0; i < 10; i++ {
		<-done
	}
	// Output:
	// Only once
}

// This example uses OnceValue to perform an "expensive" computation just once,
// even when used concurrently.

-- input --
Text.
 1. Uno
   2) Dos
 3. Tres
   5. Cinco
 7. Siete
   11. Once
 12. Doce
 13. Trece.

-- gofmt --
Text.
 1. Uno
 2. Dos
 3. Tres
 5. Cinco
 7. Siete
 11. Once
 12. Doce
 13. Trece.

-- text --
Text.
 1. Uno
 2. Dos
 3. Tres
 5. Cinco
 7. Siete
 11. Once
 12. Doce
 13. Trece.

-- markdown --
Text.

 1. Uno
 2. Dos
 3. Tres

// to a Run method), even in the presence of process termination. It guarantees exactly once
// invocation of the provided notify functions.
type Handler struct {
	notify []func()
	final  func(os.Signal)
	once   sync.Once
}

// New creates a new handler that guarantees all notify functions are run after the critical

	// the Lock fast path should be inlined
	mutex.Lock() // ERROR "inlining call to sync\.\(\*Mutex\)\.Lock"
}

var once *sync.Once

func small7() { // ERROR "can inline small7"
	// the Do fast path should be inlined
	once.Do(small5) // ERROR "inlining call to sync\.\(\*Once\)\.Do" "inlining call to atomic\.\(\*Uint32\)\.Load"
}

var rwmutex *sync.RWMutex

func small8() { // ERROR "can inline small8"

	batch *LoaderBatch[K, R]
}

func (l *Loader[K, R]) Load() error {
	l.batch.f()
	return nil
}

type LoaderBatch[K comparable, R any] struct {
	once    *sync.Once
}

func (b *LoaderBatch[K, R]) f() {
	b.once.Do(func() {})

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Check that we do loads exactly once. The SSA backend
// once tried to do the load in f twice, once sign extended
// and once zero extended.  This can cause problems in
// racy code, particularly sync/mutex.

package main

func f(p *byte) bool {
	x := *p
	a := int64(int8(x))

package testing

import (
	"os"
	"sync"

	"k8s.io/kube-openapi/pkg/spec3"
)

type OpenAPIV3Getter struct {
	Path      string
	once      sync.Once
	bytes     []byte
	openapiv3 spec3.OpenAPI
}

func (f *OpenAPIV3Getter) SchemaBytesOrDie() []byte {
	f.once.Do(func() {
		_, err := os.Stat(f.Path)
		if err != nil {
			panic(err)
		}
		spec, err := os.ReadFile(f.Path)
		if err != nil {
			panic(err)