error.message.contains("              |       |  'notOne'")
    }

    def "fails with not equal values in sub-model check"() {
        when:
        ToolingApiModelChecker.checkModel(
            dummyCompositeModel(dummyModel("one")),
            dummyCompositeModel(dummyModel("notOne")),
            [
                [{ it.modelOne }, { a, e ->

IntegTestPreconditions$NotParallelExecutor,UnitTestPreconditions$StableGroovy
UnitTestPreconditions$NotWindowsJavaBefore9
UnitTestPreconditions$NotWindowsJavaBefore11
UnitTestPreconditions$Online
UnitTestPreconditions$Online,TestKitPreconditions$LowestMajorGradleIsAvailable
UnitTestPreconditions$Online,UnitTestPreconditions$Jdk11OrEarlier,IntegTestPreconditions$NotEmbeddedExecutor
UnitTestPreconditions$SmartTerminalAvailable
UnitTestPreconditions$StableGroovy

   *     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.
   */
  @Deprecated
  protected ExecutionError() {}

  /**

   *     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.
   */
  @Deprecated
  protected UncheckedExecutionException() {}

  /**

    def addresses = new InetAddresses()

    def "always contains at least one loopback address"() {
        expect:
        !addresses.loopback.empty
    }

    @Requires(UnitTestPreconditions.Online)
    def "always contains at least one remote address"() {
        expect:
        !addresses.remote.empty
    }

    def "No remote addresses are loopback addresses"() {
        expect:

     * @return uses the Maven project and its child modules
     */
    boolean aggregator() default false;

    /**
     * does this Mojo need to be online to be executed?
     * @return need to be online
     */
    boolean onlineRequired() default false;

    /**
     * TODO: v4: add a SPI for the configurator
     * configurator bean name.
     * @return the configurator bean name

import org.gradle.integtests.fixtures.AbstractDependencyResolutionTest
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions

@Requires(UnitTestPreconditions.Online)
class GradlePluginPortalDependencyResolveIntegrationTest extends AbstractDependencyResolutionTest {

    def gradlePluginPortalRepository = """
        repositories {
            gradlePluginPortal()

import org.gradle.integtests.fixtures.AbstractDependencyResolutionTest
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions

@Requires(UnitTestPreconditions.Online)
class MavenGoogleDependencyResolveIntegrationTest extends AbstractDependencyResolutionTest {

    def setup() {
        buildFile << """
            repositories {
                google()

   *     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.
   */
  @Deprecated
  protected UncheckedExecutionException() {}

  /**

 *
 * This should only be used on a type that is always assumed to also implement the internal protocol by Gradle internals.
 *
 * This exists to help anyone reading the source code realise that there is an internal component to the type.
 */
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.TYPE})
public @interface HasInternalProtocol {