if (minutes > 0 || result.length() > 0) {
            result.append(minutes);
            result.append("m");
        }
        int secondsScale = result.length() > 0 ? 2 : 3;
        result.append(BigDecimal.valueOf(duration).divide(BigDecimal.valueOf(MILLIS_PER_SECOND)).setScale(secondsScale, RoundingMode.HALF_UP));
        result.append("s");
        return result.toString();
    }

        String url;
        String result;

        url = "http://foo.com";
        result = "http://www.foo.com";
        assertEquals(result, duplicateHostHelper.convert(url));

        url = "http://foo.com/";
        result = "http://www.foo.com/";
        assertEquals(result, duplicateHostHelper.convert(url));

        url = "http://foo.com:8080/";
        result = "http://www.foo.com:8080/";

    @Override
    public Result execute(BuildController controller) {
        Result result = new Result();

        GradleBuild buildModel = controller.getBuildModel();
        result.rootBuild = buildModel;
        result.rootIdeaProject = controller.getModel(IdeaProject.class);

        collectAllNestedBuilds(buildModel, controller, result);

        String result = source.toLowerCase();

        // replace invalid characters
        result = ID_PATTERN.matcher(result).replaceAll("");

        // normalize separators
        result = SEPARATOR_PATTERN.matcher(result).replaceAll(PART_SEPARATOR);

        // strip separator from the end
        if (result.endsWith(PART_SEPARATOR)) {
            result = result.substring(0, result.length() - 1);
        }

        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:

        then:
        result.assertTasksNotSkipped(":adHocTask", ":executedTask")
        result.assertHasPostBuildOutput "2 actionable tasks: 2 executed"

        when:
        run "adHocTask", "executedTask"

        then:
        result.assertTaskSkipped(":adHocTask")
        result.assertTasksNotSkipped(":executedTask")
        result.assertHasPostBuildOutput "2 actionable tasks: 1 executed, 1 up-to-date"

    }

    @Override
    public <RESULT> ChildMap<RESULT> invalidate(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, InvalidationHandler<T, RESULT> handler) {
        return entry.withNode(targetPath, caseSensitivity, new AbstractInvalidateChildHandler<T, RESULT>(handler) {
            @SuppressWarnings("unchecked")
            @Override
            public SingletonChildMap<RESULT> getChildMap() {

				retval.ErrStatus.Reason = result.Result.Reason
			}
			if result.Result.Details != nil {
				retval.ErrStatus.Details = result.Result.Details
			}
			if result.Result.Code != 0 {
				retval.ErrStatus.Code = result.Result.Code
			}
		}
		return retval
	}
	return nil
}

type lazyConvertingAttributes struct {
	admission.Attributes

	convertObjectOnce    sync.Once
	convertedObject      runtime.Object

        when:
        def result = ucrtLocator.locateComponent(ucrtDir1)

        then:
        result.available
        result.component.name == "User-provided Universal C Runtime 10"
        result.component.baseDir == ucrtDir1
        result.component.version == VersionNumber.withPatchNumber().parse("10.0.10150.1")

        when:
        result = ucrtLocator.locateComponent(ucrtDir2)

        then:

  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)