Java Doc for JUnitTask.java in  » Build » ANT » org » apache » tools » ant » taskdefs » optional » junit » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Build » ANT » org.apache.tools.ant.taskdefs.optional.junit 
Source Cross Reference  Class Diagram Java Document (Java Doc) 


org.apache.tools.ant.Task
   org.apache.tools.ant.taskdefs.optional.junit.JUnitTask

JUnitTask
public class JUnitTask extends Task (Code)
Runs JUnit tests.

JUnit is a framework to create unit tests. It has been initially created by Erich Gamma and Kent Beck. JUnit can be found at http://www.junit.org.

JUnitTask can run a single specific JUnitTest using the test element.

For example, the following target
 <target name="test-int-chars" depends="jar-test">
 <echo message="testing international characters"/>
 <junit printsummary="no" haltonfailure="yes" fork="false">
 <classpath refid="classpath"/>
 <formatter type="plain" usefile="false" />
 <test name="org.apache.ecs.InternationalCharTest" />
 </junit>
 </target>
 

runs a single junit test (org.apache.ecs.InternationalCharTest) in the current VM using the path with id classpath as classpath and presents the results formatted using the standard plain formatter on the command line.

This task can also run batches of tests. The batchtest element creates a BatchTest based on a fileset. This allows, for example, all classes found in directory to be run as testcases.

For example,

 <target name="run-tests" depends="dump-info,compile-tests" if="junit.present">
 <junit printsummary="no" haltonfailure="yes" fork="${junit.fork}">
 <jvmarg value="-classic"/>
 <classpath refid="tests-classpath"/>
 <sysproperty key="build.tests" value="${build.tests}"/>
 <formatter type="brief" usefile="false" />
 <batchtest>
 <fileset dir="${tests.dir}">
 <include name="**/*Test*" />
 </fileset>
 </batchtest>
 </junit>
 </target>
 

this target finds any classes with a test directory anywhere in their path (under the top ${tests.dir}, of course) and creates JUnitTest's for each one.

Of course, <junit> and <batch> elements can be combined for more complex tests. For an example, see the ant build.xml target run-tests (the second example is an edited version).

To spawn a new Java VM to prevent interferences between different testcases, you need to enable fork. A number of attributes and elements allow you to set up how this JVM runs.
since:
   Ant 1.2
See Also:   JUnitTest
See Also:   BatchTest


Inner Class :public static class SummaryAttribute extends EnumeratedAttribute
Inner Class :final public static class ForkMode extends EnumeratedAttribute
Inner Class :protected class TestResultHolder
Inner Class :protected static class JUnitLogOutputStream extends LogOutputStream
Inner Class :protected static class JUnitLogStreamHandler extends PumpStreamHandler

Field Summary
final public static  StringTESTLISTENER_PREFIX
    

Constructor Summary
public  JUnitTask()
     Creates a new JUnitRunner and enables fork of a new Java VM.

Method Summary
protected  voidactOnTestResult(int exitValue, boolean wasKilled, JUnitTest test, String name)
     Logs information about failed tests, potentially stops processing (by throwing a BuildException) if a failure/error occurred or sets a property.
protected  voidactOnTestResult(TestResultHolder result, JUnitTest test, String name)
     Logs information about failed tests, potentially stops processing (by throwing a BuildException) if a failure/error occurred or sets a property.
public  voidaddAssertions(Assertions asserts)
    
protected  booleanaddClasspathEntry(String resource)
     Search for the given resource and add the directory or archive that contains it to the classpath.
public  voidaddConfiguredSysproperty(Environment.Variable sysp)
     Adds a system property that tests can access.
public  voidaddEnv(Environment.Variable var)
     Adds an environment variable; used when forking.
public  voidaddFormatter(FormatterElement fe)
     Add a new formatter to all tests of this task.
public  voidaddSysproperty(Environment.Variable sysp)
     Adds a system property that tests can access.
public  voidaddSyspropertyset(PropertySet sysp)
     Adds a set of properties that will be used as system properties that tests can access.
public  voidaddTest(JUnitTest test)
     Add a new single testcase.
protected  EnumerationallTests()
    
public  BatchTestcreateBatchTest()
     Adds a set of tests based on pattern matching.
public  PathcreateBootclasspath()
     Adds a path to the bootclasspath.
public  PathcreateClasspath()
     Adds path to classpath used for tests.
public  Commandline.ArgumentcreateJvmarg()
     Adds a JVM argument; ignored if not forking.
public  PermissionscreatePermissions()
     Sets the permissions for the application run inside the same JVM.
protected  ExecuteWatchdogcreateWatchdog()
    
public  voidexecute()
     Runs the testcase.
protected  voidexecute(JUnitTest arg)
     Run the tests.
protected  voidexecute(List tests)
     Execute a list of tests in a single forked Java VM.
protected  CollectionexecuteOrQueue(Enumeration testList, boolean runIndividual)
     Executes all tests that don't need to be forked (or all tests if the runIndividual argument is true.
protected  CommandlineJavagetCommandline()
     Get the command line used to run the tests.
protected  OutputStreamgetDefaultOutput()
     Get the default output for a formatter.
protected  EnumerationgetIndividualTests()
     Merge all individual tests from the batchtest with all individual tests and return an enumeration over all JUnitTest.
protected  FilegetOutput(FormatterElement fe, JUnitTest test)
     If the formatter sends output to a file, return that file.
public  voidhandleErrorFlush(String output)
     Pass output sent to System.err to the TestRunner so it can collect it for the formatters.
public  voidhandleErrorOutput(String output)
     Pass output sent to System.err to the TestRunner so it can collect it for the formatters.
protected  voidhandleFlush(String output)
     Pass output sent to System.out to the TestRunner so it can collect ot for the formatters.
protected  inthandleInput(byte[] buffer, int offset, int length)
     Handle an input request by this task.
See Also:   Task.handleInput(byte[]intint)
See Also:   This implementation delegates to a runner if it
See Also:   present.
Parameters:
  buffer - the buffer into which data is to be read.
Parameters:
  offset - the offset into the buffer at which data is stored.
Parameters:
  length - the amount of data to read.
protected  voidhandleOutput(String output)
     Pass output sent to System.out to the TestRunner so it can collect ot for the formatters.
public  voidinit()
     Adds the jars or directories containing Ant, this task and JUnit to the classpath - this should make the forked JVM work without having to specify them directly.
public  voidsetCloneVm(boolean cloneVm)
     If set, system properties will be copied to the cloned VM - as well as the bootclasspath unless you have explicitly specified a bootclaspath.
public  voidsetDir(File dir)
     The directory to invoke the VM in.
public  voidsetErrorProperty(String propertyName)
     Property to set to "true" if there is a error in a test.
public  voidsetFailureProperty(String propertyName)
     Property to set to "true" if there is a failure in a test.
public  voidsetFiltertrace(boolean value)
     If true, smartly filter the stack frames of JUnit errors and failures before reporting them.
public  voidsetFork(boolean value)
     If true, JVM should be forked for each test.

It avoids interference between testcases and possibly avoids hanging the build.

public  voidsetForkMode(ForkMode mode)
     Set the behavior when JUnitTask.setFork fork fork has been enabled.

Possible values are "once", "perTest" and "perBatch".

public  voidsetHaltonerror(boolean value)
     If true, stop the build process when there is an error in a test.
public  voidsetHaltonfailure(boolean value)
     If true, stop the build process if a test fails (errors are considered failures as well).
public  voidsetIncludeantruntime(boolean b)
     If true, include ant.jar, optional.jar and junit.jar in the forked VM.
public  voidsetJvm(String value)
     The command used to invoke the Java Virtual Machine, default is 'java'.
public  voidsetMaxmemory(String max)
     Set the maximum memory to be used by all forked JVMs.
public  voidsetNewenvironment(boolean newenv)
     If true, use a new environment when forked.
public  voidsetOutputToFormatters(boolean outputToFormatters)
     If true, send any output generated by tests to the formatters.
public  voidsetPrintsummary(SummaryAttribute value)
     If true, print one-line statistics for each test, or "withOutAndErr" to also show standard output and error.
public  voidsetReloading(boolean value)
    
public  voidsetShowOutput(boolean showOutput)
     If true, send any output generated by tests to Ant's logging system as well as to the formatters. By default only the formatters receive the output.

Output will always be passed to the formatters and not by shown by default.

public  voidsetTempdir(File tmpDir)
     Where Ant should place temporary files.
public  voidsetTimeout(Integer value)
     Set the timeout value (in milliseconds).

If the test is running for more than this value, the test will be canceled.


Field Detail
TESTLISTENER_PREFIX
final public static String TESTLISTENER_PREFIX(Code)

since:
   Ant 1.7




Constructor Detail
JUnitTask
public JUnitTask() throws Exception(Code)
Creates a new JUnitRunner and enables fork of a new Java VM.
throws:
  Exception - under ??? circumstances
since:
   Ant 1.2




Method Detail
actOnTestResult
protected void actOnTestResult(int exitValue, boolean wasKilled, JUnitTest test, String name)(Code)
Logs information about failed tests, potentially stops processing (by throwing a BuildException) if a failure/error occurred or sets a property.
Parameters:
  exitValue - the exitValue of the test.
Parameters:
  wasKilled - if true, the test had been killed.
Parameters:
  test - the test in question.
Parameters:
  name - the name of the test.
since:
   Ant 1.6.2



actOnTestResult
protected void actOnTestResult(TestResultHolder result, JUnitTest test, String name)(Code)
Logs information about failed tests, potentially stops processing (by throwing a BuildException) if a failure/error occurred or sets a property.
Parameters:
  result - the result of the test.
Parameters:
  test - the test in question.
Parameters:
  name - the name of the test.
since:
   Ant 1.7



addAssertions
public void addAssertions(Assertions asserts)(Code)
Assertions to enable in this program (if fork=true)
since:
   Ant 1.6
Parameters:
  asserts - assertion set



addClasspathEntry
protected boolean addClasspathEntry(String resource)(Code)
Search for the given resource and add the directory or archive that contains it to the classpath.

Doesn't work for archives in JDK 1.1 as the URL returned by getResource doesn't contain the name of the archive.


Parameters:
  resource - resource that one wants to lookup true if something was in fact added
since:
   Ant 1.4



addConfiguredSysproperty
public void addConfiguredSysproperty(Environment.Variable sysp)(Code)
Adds a system property that tests can access. This might be useful to tranfer Ant properties to the testcases when JVM forking is not enabled.
Parameters:
  sysp - new environment variable to add
since:
   Ant 1.6



addEnv
public void addEnv(Environment.Variable var)(Code)
Adds an environment variable; used when forking.

Will be ignored if we are not forking a new VM.


Parameters:
  var - environment variable to be added
since:
   Ant 1.5



addFormatter
public void addFormatter(FormatterElement fe)(Code)
Add a new formatter to all tests of this task.
Parameters:
  fe - formatter element
since:
   Ant 1.2



addSysproperty
public void addSysproperty(Environment.Variable sysp)(Code)
Adds a system property that tests can access. This might be useful to tranfer Ant properties to the testcases when JVM forking is not enabled.
since:
   Ant 1.3
Parameters:
  sysp - environment variable to add



addSyspropertyset
public void addSyspropertyset(PropertySet sysp)(Code)
Adds a set of properties that will be used as system properties that tests can access. This might be useful to tranfer Ant properties to the testcases when JVM forking is not enabled.
Parameters:
  sysp - set of properties to be added
since:
   Ant 1.6



addTest
public void addTest(JUnitTest test)(Code)
Add a new single testcase.
Parameters:
  test - a new single testcase
See Also:   JUnitTest
since:
   Ant 1.2



allTests
protected Enumeration allTests()(Code)
return an enumeration listing each test, then each batchtest enumeration
since:
   Ant 1.3



createBatchTest
public BatchTest createBatchTest()(Code)
Adds a set of tests based on pattern matching. a new instance of a batch test.
See Also:   BatchTest
since:
   Ant 1.2



createBootclasspath
public Path createBootclasspath()(Code)
Adds a path to the bootclasspath. reference to the bootclasspath in the embedded java command line
since:
   Ant 1.6



createClasspath
public Path createClasspath()(Code)
Adds path to classpath used for tests. reference to the classpath in the embedded java command line
since:
   Ant 1.2



createJvmarg
public Commandline.Argument createJvmarg()(Code)
Adds a JVM argument; ignored if not forking. create a new JVM argument so that any argument can bepassed to the JVM.
See Also:   JUnitTask.setFork(boolean)
since:
   Ant 1.2



createPermissions
public Permissions createPermissions()(Code)
Sets the permissions for the application run inside the same JVM.
since:
   Ant 1.6 .



createWatchdog
protected ExecuteWatchdog createWatchdog() throws BuildException(Code)
null if there is a timeout value, otherwise thewatchdog instance.
throws:
  BuildException - under unspecified circumstances
since:
   Ant 1.2



execute
public void execute() throws BuildException(Code)
Runs the testcase.
throws:
  BuildException - in case of test failures or errors
since:
   Ant 1.2



execute
protected void execute(JUnitTest arg) throws BuildException(Code)
Run the tests.
Parameters:
  arg - one JunitTest
throws:
  BuildException - in case of test failures or errors



execute
protected void execute(List tests) throws BuildException(Code)
Execute a list of tests in a single forked Java VM.
Parameters:
  tests - the list of tests to execute.
throws:
  BuildException - on error.



executeOrQueue
protected Collection executeOrQueue(Enumeration testList, boolean runIndividual)(Code)
Executes all tests that don't need to be forked (or all tests if the runIndividual argument is true. Returns a collection of lists of tests that share the same VM configuration and haven't been executed yet.
Parameters:
  testList - the list of tests to be executed or queued.
Parameters:
  runIndividual - if true execute each test individually. a list of tasks to be executed.
since:
   1.6.2



getCommandline
protected CommandlineJava getCommandline()(Code)
Get the command line used to run the tests. the command line.
since:
   Ant 1.6.2



getDefaultOutput
protected OutputStream getDefaultOutput()(Code)
Get the default output for a formatter. default output stream for a formatter
since:
   Ant 1.3



getIndividualTests
protected Enumeration getIndividualTests()(Code)
Merge all individual tests from the batchtest with all individual tests and return an enumeration over all JUnitTest. enumeration over individual tests
since:
   Ant 1.3



getOutput
protected File getOutput(FormatterElement fe, JUnitTest test)(Code)
If the formatter sends output to a file, return that file. null otherwise.
Parameters:
  fe - formatter element
Parameters:
  test - one JUnit test file reference
since:
   Ant 1.3



handleErrorFlush
public void handleErrorFlush(String output)(Code)
Pass output sent to System.err to the TestRunner so it can collect it for the formatters.
Parameters:
  output - coming from System.err
since:
   Ant 1.5.2



handleErrorOutput
public void handleErrorOutput(String output)(Code)
Pass output sent to System.err to the TestRunner so it can collect it for the formatters.
Parameters:
  output - output coming from System.err
since:
   Ant 1.5



handleFlush
protected void handleFlush(String output)(Code)
Pass output sent to System.out to the TestRunner so it can collect ot for the formatters.
Parameters:
  output - output coming from System.out
since:
   Ant 1.5.2



handleInput
protected int handleInput(byte[] buffer, int offset, int length) throws IOException(Code)
Handle an input request by this task.
See Also:   Task.handleInput(byte[]intint)
See Also:   This implementation delegates to a runner if it
See Also:   present.
Parameters:
  buffer - the buffer into which data is to be read.
Parameters:
  offset - the offset into the buffer at which data is stored.
Parameters:
  length - the amount of data to read. the number of bytes read.
exception:
  IOException - if the data cannot be read.
since:
   Ant 1.6



handleOutput
protected void handleOutput(String output)(Code)
Pass output sent to System.out to the TestRunner so it can collect ot for the formatters.
Parameters:
  output - output coming from System.out
since:
   Ant 1.5



init
public void init()(Code)
Adds the jars or directories containing Ant, this task and JUnit to the classpath - this should make the forked JVM work without having to specify them directly.
since:
   Ant 1.4



setCloneVm
public void setCloneVm(boolean cloneVm)(Code)
If set, system properties will be copied to the cloned VM - as well as the bootclasspath unless you have explicitly specified a bootclaspath.

Doesn't have any effect unless fork is true.


Parameters:
  cloneVm - a boolean value.
since:
   Ant 1.7



setDir
public void setDir(File dir)(Code)
The directory to invoke the VM in. Ignored if no JVM is forked.
Parameters:
  dir - the directory to invoke the JVM from.
See Also:   JUnitTask.setFork(boolean)
since:
   Ant 1.2



setErrorProperty
public void setErrorProperty(String propertyName)(Code)
Property to set to "true" if there is a error in a test.

This property is applied on all BatchTest (batchtest) and JUnitTest (test), however, it can possibly be overriden by their own properties.


Parameters:
  propertyName - the name of the property to set in theevent of an error.
since:
   Ant 1.4



setFailureProperty
public void setFailureProperty(String propertyName)(Code)
Property to set to "true" if there is a failure in a test.

This property is applied on all BatchTest (batchtest) and JUnitTest (test), however, it can possibly be overriden by their own properties.


Parameters:
  propertyName - the name of the property to set in theevent of an failure.
since:
   Ant 1.4



setFiltertrace
public void setFiltertrace(boolean value)(Code)
If true, smartly filter the stack frames of JUnit errors and failures before reporting them.

This property is applied on all BatchTest (batchtest) and JUnitTest (test) however it can possibly be overridden by their own properties.


Parameters:
  value - false if it should not filter, otherwisetrue
since:
   Ant 1.5



setFork
public void setFork(boolean value)(Code)
If true, JVM should be forked for each test.

It avoids interference between testcases and possibly avoids hanging the build. this property is applied on all BatchTest (batchtest) and JUnitTest (test) however it can possibly be overridden by their own properties.


Parameters:
  value - true if a JVM should be forked, otherwisefalse
See Also:   JUnitTask.setTimeout
since:
   Ant 1.2



setForkMode
public void setForkMode(ForkMode mode)(Code)
Set the behavior when JUnitTask.setFork fork fork has been enabled.

Possible values are "once", "perTest" and "perBatch". If set to "once", only a single Java VM will be forked for all tests, with "perTest" (the default) each test will run in a fresh Java VM and "perBatch" will run all tests from the same <batchtest> in the same Java VM.

This attribute will be ignored if tests run in the same VM as Ant.

Only tests with the same configuration of haltonerror, haltonfailure, errorproperty, failureproperty and filtertrace can share a forked Java VM, so even if you set the value to "once", Ant may need to fork mutliple VMs.


Parameters:
  mode - the mode to use.
since:
   Ant 1.6.2



setHaltonerror
public void setHaltonerror(boolean value)(Code)
If true, stop the build process when there is an error in a test. This property is applied on all BatchTest (batchtest) and JUnitTest (test) however it can possibly be overridden by their own properties.
Parameters:
  value - true if it should halt, otherwisefalse
since:
   Ant 1.2



setHaltonfailure
public void setHaltonfailure(boolean value)(Code)
If true, stop the build process if a test fails (errors are considered failures as well). This property is applied on all BatchTest (batchtest) and JUnitTest (test) however it can possibly be overridden by their own properties.
Parameters:
  value - true if it should halt, otherwisefalse
since:
   Ant 1.2



setIncludeantruntime
public void setIncludeantruntime(boolean b)(Code)
If true, include ant.jar, optional.jar and junit.jar in the forked VM.
Parameters:
  b - include ant run time yes or no
since:
   Ant 1.5



setJvm
public void setJvm(String value)(Code)
The command used to invoke the Java Virtual Machine, default is 'java'. The command is resolved by java.lang.Runtime.exec(). Ignored if fork is disabled.
Parameters:
  value - the new VM to use instead of java
See Also:   JUnitTask.setFork(boolean)
since:
   Ant 1.2



setMaxmemory
public void setMaxmemory(String max)(Code)
Set the maximum memory to be used by all forked JVMs.
Parameters:
  max - the value as defined by -mx or -Xmxin the java command line options.
since:
   Ant 1.2



setNewenvironment
public void setNewenvironment(boolean newenv)(Code)
If true, use a new environment when forked.

Will be ignored if we are not forking a new VM.


Parameters:
  newenv - boolean indicating if setting a new environment is wished
since:
   Ant 1.5



setOutputToFormatters
public void setOutputToFormatters(boolean outputToFormatters)(Code)
If true, send any output generated by tests to the formatters.
Parameters:
  outputToFormatters - if true, send output to formatters (Defaultis true).
since:
   Ant 1.7.0



setPrintsummary
public void setPrintsummary(SummaryAttribute value)(Code)
If true, print one-line statistics for each test, or "withOutAndErr" to also show standard output and error. Can take the values on, off, and withOutAndErr.
Parameters:
  value - true to print a summary,withOutAndErr to include the test's output aswell, false otherwise.
See Also:   SummaryJUnitResultFormatter
since:
   Ant 1.2



setReloading
public void setReloading(boolean value)(Code)
If true, force ant to re-classload all classes for each JUnit TestCase
Parameters:
  value - force class reloading for each test case



setShowOutput
public void setShowOutput(boolean showOutput)(Code)
If true, send any output generated by tests to Ant's logging system as well as to the formatters. By default only the formatters receive the output.

Output will always be passed to the formatters and not by shown by default. This option should for example be set for tests that are interactive and prompt the user to do something.


Parameters:
  showOutput - if true, send output to Ant's logging system too
since:
   Ant 1.5



setTempdir
public void setTempdir(File tmpDir)(Code)
Where Ant should place temporary files.
Parameters:
  tmpDir - location where temporary files should go to
since:
   Ant 1.6



setTimeout
public void setTimeout(Integer value)(Code)
Set the timeout value (in milliseconds).

If the test is running for more than this value, the test will be canceled. (works only when in 'fork' mode).


Parameters:
  value - the maximum time (in milliseconds) allowed beforedeclaring the test as 'timed-out'
See Also:   JUnitTask.setFork(boolean)
since:
   Ant 1.2



Fields inherited from org.apache.tools.ant.Task
protected Target target(Code)(Java Doc)
protected String taskName(Code)(Java Doc)
protected String taskType(Code)(Java Doc)
protected RuntimeConfigurable wrapper(Code)(Java Doc)

Methods inherited from org.apache.tools.ant.Task
final public void bindToOwner(Task owner)(Code)(Java Doc)
public void execute() throws BuildException(Code)(Java Doc)
public Target getOwningTarget()(Code)(Java Doc)
public RuntimeConfigurable getRuntimeConfigurableWrapper()(Code)(Java Doc)
public String getTaskName()(Code)(Java Doc)
public String getTaskType()(Code)(Java Doc)
protected RuntimeConfigurable getWrapper()(Code)(Java Doc)
protected void handleErrorFlush(String output)(Code)(Java Doc)
protected void handleErrorOutput(String output)(Code)(Java Doc)
protected void handleFlush(String output)(Code)(Java Doc)
protected int handleInput(byte[] buffer, int offset, int length) throws IOException(Code)(Java Doc)
protected void handleOutput(String output)(Code)(Java Doc)
public void init() throws BuildException(Code)(Java Doc)
final protected boolean isInvalid()(Code)(Java Doc)
public void log(String msg)(Code)(Java Doc)
public void log(String msg, int msgLevel)(Code)(Java Doc)
public void log(Throwable t, int msgLevel)(Code)(Java Doc)
public void log(String msg, Throwable t, int msgLevel)(Code)(Java Doc)
public void maybeConfigure() throws BuildException(Code)(Java Doc)
final public void perform()(Code)(Java Doc)
public void reconfigure()(Code)(Java Doc)
public void setOwningTarget(Target target)(Code)(Java Doc)
public void setRuntimeConfigurableWrapper(RuntimeConfigurable wrapper)(Code)(Java Doc)
public void setTaskName(String name)(Code)(Java Doc)
public void setTaskType(String type)(Code)(Java Doc)

www.j__a___v___a___2_s__._co__m_ | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.