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

package main

import (
	"os"
	"runtime"
)

func foo(x int) int {
	return x + 1
}

func test() {
	defer func() {
		if r := recover(); r != nil {
			pcs := make([]uintptr, 10)
			n := runtime.Callers(0, pcs)
			pcs = pcs[:n]
			frames := runtime.CallersFrames(pcs)
			for {
				f, more := frames.Next()
				if f.Function == "main.foo" {

		defer func(x, y, z int) {
			if recover() != nil || x != 1 || y != 2 || z != 3 {
				panic("bad recover")
			}
		}(1, 2, 3)
	}
}

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

func defer3() {
	defer func(x, y, z int) {
		if recover() == nil {
			panic("failed recover")
		}
	}(1, 2, 3)
	panic("hi")
}

        when:
        server.stop()
        args("--offline")

        then:
        succeeds 'help'
        output.contains('loaded external script 2')
    }

    def "reports and recovers from missing remote script"() {
        String scriptName = "script-missing.gradle"
        String scriptUrl = "${server.uri}/${scriptName}"
        def scriptFile = file("script.gradle") << """

func doDoubleNext2() Seq2[int, int] {
	return func(_ func(int, int) bool) {
		defer func() {
			if recover() != nil {
				nextSlot2 = nil
			}
		}()
		nextSlot2()
	}
}

func TestPullDoubleYield(t *testing.T) {
	_, stop := Pull(storeYield())
	defer func() {
		if recover() != nil {
			yieldSlot = nil
		}
		stop()
	}()
	yieldSlot(5)
	if yieldSlot != nil {

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

package gob

import "fmt"

// Errors in decoding and encoding are handled using panic and recover.
// Panics caused by user error (that is, everything except run-time panics
// such as "index out of bounds" errors) do not leave the file that caused
// them, but are instead turned into plain error returns. Encoding and

	// os.Pipe because it is not supported on js/wasm.
	stdout := os.Stdout
	f := createTempFile(eg.Name)
	os.Stdout = f
	finished := false
	start := time.Now()

	// Clean up in a deferred call so we can recover if the example panics.
	defer func() {
		timeSpent := time.Since(start)

		// Restore stdout, get output and remove temporary file.
		os.Stdout = stdout
		var buf strings.Builder

}

func testInt64IndexPanic(t *testing.T) {
	defer func() {
		if r := recover(); r != nil {
			//println("panicked as expected")
		}
	}()

	str := "foobar"
	t.Errorf("got %d and expected to panic, but didn't", testInt64Index_ssa(str, 1<<32+1))
}

func testInt64SlicePanic(t *testing.T) {
	defer func() {
		if r := recover(); r != nil {
			//println("panicked as expected")
		}
	}()

	t.Run("zero", func(t *testing.T) {
		h := Handle(0)

		defer func() {
			if r := recover(); r != nil {
				return
			}
			t.Fatalf("Delete of zero handle did not trigger a panic")
		}()

		h.Delete()
	})

	t.Run("invalid", func(t *testing.T) {
		h := NewHandle(42)

		defer func() {
			if r := recover(); r != nil {
				h.Delete()
				return
			}

            'group:projectA' {
                expectVersionListing()
                '1.2' {
                    expectResolve()
                }
            }
        }

        then: "recovers from previous --offline mode"
        checkResolve "group:projectA:1.+": ["group:projectA:1.2", "didn't match version 2.0"], "group:projectB:latest.release": ["group:projectB:1.1", "didn't match version 2.2"]
    }

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

package main

func main() {
	testRecover()

}

func testRecover() {
	if false {
		func() {
			defer func() {
				_ = recover()
			}()
		}()
	}