}
  return p;
}
*/
import "C"
import (
	"fmt"
	"unsafe"
)

func main() {
	a := C.f()
	q5 := (*C.int)(unsafe.Add(unsafe.Pointer(a), 4*5))
	// Access to C pointer out of bounds.
	*q5 = 100 // BOOM
	// We shouldn't get here; asan should stop us first.
	fmt.Printf("q5: %d, %x\n", *q5, q5)

func main() {
	a := 1
	b := 2
	// The local variables.
	// When -asan is enabled, the unsafe.Pointer(&a) conversion is escaping.
	var p *int = (*int)(unsafe.Add(unsafe.Pointer(&a), 1*unsafe.Sizeof(int(1))))
	*p = 20 // BOOM
	d := a + b
	fmt.Println(d)

        buildFile << """
            class BrokenSerializable implements java.io.Serializable {
                private Object writeReplace() {
                    throw new RuntimeException("BOOM")
                }
            }

            class BrokenTaskType extends DefaultTask {
                final prop = new BrokenSerializable()
            }

            task broken(type: BrokenTaskType)

int* test() {
 p = (int *)malloc(2 * sizeof(int));
 free(p);
 return p;
}
*/
import "C"
import "fmt"

func main() {
	// C passes Go an invalid pointer.
	a := C.test()
	// Use after free
	*a = 2 // BOOM
	// We shouldn't get here; asan should stop us first.
	fmt.Println(*a)

//go:noinline
func add(a1, b1 int) int {
	// The arguments.
	// When -asan is enabled, unsafe.Pointer(&a1) conversion is escaping.
	var p *int = (*int)(unsafe.Add(unsafe.Pointer(&a1), 1*unsafe.Sizeof(int(1))))
	*p = 10 // BOOM
	return a1 + b1

            addUnrecoverableErrorHandler(_) >> { args -> handler = args[0] }
            addOutgoing(_) >> Stub(RemoteTestClassProcessor)
        }

        when:
        def unexpectedException = new Throwable('BOOM!')
        handler.execute(unexpectedException)

        and:
        processor.stop()

        then:
        def e = thrown(DefaultMultiCauseException)
        e.causes.contains(unexpectedException)

        buildFile """
            task cacheable(type: Cacheable) {
                doLast {
                    throw new GradleException("boom")
                }
            }
        """
        when:
        withBuildCache().fails "cacheable"
        failure.assertHasCause("boom")
        then:
        assertCachingDisabledFor null, null
    }

        def factory = new DefaultFailureFactory(StackTraceClassifier.USER_CODE)

        def e0 = SimulatedJavaException.simulateDeeperException()
        def e = new RuntimeException("BOOM", e0)
        e0.initCause(e)
        e0.addSuppressed(e)

        when:
        def failure = factory.create(e)
        def failureCause = failure.causes[0]

        then:

        def initDir = gradleUserHomeDir.createDir('init.d')
        initDir.createFile('broken.gradle') << """
            throw new Exception('BOOM!')
        """

        when:
        fails("help")

        then:
        oldButRecentlyUsedGradleDist.assertAllDirsExist()
        oldNotRecentlyUsedGradleDist.assertAllDirsExist()

                    assert false;
                }

                @Test
                public void failWithUnexpectedRuntimeException() {
                    throw new IllegalStateException("Boom!");
                }

                @Test
                public void failWithBrokenAssertion() {
                    assertEquals("This should fail.", "myExpectedValue", "myActualValue");
                }