testCoverage: TestCoverage,
        parallelization: (Int) -> ParallelizationMethod,
    ): List<SmallSubprojectBucket> {
        // splitIntoBuckets() method expects us to split large element into N elements,
        // but we want to have a single bucket with N batches.
        // As a workaround, we repeat the bucket N times, and deduplicate the result at the end

        Pattern pattern = Pattern.compile(wrongPattern);

        // Without escaping, "application/xhtml+xml" does NOT match
        // because the pattern expects "one or more 'l'" followed by "xml"
        assertFalse(pattern.matcher("application/xhtml+xml").matches());
        assertFalse(pattern.matcher("application/rdf+xml").matches());
    }

    @Test

import spock.lang.Specification

class PreparePatchReleaseTest extends Specification {

    def "patch version is correctly bumped"() {
        expect:
        ReleasedVersionsHelperKt.bumpPatchVersion(input) == expected

        where:
        input   | expected
        "9.4.0" | "9.4.1"
        "9.4.1" | "9.4.2"
        "8.0.0" | "8.0.1"
        "1.2.3" | "1.2.4"
    }

        def snapshot = snapshot('4.3')
        def rc = releasedVersion('4.3-rc-1')
        def versions = releasedVersions(snapshot, rc, [])
        def version = new ReleasedVersion('4.2', '20170913122310+0000')

        expect:
        ReleasedVersionsHelperKt.updateReleasedVersions(version, versions) == releasedVersions(snapshot, rc, [version])
    }

    def "final releases are sorted by version"() {
        def snapshot = snapshot('4.3')

Symmetrically, the same problem exists on the side of Gradle maintainers.
It should be clear when introducing a property what contract users can expect and what we can afford to provide.
As features progress through the lifecycle of stabilization and, possibly later, deprecation, the corresponding properties can also adjust accordingly.

    protected void assertEquals(String message, Object expected, Object actual) {
        Assertions.assertEquals(expected, actual, message);
    }

    // assertEquals - JUnit 4 style (message first) - int version
    protected void assertEquals(String message, int expected, int actual) {
        Assertions.assertEquals(expected, actual, message);
    }

    // assertSame - JUnit 5 style (no message)

    }

    def "#member change should not be reported"() {
        expect:
        noViolation(rule)

        where:
        member << [Mock(JApiMethod), Mock(JApiField), Mock(JApiImplementedInterface), Mock(JApiConstructor)]
    }

    def "nothing should be reported if no changes"() {
        expect:
        noViolation(rule)
    }

A pull request is not a finished product—it is the start of a conversation, and an implied contract: we promise to provide thoughtful feedback, and we expect the contributor to engage with us in return.

## What we expect from contributors

 *  @author Victor Jonsson, http://victorjonsson.se
 *  @license MIT
 */

**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

**Expected behavior**
A clear and concise description of what you expected to happen.

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Environment (please complete the following information):**
 - OS: [e.g. Windows 10]