.assertTestFailed("failing", equalTo('java.lang.AssertionError: failing test'))
            .assertStdout(allOf(containsString('org.gradle.testing.SuperTest#failing\n'), containsString('org.gradle.testing.SuperTest#passing\n')))
        htmlReport.testClass("org.gradle.testing.SubTest").assertTestCount(4, 1, 0).assertTestPassed("passing") // onlySub is passing once and failing once

   *     of this class typically expect for instances to have a non-null cause. At the moment, you
   *     can <i>usually</i> still preserve behavior by passing an explicit {@code null} cause. Note,
   *     however, that passing an explicit {@code null} cause prevents anyone from calling {@link
   *     #initCause} later, so it is not quite equivalent to using a constructor that omits the
   *     cause.
   */

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

// The unmarshal package defines an Analyzer that checks for passing
// non-pointer or non-interface types to unmarshal and decode functions.
//
// # Analyzer unmarshal
//
// unmarshal: report passing non-pointer or non-interface values to unmarshal
//
// The unmarshal analysis reports calls to functions such as json.Unmarshal

            ${testFrameworkImports}

            public class SomeTest {
                @Test public void showsOutputWhenPassing() {
                    System.out.println("out passing");
                    System.err.println("err passing");
                    assertTrue(true);
                }

                @Test public void showsOutputWhenFailing() {
                    System.out.println("out failing");

   *     accepts a cause: Users of this class typically expect for instances to have a non-null
   *     cause. At the moment, you can <i>usually</i> still preserve behavior by passing an explicit
   *     {@code null} cause. Note, however, that passing an explicit {@code null} cause prevents
   *     anyone from calling {@link #initCause} later, so it is not quite equivalent to using a
   *     constructor that omits the cause.
   */

   *     of this class typically expect for instances to have a non-null cause. At the moment, you
   *     can <i>usually</i> still preserve behavior by passing an explicit {@code null} cause. Note,
   *     however, that passing an explicit {@code null} cause prevents anyone from calling {@link
   *     #initCause} later, so it is not quite equivalent to using a constructor that omits the
   *     cause.
   */

		fail:    false,
	},
	{
		// Passing the address of a slice with a Go pointer.
		name:    "sliceptr1",
		c:       `void f7(void **p) {}`,
		imports: []string{"unsafe"},
		body:    `i := 0; s := []unsafe.Pointer{unsafe.Pointer(&i)}; C.f7(&s[0])`,
		fail:    true,
	},
	{
		// Passing the address of a slice with a Go pointer,
		// where we are passing the address of an element that
		// is not a Go pointer.

	// holding the transient P, leaving that P in limbo and deadlocking the
	// STW.
	//
	// Callers passing a non-nil P must already be in non-preemptible
	// context, otherwise such preemption could occur on function entry to
	// startm. Callers passing a nil P may be preemptible, so we must
	// disable preemption before acquiring a P from pidleget below.
	mp := acquirem()
	if !lockheld {

   *     accepts a cause: Users of this class typically expect for instances to have a non-null
   *     cause. At the moment, you can <i>usually</i> still preserve behavior by passing an explicit
   *     {@code null} cause. Note, however, that passing an explicit {@code null} cause prevents
   *     anyone from calling {@link #initCause} later, so it is not quite equivalent to using a
   *     constructor that omits the cause.
   */

Refraction of the first Crystal, the Rays which are refracted after the
usual manner in passing through the first Crystal, will be all of them
refracted after the unusual manner in passing through the second
Crystal; and the Rays which are refracted after the unusual manner in
passing through the first Crystal, will be all of them refracted after
the usual manner in passing through the second Crystal. And therefore