def convertStringToWords() {
        expect:
        toWords(null) == null
        toWords("") == ""
        toWords("word") == "word"
        toWords("twoWords") == "two words"
        toWords("TwoWords") == "two words"
        toWords("two words") == "two words"
        toWords("Two Words") == "two words"
        toWords(" Two  \t words\n") == "two words"
        toWords("two_words") == "two words"

        }
        return toWords(string, '_').toUpperCase(Locale.ROOT);
    }

    /**
     * Converts an arbitrary string to space-separated words. Eg, camelCase -> camel case, with_underscores -> with underscores
     */
    public static String toWords(CharSequence string) {
        return toWords(string, ' ');
    }

    public static String toWords(CharSequence string, char separator) {

import org.gradle.util.internal.GUtil;

public enum ArtifactType {
    SOURCES, JAVADOC, IVY_DESCRIPTOR, MAVEN_POM;

    @Override
    public String toString() {
        return "'" + GUtil.toWords(name()) + "' artifacts";
    }

        if (string == null) {
            return null;
        }
        return toWords(string, '_').toUpperCase();
    }

    /**
     * Converts an arbitrary string to space-separated words. Eg, camelCase -> camel case, with_underscores -> with underscores
     */
    public static String toWords(CharSequence string) {
        return toWords(string, ' ');
    }

    @SuppressWarnings("StringCaseLocaleUsage")

        this.name = name;

        // Might not always want Test type here?
        this.testTask = tasks.register(name, Test.class, t -> {
            t.setDescription("Runs the " + GUtil.toWords(name) + " suite.");
            t.setGroup(JavaBasePlugin.VERIFICATION_GROUP);
        });
        this.taskDependencyFactory = taskDependencyFactory;
    }

    @Override
    public String getName() {

        return linkage;
    }

    @Override
    public ModuleVersionIdentifier getCoordinates() {
        return DefaultModuleVersionIdentifier.newId(group.get(), baseName.get() + "_" + GUtil.toWords(name, '_'), version.get());
    }

    @Override
    public Set<? extends UsageContext> getUsages() {
        return variants;
    }

    @Override
    public String getName() {
        return name;

    String getPluginName() {
        def matcher = Pattern.compile("(\\w+)Plugin(GoodBehaviour)?(Integ(ration)?)?Test").matcher(getClass().simpleName)
        if (matcher.matches()) {
            return GUtil.toWords(matcher.group(1), (char) '-')
        }
        throw new UnsupportedOperationException("Cannot determine plugin id from class name '${getClass().simpleName}.")
    }

    String getQualifiedPluginId() {

                variants.put(property.getName(), property.getPropertyValue(binary));
            }
        }

        for (Map.Entry<String, Object> variant : variants.entrySet()) {
            String variantName = GUtil.toWords(variant.getKey());
            builder.item(variantName, RendererUtils.displayValueOf(variant.getValue()));
        }
    }

    protected void renderDetails(T binary, TextReportBuilder builder) {
    }

        failure.assertHasDescription("A problem occurred configuring root project '${testDirectory.name}'.")
        failure.assertHasCause("A target machine needs to be specified for the ${GUtil.toWords(componentUnderTestDsl, (char) ' ')}.")
    }

    @ToBeFixedForConfigurationCache
    def "can build for current machine when multiple target machines are specified"() {
        given:
        makeSingleProject()

        return new File(baseDir, getOutputDirectoryBase(outputType));
    }

    @Override
    public String getDescription() {
        StringBuilder builder = new StringBuilder();
        builder.append(GUtil.toWords(binaryType));
        builder.append(" '");
        List<String> elements = new ArrayList<>();
        elements.add(parentName);
        if (binaryName != null) {
            elements.add(binaryName);