buildA = singleProjectBuildInRootFolder("buildA") {
            buildFile << """
                apply plugin: 'java-library'
                dependencies {
                    testImplementation "org.test:b1:1.0"
                }
            """
            settingsFile << """
                includeBuild 'buildB'
                includeBuild 'buildC'
            """
        }

 * @since 7.6
 */
@Incubating
public abstract class TestFailure {

    /**
     * Returns the list of causes.
     * <p>
     * The result is typically non-empty for multi-assertion failures, e.g. for {@code org.test4j.MultipleFailuresError}, where the individual failures are in the returned list.
     *
     * @return the cause failures.
     */
    public abstract List<TestFailure> getCauses();

    /**

 */

/** @file
 * Basic interface with output to stdout.
 */
/** @addtogroup Basic
 * @{
 */

#ifndef CUNIT_BASIC_H_SEEN
#define CUNIT_BASIC_H_SEEN

#include "CUnit.h"
#include "TestDB.h"

#ifdef __cplusplus
extern "C" {
#endif

/** Run modes for the basic interface. */
typedef enum {
  CU_BRM_NORMAL = 0,  /**< Normal mode - failures and run summary are printed [default]. */

            }

            repositories {
               maven { url "${mavenRepo.uri}" }
            }

            dependencies {
                conf 'org.test:a:1.0'
                conf 'org.test:b:1.0'
            }

            task checkDeps {
                doLast {
                    def result = configurations.conf.incoming.resolutionResult
                    result.allComponents {

}
-- b/b.go --
package b

func init() {
	println("package 'b' init: release the kraken")
}

func BFunc() int {
	return -42
}
-- b/b_test.go --
package b

import "testing"

func TestB(t *testing.T) {
	if BFunc() != -42 {
		t.Fatalf("bad!")
	}
}
-- f/f.go --
package f

func Id() int {
     return 42
}
-- main/main.go --
package main

import (
	"M/a"
	"M/b"
)

        buildA = singleProjectBuildInRootFolder("buildA") {
            buildFile << """
                apply plugin: 'java'
                dependencies {
                    ${testImplementationConfiguration} "org.test:b1:1.0"
                }
            """
            settingsFile << """
                includeBuild 'buildB'
                includeBuild 'buildC'
            """
        }

                capability group:'org', name:'capability', version:'1.0'
            }
        """

        when:
        fails 'compileJava'

        then:
        failure.assertHasCause("""Module 'test:b' has been rejected:
   Cannot select module with conflict on capability 'org:capability:1.0' also provided by [:test:unspecified(compileClasspath)]""")
    }

    def 'fails to resolve undeclared test fixture'() {

            dependencies {
                implementation(project(':b'))
                atestImplementation(project(':b')) {
                    capabilities {
                        requireCapability('test:b-feature')
                    }
                }
            }
        """

        file('b/build.gradle') << """
            sourceSets {
                functionalTest
            }

}
-- b/b.go --
package b

func init() {
	println("package 'b' init: release the kraken")
}

func BFunc() int {
	return -42
}
-- b/b_test.go --
package b

import "testing"

func TestB(t *testing.T) {
	if BFunc() != -42 {
		t.Fatalf("bad!")
	}
}
-- deadstuff/deadstuff.go --
package deadstuff

func downStreamOfPanic(x int) {
	panic("bad")
	if x < 10 {
		println("foo")
	}
}

// Fold boolean tests into blocks
(NE (TESTB (SETL  cmp) (SETL  cmp)) yes no) => (LT  cmp yes no)
(NE (TESTB (SETLE cmp) (SETLE cmp)) yes no) => (LE  cmp yes no)
(NE (TESTB (SETG  cmp) (SETG  cmp)) yes no) => (GT  cmp yes no)
(NE (TESTB (SETGE cmp) (SETGE cmp)) yes no) => (GE  cmp yes no)
(NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no) => (EQ  cmp yes no)
(NE (TESTB (SETNE cmp) (SETNE cmp)) yes no) => (NE  cmp yes no)