import org.apache.commons.text.WordUtils

class App {
    static void main(String[] args) {
        LinkedList tokens
        tokens = split(getMessage())
        String result = join(tokens)
        println(WordUtils.capitalize(result))
    }

        """
    }

    @Override
    protected List<String> getTasksToAssembleDevelopmentBinary(String variant) {
        return [":compileDebug${variant.capitalize()}Cpp", ":createDebug${variant.capitalize()}"]
    }

    @Override
    protected String getDevelopmentBinaryCompileTask() {
        return ":compileDebugCpp"
    }

    @Override

object App {
   def main(args: Array[String]): Unit = {
        val tokens = StringUtils.split(MessageUtils.getMessage())
        val result = StringUtils.join(tokens)
        println(WordUtils.capitalize(result))
    }

            import org.apache.commons.lang3.StringUtils;

            public class PersonFixture {
                public static Person anyone() {
                    return new Person(StringUtils.capitalize("john"), StringUtils.capitalize("doe"));
                }
            }
        """
    }

    protected void dumpCompileAndRuntimeTestClasspath() {
        buildFile << """
            class Utils {

    public static Person maggie() { return MAGGIE; }

    // ...
//end::sample[]
    public static Person named(String firstName) {
        String capitalized = WordUtils.capitalizeFully(firstName);
        for (Person person : FAMILY) {
            if (capitalized.equals(person.getFirstName())) {
                return person;
            }
        }
        return null;
    }

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import gradlebuild.basics.capitalize
import gradlebuild.basics.testing.TestType
import gradlebuild.integrationtests.addDependenciesAndConfigurations
import gradlebuild.integrationtests.addSourceSet
import gradlebuild.integrationtests.configureIde

        listOf("compile", "runtime").forEach { base ->
            mapOf(6 to "android", 8 to "jre").forEach { (targetJvmVersion, jarName) ->
                context.details.addVariant("jdk$targetJvmVersion${base.capitalize()}", base) {
                    attributes {
                        attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, targetJvmVersion)
                    }
                    withFiles {

        ["compile", "runtime"].each { base ->
            [6: "android", 8: "jre"].each { targetJvmVersion, jarName ->
                context.details.addVariant("jdk$targetJvmVersion${base.capitalize()}", base) {
                    attributes {
                        attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, targetJvmVersion)
                    }
                    withFiles {

        then:
        NativeExecutableBinarySpec binary = realizeBinaries().testExecutable
        binary.tasks.withType(compileTaskClass)*.name as Set == ["compileTestExecutableTestAnotherOne", "compileTestExecutableTest${StringUtils.capitalize(pluginName)}"] as Set

        and:
        binary.tasks.withType(compileTaskClass).each { compile ->
            compile.toolChain == binary.toolChain
            compile.macros == [NDEBUG: null, LEVEL: "1"]

            String result = ""
            if (operatingSystemFamily != null) {
                result += operatingSystemFamily.toLowerCase().capitalize()
            }
            if (architecture != null) {
                result += architecture.toLowerCase().capitalize()
            }
            return result
        }
    }