package main

func main() {
	defer func() {
		// This recover recovers the panic caused by the nil defer func
		// g(). The original panic(1) was already aborted/replaced by this
		// new panic, so when this recover is done, the program completes
		// normally.
		recover()
	}()
	f()
}

func f() {
	var g func()
	defer g()
	panic(1)

	var k pthreadkey
	err := g0_pthread_key_create(&k, 0)
	if err != 0 {
		abort()
	}

	const magic = 0xc476c475c47957
	err = g0_pthread_setspecific(k, magic)
	if err != 0 {
		abort()
	}

	for i, x := range tlsbase {
		if x == magic {
			*tlsg = uintptr(i * goarch.PtrSize)
			g0_pthread_setspecific(k, 0)
			return
		}
	}
	abort()

 * limitations under the License.
 */

package org.gradle.process.internal;

public enum ExecHandleState {
    INIT(false),
    STARTING(false),
    STARTED(false),
    ABORTED(true),
    FAILED(true),
    DETACHED(true),
    SUCCEEDED(true);

    private final boolean terminal;

    ExecHandleState(boolean terminal) {
        this.terminal = terminal;
    }

                    --shell /bin/false \
                    --home "$FESS_USER_HOME"  \
                    "$FESS_USER"
            echo " OK"
        fi
    ;;
    abort-deconfigure|abort-upgrade|abort-remove)
    ;;

    # RedHat ####################################################
    1|2)

        # Create fess group if not existing
        if ! getent group "$FESS_GROUP" > /dev/null 2>&1 ; then

import (
	"internal/abi"
	"unsafe"
)

//go:nosplit
//go:cgo_unsafe_args
func thrsleep(ident uintptr, clock_id int32, tsp *timespec, lock uintptr, abort *uint32) int32 {
	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(thrsleep_trampoline)), unsafe.Pointer(&ident))
	KeepAlive(tsp)
	KeepAlive(abort)
	return ret
}
func thrsleep_trampoline()

//go:nosplit
//go:cgo_unsafe_args
func thrwakeup(ident uintptr, n int32) int32 {

   * <p>If the target method call finishes before the limit is reached, the return value or
   * exception is propagated to the caller exactly as-is. If, on the other hand, the time limit is
   * reached, the proxy will attempt to abort the call to the target, and will throw an {@link
   * UncheckedTimeoutException} to the caller.
   *
   * <p>It is important to note that the primary purpose of the proxy object is to return control to

void C1() __attribute__ ((weak));
void C2() __attribute__ ((weak));

void C1() {
	int i;
	Go1(&i);
	if (i != 42) {
		abort();
	}
}

void C2() {
	char a[2];
	a[1] = 42;
	Go2(a);
	if (a[0] != 42) {
		abort();
	}
}
*/
import "C"

import (
	"reflect"
	"unsafe"
)

//export Go1
func Go1(p *C.int) {

        then:
        1 * execHandle.addListener(_)
        1 * execHandle.start()
        1 * execHandle.getState() >> ExecHandleState.STARTED
        1 * execHandle.toString() >> 'ExecHandle'
        1 * execHandle.abort()
        1 * acceptor.stop()
    }

    def startThrowsExceptionWhenChildProcessNeverConnectsAndCleansUp() {
        ExecHandleListener listener
        def execResult = Mock(ExecResult)

        when:

	abort();
}

void
x_cgo_notify_runtime_init_done(void* dummy) {
	 _cgo_maybe_run_preinit();

	 EnterCriticalSection(&runtime_init_cs);
	runtime_init_done = 1;
	 LeaveCriticalSection(&runtime_init_cs);

	 if (!SetEvent(runtime_init_wait)) {
		fprintf(stderr, "runtime: failed to signal runtime initialization complete.\n");
		abort();
	}
}

        }

        this.execHandle = execHandle;
    }

    @Override
    public void run() {
        try {
            execHandle.abort();
        } catch (Throwable t) {
            LOGGER.error("failed to abort " + execHandle, t);
        }
    }