Java 类org.apache.tools.ant.taskdefs.Echo 实例源码

private Target extracted(Project p) {

        Target target = new Target() {
            //          @Override
            //          public Project getProject() {
            //              return p;
            //          }
        };
        target.setProject(p);

        target.setName("Hello build");
        target.setDescription("Runtime Adding Target");

        Echo echo = new Echo();
        echo.setMessage("Hello ant build");
        echo.setProject(p);
        target.addTask(echo);
        return target;
    }

public Echo getEchoTask() {
    Project project = new Project();
    project.setName("testProject");

    Target target = new Target();
    target.setName("testTarget");
    target.setProject(project);

    Echo.EchoLevel level = new Echo.EchoLevel();
    level.setValue("error");
    Echo echoTask = new Echo();
    echoTask.setOwningTarget(target);
    echoTask.setLevel(level);
    echoTask.setTaskName("echo");
    echoTask.setTaskType("echo");
    echoTask.setMessage("This is a sample message.");

    return echoTask;
}

public void execute() {
    Project project = getProject();
    String buildoptions = project.getProperty("buildoptions");
    Pattern p = Pattern.compile("\\s");
    String[] commands = p.split(buildoptions);
    for(int i=0; i<commands.length; i++){
        project.setProperty("command"+i,commands[i]);
        Echo echo = (Echo) project.createTask("echo");
        echo.setMessage("command"+i+": "+commands[i]);
        echo.perform();     
    }
    project.setProperty("numberofcommands",""+commands.length);
}

private void appendDeliveryList(String msg) {
    Echo echo = (Echo) getProject().createTask("echo");
    echo.setOwningTarget(getOwningTarget());
    echo.init();
    echo.setFile(deliveryList);
    echo.setMessage(msg + "\n");
    echo.setAppend(true);
    echo.perform();
}

@Test
public void testPlainTask() {
    buildRule.executeTarget("testPlainTask");
    Echo e = (Echo) buildRule.getProject().getReference("echo");
    assertFalse(e.getLocation() == Location.UNKNOWN_LOCATION);
    assertFalse(e.getLocation().getLineNumber() == 0);
}

@Test
public void testStandaloneType() {
    buildRule.executeTarget("testStandaloneType");
    Echo e = (Echo) buildRule.getProject().getReference("echo2");
    FileSet f = (FileSet) buildRule.getProject().getReference("fs");
    assertFalse(f.getLocation() == Location.UNKNOWN_LOCATION);
    assertEquals(e.getLocation().getLineNumber() + 1,
                 f.getLocation().getLineNumber());
}

@Test
public void testMacrodefWrappedTask() {
    buildRule.executeTarget("testMacrodefWrappedTask");
    Echo e = (Echo) buildRule.getProject().getReference("echo3");
    assertTrue(buildRule.getLog().indexOf("Line: "
                                + (e.getLocation().getLineNumber() + 1))
               > -1);
}

@Test
public void testPresetdefWrappedTask() {
    buildRule.executeTarget("testPresetdefWrappedTask");
    Echo e = (Echo) buildRule.getProject().getReference("echo4");
    assertTrue(buildRule.getLog().indexOf("Line: "
                                + (e.getLocation().getLineNumber() + 1))
               > -1);
}

public static void writeTextToFile(String text, File file) {
        ensureParentFolderExists(file);

        Echo echo = new Echo();
        echo.setProject(new Project());
        echo.addText(text);
        echo.setFile(file);
        echo.execute();
}

public void testNumberCriteria() throws Exception {
    Echo echoTask = getEchoTask();
    BuildEvent event = new BuildEvent(echoTask);
    event.setMessage("Population completed with 2 errors.", Project.MSG_INFO);

    ReportParseCriteria criteria = new ReportParseCriteria();

    // Verify that the regular expression parsing can find the match
    criteria.setText("with [1-9] errors");
    assertEquals(true, criteria.matches(event));

    // Verify that the regular expression does not produce false matches
    event.setMessage("Population completed with no errors.", Project.MSG_INFO);
    assertEquals(false, criteria.matches(event));
}

public void testJavadocCriteria() throws Exception {
    Echo echoTask = getEchoTask();
    BuildEvent event = new BuildEvent(echoTask);
    event.setMessage("/path/SomeFile.java:28: warning - Tag @link: reference not found: com.xyz.SomeClass", Project.MSG_INFO);

    ReportParseCriteria criteria = new ReportParseCriteria();

    // Verify that the regular expression parsing can find the match
    criteria.setText(": warning -");
    assertEquals(true, criteria.matches(event));

    // Verify that the regular expression does not produce false matches
    event.setMessage("This is a false error: some error", Project.MSG_INFO);
    assertEquals(false, criteria.matches(event));
}

/**
 * Processes a list of references, check references names and output to a file if requested.
 *
 * @param refList The list of references to process
 */
protected void processReferencesAndOutput(List<Ref> refList) {
        List<String> refNames = new ArrayList<String>(refList.size());

        for (Ref ref : refList) {
                refNames.add(GitTaskUtils.sanitizeRefName(ref.getName()));
        }

        if (!namesToCheck.isEmpty()) {
                if (!refNames.containsAll(namesToCheck)) {
                        List<String> namesCopy = new ArrayList<String>(namesToCheck);
                        namesCopy.removeAll(refNames);

                        throw new GitBuildException(String.format(MISSING_REFS_TEMPLATE, namesCopy.toString()));
                }
        }

        if (!GitTaskUtils.isNullOrBlankString(outputFilename)) {
                FileUtils fileUtils = FileUtils.getFileUtils();

                Echo echo = new Echo();
                echo.setProject(getProject());
                echo.setFile(fileUtils.resolveFile(getProject().getBaseDir(), outputFilename));

                for (int i = 0; i < refNames.size(); i++) {
                        String refName = refNames.get(i);
                        echo.addText(String.format(REF_NAME_TEMPLATE, refName));
                }

                echo.perform();
        }
}

public void execute() {
    Project project = getProject();

    String currentdir = project.getProperty("currentdir");
    String generatedir = project.getProperty("generate-dir");
    String webcontentdir = project.getProperty("webcontentdir");

    StringBuilder classpathFile = new StringBuilder();
    classpathFile.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
    classpathFile.append("<classpath>\n");
    classpathFile.append("\t<classpathentry kind=\"src\" path=\".servletapp/src-template\"/>\n");
    classpathFile.append("\t<classpathentry kind=\"src\" path=\".servletapp/src-generated\"/>\n");
    classpathFile.append("\t<classpathentry kind=\"src\" path=\"nativejava\"/>\n");
    classpathFile.append("\t<classpathentry kind=\"con\" path=\"org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6\"/>\n");
    classpathFile.append("\t<classpathentry kind=\"con\" path=\"org.eclipse.jst.j2ee.internal.web.container\"/>\n");
    classpathFile.append("\t<classpathentry kind=\"con\" path=\"org.eclipse.jst.j2ee.internal.module.container\"/>\n");
    classpathFile.append("\t<classpathentry kind=\"output\" path=\"").append(generatedir).append("/WEB-INF/classes\"/>\n"); //must use relative path here

    String filedir = webcontentdir+"/WEB-INF/lib"; //must use absolute path here
    File appdir = new File(filedir);
    Echo echo = (Echo) project.createTask("echo");
    echo.setMessage(filedir);
    echo.perform();
    File[] libfiles = appdir.listFiles();
    for (int i = 0 ; i < libfiles.length ; i ++ ) {
        if ( libfiles[i].isFile ( ) ){
            classpathFile.append("\t<classpathentry kind=\"lib\" path=\"").append(generatedir).append("/WEB-INF/lib/").append(libfiles[i].getName()).append("\"/>\n"); //must use relative path here
        }
    }
    classpathFile.append("</classpath>\n");

    try {
        //write result
        FileWriter fw = new FileWriter(currentdir+"/.classpath");
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write(classpathFile.toString());
        bw.close();
        fw.close();
    } catch (Exception e) {
        Echo ec = (Echo) project.createTask("echo");
        ec.setMessage(e.getMessage());
        ec.perform();
    }
}

public void addNested(Echo nestedEcho) {
    this.nestedEcho = nestedEcho;
}

public static void main(String[] args) {
    // global ant project settings
    Project project = new Project();
    project.setBaseDir(new File(System.getProperty("user.dir")));
    project.init();
    DefaultLogger logger = new DefaultLogger();
    project.addBuildListener(logger);
    logger.setOutputPrintStream(System.out);
    logger.setErrorPrintStream(System.err);
    logger.setMessageOutputLevel(Project.MSG_INFO);
    System.setOut(new PrintStream(new DemuxOutputStream(project, false)));
    System.setErr(new PrintStream(new DemuxOutputStream(project, true)));
    project.fireBuildStarted();

    Throwable caught = null;
    try {
        // an echo example
        Echo echo = new Echo();
        echo.setTaskName("Echo");
        echo.setProject(project);
        echo.init();
        echo.setMessage("Launching ...");
        echo.execute();


        /** initialize an java task **/
        Java javaTask = new Java();
        javaTask.setNewenvironment(true);
        javaTask.setTaskName("runjava");
        javaTask.setProject(project);
        javaTask.setFork(true);
        javaTask.setFailonerror(true);
        javaTask.setClassname(MyClassToLaunch.class.getName());

        // add some vm args
        Argument jvmArgs = javaTask.createJvmarg();
        jvmArgs.setLine("-Xms512m -Xmx512m");

        // added some args for to class to launch
        Argument taskArgs = javaTask.createArg();
        taskArgs.setLine("bla path=/tmp/");

        Path classPath = new Path(project, new File(System.getProperty("user.dir") + "/bin/test").getAbsolutePath());
        javaTask.setClasspath(classPath);

        javaTask.init();
        int ret = javaTask.executeJava();
        System.out.println("return code: " + ret);

    } catch (BuildException e) {
        caught = e;
    }
    project.log("finished");
    project.fireBuildFinished(caught);
}

public void execute() {
    // Make sure we have all the required fields set.
    if (outFile == null) {
        throw new BuildException("The outFile attribute is required");
    }


    // First, populate all of the properties we care about for this task.
    if (getProject().getProperty("ant.build.native.toolchain") != null) {
        this.setToolchain(getProject().getProperty("ant.build.native.toolchain"));
    }

    if (getProject().getProperty("ant.build.native.host") != null) {
        this.setHost(getProject().getProperty("ant.build.native.host"));
    }


    // Setup the compiler.
    LinkerAdapter linker = ToolchainFactory.getLinker(toolchain);
    linker.setProject(getProject());
    linker.setOutFile(outFile);

    if (host != null && host.length() > 0) {
        // Prepend the host string to the executable.
        linker.setExecutable(host + '-' + linker.getExecutable());
    }

    for (AbstractFeature feat : features) {
        if (feat.isIfConditionValid() && feat.isUnlessConditionValid()) {
            linker.addArg(feat);
        }
    }

    long newest = 0;
    Iterator<File> inFile = linker.getInFiles();
    while (inFile.hasNext()) {
        long modified = inFile.next().lastModified();

        if (newest < modified) {
            newest = modified;
        }
    }

    if (newest >= outFile.lastModified()) {
        // Print the executed command.
        Echo echo = (Echo) getProject().createTask("echo");
        echo.setTaskName(this.getTaskName());
        echo.setAppend(true);

        // Create an exec task to run a shell.  Using the current shell to
        // execute commands is required for Windows support.
        ExecTask shell = (ExecTask) getProject().createTask("exec");
        shell.setTaskName(this.getTaskName());
        shell.setFailonerror(true);
        //shell.setDir(dir);

        echo.addText(linker.getExecutable());
        shell.setExecutable(linker.getExecutable());

        Iterator<String> args = linker.getArgs();
        while (args.hasNext()) {
            String arg = args.next();

            echo.addText(" " + arg);
            shell.createArg().setLine(arg);
        }

        echo.execute();
        shell.execute();
    }
}

@Override
public void execute() throws BuildException {
    // Set the command to execute along with any required arguments.
    StringBuilder command = new StringBuilder(AutoreconfTask.cmd);

    // Take care of the optional arguments.
    if (!this.quiet) {
        command.append(" --verbose");
    }

    if (this.force) {
        command.append(" --force");
    }

    if (this.install) {
        command.append(" --install");
    }

    // Include arguments for nested Include.
    Iterator<AutoreconfTask.Include> iterator = includes.iterator();
    while (iterator.hasNext()) {
        AutoreconfTask.Include include = iterator.next();

        if (include.isIfConditionValid() && include.isUnlessConditionValid()) {
            if (include.isPrepend()) {
                command.append(" -B").append(include.getPath());
            }
            else {
                command.append(" -I").append(include.getPath());
            }
        }
    }

    // Print the executed command.
    Echo echo = (Echo) getProject().createTask("echo");
    echo.addText(command.toString());
    echo.setTaskName(this.getTaskName());
    echo.execute();

    // Create an exec task to run a shell.  Using the current shell to
    // execute commands is required for Windows support.
    ExecTask shell = (ExecTask) getProject().createTask("exec");
    shell.setTaskName(this.getTaskName());

    shell.setDir(dir);
    shell.setExecutable("sh");
    shell.setFailonerror(true);

    shell.createArg().setValue("-c");
    shell.createArg().setValue(command.toString());

    shell.execute();
}

/**
 * Changes the current log level.
 * 
 * @param level the current log level
 */
public void setLevel(Echo.EchoLevel level) {
    this.logLevel = level.getLevel();
}