repos.mavenLocal();
        }
        repos.mavenCentral();

        String luceneVersion = VersionProperties.getLucene();
        if (luceneVersion.contains("-snapshot")) {
            // extract the revision number from the version with a regex matcher
            Matcher matcher = LUCENE_SNAPSHOT_REGEX.matcher(luceneVersion);
            if (matcher.find() == false) {

        while (true) {
            current++;
            if (current > endPort) {
                current = startPort;
            }
            int candidate = current;
            if (allocated.contains(candidate) == false && portDetector.isAvailable(candidate)) {
                allocated.add(candidate);
                return candidate;
            } else {
                if (current == first) {

        String body = response.getBody().asString();
        assertTrue(body != null, "CSV response should not be null");
        // CSV should contain the test data
        assertTrue(body.contains(NAME_PREFIX) || body.isEmpty(), "CSV should contain test data or be empty");
    }

    @Test
    void testUploadCsv_ok() {
        // Create CSV content

                sourceSet.getCompileOnlyConfigurationName(),
                sourceSet.getRuntimeOnlyConfigurationName()
        );

        project.getConfigurations().matching(c -> sourceSetConfigurationNames.contains(c.getName()))
                .configureEach(GradleUtils::disableTransitiveDependencies);
     }

    /**
     * Adds compiler settings to the project
     */

      for (int i = 0; i < startIndex; i++) {
        previousElements.push(nextElements.pop());
      }
    }

    @Override
    public void add(E e) {
      if (!features.contains(IteratorFeature.SUPPORTS_ADD)) {
        throw PermittedMetaException.UOE;
      }

      previousElements.push(e);
      stackWithLastReturnedElementAtTop = null;
    }

    @Override

                if (contentFieldNameSet.contains(name)) {
                    if (sb.length() > 0) {
                        sb.append(TEXT_SEP);
                    }
                    sb.append(searchFieldLog.getSecond());
                    fields.add(name);
                } else if (tagFieldNameSet.contains(name)) {
                    tags.add(searchFieldLog.getSecond());

    override fun shouldInclude(taskPath: String): Boolean {
        // https://github.com/gradle/gradle/issues/21351
        return super.shouldInclude(taskPath) || taskPath.contains("detekt")
    }

    override fun action(taskPath: String, taskResult: TaskOperationResult) {
        if (taskResult is TaskFailureResult) {
            failedTaskPaths.add(taskPath)
        }
    }

        Matcher matcher = linkPattern.matcher(line);
        while (matcher.find()) {
            MatchResult xrefMatcher = matcher.toMatchResult();
            String link = xrefMatcher.group(1);
            if (link.contains("#")) {
                Matcher linkMatcher = linkWithHashPattern.matcher(link);
                if (linkMatcher.matches()) {
                    MatchResult result = linkMatcher.toMatchResult();

        /* Allow for this test running across midnight */
        Set<String> expected = new HashSet<>(Arrays.asList(dateBefore, dateAfter));
        assertTrue(expected.contains(datePart), "Expected " + datePart + " to be in " + expected);
    }

    @Test
    void buildNumberNotSet() {
        RemoteSnapshotMetadata metadata =

        // Act
        String result = trans.toString();

        // Assert
        assertNotNull(result);
        assertTrue(result.contains("TransTransactNamedPipe"));
        assertTrue(result.contains("pipeFid=" + TEST_FID));
    }

    @Test
    @DisplayName("Test with null data array")
    void testWithNullData() {
        // Arrange & Act