parent--;
                }
                parent = result.lastIndexOf('/', parent);
                if (parent < 0) {
                    result = result.substring(idx + 4);
                } else {
                    result = result.substring(0, parent) + result.substring(idx + 3);
                }
            }
        }

        return result;
    }

        filer.createResource(StandardLocation.SOURCE_OUTPUT, "", "bar.txt", type("B"))

        then:
        result.generatedTypesWithIsolatedOrigin.size() == 3
        result.generatedTypesWithIsolatedOrigin["A"] == ["Foo"] as Set
        result.generatedTypesWithIsolatedOrigin["pkg.package-info"] == ["Foo"] as Set
        result.generatedTypesWithIsolatedOrigin["B"] == ["Foo", "Bar"] as Set

        def foo = sourceResource("foo.txt")

        file("input").text = "input file"

        when:
        def result = runner('cacheable').build()

        then:
        result.tasks.collect { it.path } == [':cacheable']
        result.taskPaths(SUCCESS) == [':cacheable']
        result.taskPaths(SKIPPED).empty
        result.taskPaths(UP_TO_DATE).empty
        result.taskPaths(FAILED).empty
        result.taskPaths(FROM_CACHE).empty

        when:

        boolean result = ensureAtLeastOneNonNull(os);

        if (result && os.getFamily() != null) {
            result = determineFamilyMatch(os.getFamily());
        }
        if (result && os.getName() != null) {
            result = determineNameMatch(os.getName());
        }
        if (result && os.getArch() != null) {
            result = determineArchMatch(os.getArch());
        }

        def result = deserializeMultiple(serialized, 3)

        then:
        result[0] instanceof ChannelMessage
        result[0].channel == channelId1
        result[0].payload == "payload 1"
        result[1] instanceof ChannelMessage
        result[1].channel == channelId2
        result[1].payload == "payload 2"
        result[2] instanceof ChannelMessage

        result.task(":readmeCheck").outcome == TaskOutcome.FAILED
        result.output.contains('README should contain section: ^## API$')
    }

    def "fails when README does not have Changelog section"() {
        given:
        new File(testProjectDir, 'README.md') << """
## API
public API description
        """

        when:
        def result = runTaskWithFailure('check')

        then:

        }
        result.nextControlFlow("else");
        result.addStatement("$L = false", varargMatched);
        result.addStatement("break");
        result.endControlFlow();

        result.endControlFlow();
        result.beginControlFlow("if ($L)", varargMatched);
        paramVariablesStack.push(varargVariable);

  public void testGetEmpty() {
    Collection<V> result = multimap().get(k3());
    assertEmpty(result);
    assertEquals(0, result.size());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testGetNonEmpty() {
    Collection<V> result = multimap().get(k0());
    assertFalse(result.isEmpty());
    assertContentsAnyOrder(result, v0());
  }

  @CollectionSize.Require(SEVERAL)

        val resolver = tracingCodeResolver()
        val result = schema.resolve(
            """
            f(0) // must be an unresolved property x
            """.trimIndent(),
            resolver
        )

        val call = result.additions.single().dataObject.originElement as FunctionCall
        assertIs<ObjectOrigin.FunctionOrigin>(resolver.trace.expressionResolution(call).result)

    assertThat(ComparisonChain.start().compareFalseFirst(true, true).result()).isEqualTo(0);
    assertThat(ComparisonChain.start().compareFalseFirst(true, false).result()).isGreaterThan(0);
    assertThat(ComparisonChain.start().compareFalseFirst(false, true).result()).isLessThan(0);
    assertThat(ComparisonChain.start().compareFalseFirst(false, false).result()).isEqualTo(0);
  }

  public void testCompareTrueFirst() {