Subversion Repositories openrisc

// $G $D/$F.go && $L $F.$A && ./$A.out

// Copyright 2010 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test of recover during recursive panics.
// Here be dragons.

package main

import "runtime"

func main() {
        test1()
        test2()
        test3()
        test4()
        test5()
        test6()
        test7()
}

func die() {
        runtime.Breakpoint()    // can't depend on panic
}

func mustRecover(x interface{}) {
        mustNotRecover()        // because it's not a defer call
        v := recover()
        if v == nil {
                println("missing recover")
                die()   // panic is useless here
        }
        if v != x {
                println("wrong value", v, x)
                die()
        }
        
        // the value should be gone now regardless
        v = recover()
        if v != nil {
                println("recover didn't recover")
                die()
        }
}

func mustNotRecover() {
        v := recover()
        if v != nil {
                println("spurious recover")
                die()
        }
}

func withoutRecover() {
        mustNotRecover()        // because it's a sub-call
}

func test1() {
        // Easy nested recursive panic.
        defer mustRecover(1)
        defer func() {
                defer mustRecover(2)
                panic(2)
        }()
        panic(1)
}

func test2() {
        // Sequential panic.
        defer mustNotRecover()
        defer func() {
                v := recover()
                if v == nil || v.(int) != 2 {
                        println("wrong value", v, 2)
                        die()
                }
                defer mustRecover(3)
                panic(3)
        }()
        panic(2)
}

func test3() {
        // Sequential panic - like test2 but less picky.
        defer mustNotRecover()
        defer func() {
                recover()
                defer mustRecover(3)
                panic(3)
        }()
        panic(2)
}

func test4() {
        // Single panic.
        defer mustNotRecover()
        defer func() {
                recover()
        }()
        panic(4)
}

func test5() {
        // Single panic but recover called via defer
        defer mustNotRecover()
        defer func() {
                defer recover()
        }()
        panic(5)
}

func test6() {
        // Sequential panic.
        // Like test3, but changed recover to defer (same change as test4 → test5).
        defer mustNotRecover()
        defer func() {
                defer recover() // like a normal call from this func; runs because mustRecover stops the panic
                defer mustRecover(3)
                panic(3)
        }()
        panic(2)
}

func test7() {
        // Like test6, but swapped defer order.
        // The recover in "defer recover()" is now a no-op,
        // because it runs called from panic, not from the func,
        // and therefore cannot see the panic of 2.
        // (Alternately, it cannot see the panic of 2 because
        // there is an active panic of 3.  And it cannot see the
        // panic of 3 because it is at the wrong level (too high on the stack).)
        defer mustRecover(2)
        defer func() {
                defer mustRecover(3)
                defer recover() // now a no-op, unlike in test6.
                panic(3)
        }()
        panic(2)
}