return func(yield func(int) bool) {
		panic("boom")
	}
}

func panicCleanupSeq() Seq[int] {
	return func(yield func(int) bool) {
		for {
			if !yield(55) {
				panic("boom")
			}
		}
	}
}

func TestPull2Panic(t *testing.T) {
	t.Run("next", func(t *testing.T) {
		next, stop := Pull2(panicSeq2())
		if !panicsWith("boom", func() { next() }) {

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

package main

/*
#include <stdlib.h>
#include <stdio.h>

void test(int *a) {
	// Access Go pointer out of bounds.
	int c = a[5];        // BOOM
	// We shouldn't get here; asan should stop us first.
	printf("a[5]=%d\n", c);
}
*/
import "C"

func main() {
	cIntSlice := []C.int{200, 201, 203, 203, 204}
	C.test(&cIntSlice[0])

        override fun run() {
          throw RuntimeException("boom!")
        }
      }
    thread.start()
    thread.join()

    assertFailsWith<AssertionError> {
      testRule.afterEach(extensionContext)
    }.also { expected ->
      assertThat(expected).hasMessage("uncaught exception thrown during test")
      assertThat(expected.cause!!).hasMessage("boom!")
    }
  }

            @Override
            public boolean isActive(Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
                throw new RuntimeException("BOOM");
            }

            @Override
            public boolean presentInConfig(
                    Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
                return true;

	p := new([1024 * 1000]int)
	p[0] = 10
	r := bar(&p[1024*1000-1])
	fmt.Printf("r value is %d", r)
}

func bar(a *int) int {
	p := unsafe.Add(unsafe.Pointer(a), 2*unsafe.Sizeof(int(1)))
	runtime.ASanWrite(p, 8) // BOOM
	*((*int)(p)) = 10
	return *((*int)(p))

        def lazyDep = provider {
            throw new GradleException("Boom!")
        }

        dependencies {
            conf lazyDep
        }
        // Do the resolve
        configurations.conf.incoming.dependencies
        """

        when:
        fails("help")

        then:
        failure.assertHasCause("Boom!")
    }

   * exception goes to the uncaught exception handler.
   */
  private fun interceptorThrowsRuntimeExceptionAsynchronous(network: Boolean) {
    val boom = RuntimeException("boom!")
    addInterceptor(network) { chain: Interceptor.Chain? -> throw boom }
    val executor = ExceptionCatchingExecutor()
    client =
      client.newBuilder()
        .dispatcher(Dispatcher(executor))
        .build()
    val request =

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

package main

/*
#include <stdlib.h>
#include <stdio.h>

int test(int *a) {
	a[2] = 300;  // BOOM
	return a[2];
}
*/
import "C"

import "fmt"

var cIntArray [2]C.int

func main() {
	r := C.test(&cIntArray[0])
	fmt.Println("r value = ", r)

    }

    static abstract class SuperBaz {
        void setBaz(int baz) {
            boom
        }

        abstract String getBoom()
    }

    static class Baz extends SuperBaz {
        void setBaz(int baz) {
            super.setBaz(baz)
        }

        String getBoom() {
            throw new Exception("boom")
        }
    }

        when:
        lazy.get()

        then:
        0 * supplier.get()

        when:
        lazy.use {
            throw new RuntimeException("boom")
        }
        then:
        def e = thrown(RuntimeException)
        e.message == "boom"

        where:
        factory            | factoryName
        Lazy.unsafe()::of  | "unsafe"
        Lazy.locking()::of | "locking"