Merge pull request #232 from radcortez/master

radcortez · radcortez · commit 4ede2113d7c9 · 2014-06-19T20:33:55.000+01:00
Documentation clarifications and typos.
diff --git a/batch/batch-listeners/src/test/java/org/javaee7/batch/batch/listeners/BatchListenersTest.java b/batch/batch-listeners/src/test/java/org/javaee7/batch/batch/listeners/BatchListenersTest.java
@@ -21,7 +21,7 @@
 import static org.junit.Assert.assertTrue;
 
 /**
- * The Batch specification, provides several listeners to notify about specific event ocurring during the batch
+ * The Batch specification, provides several listeners to notify about specific event occurring during the batch
  * processing execution.
  *
  * Events can be caught via extending the following classes, for the appropriate batch lifecycle event:
@@ -47,7 +47,7 @@
  * The Chunk Listener:
  * include::MyChunkListener[]
  *
- * Allows you to execude code before and after the chunk processing. Useful to setup and clear resources needed by the
+ * Allows you to execute code before and after the chunk processing. Useful to setup and clear resources needed by the
  * chunk.
  *
  * The Read Listener:
@@ -71,7 +71,10 @@
  * Useful to setup additional resources and add additional information to the object writing. You can also provide
  * some logic to  treat a failed object write.
  *
- * Remember that listeners need to be configured in the job xml file (+myjob.xml+).
+ * The +listeners+ element can be used at the +step+ level or the +job+ level to define which listeners to run for each
+ * batch processing event.
+ *
+ * include::myJob.xml[]
  *
  * @author Roberto Cortez
  */
@@ -82,10 +85,10 @@ public class BatchListenersTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * ----
      *
-     * The +myjob.xml+ file is needed for running the batch definition.
+     * The +myJob.xml+ file is needed for running the batch definition.
      */
     @Deployment
     public static WebArchive createDeployment() {
diff --git a/batch/batchlet-simple/src/test/java/org/javaee7/batch/batchlet/simple/MyBatchletTest.java b/batch/batchlet-simple/src/test/java/org/javaee7/batch/batchlet/simple/MyBatchletTest.java
@@ -75,6 +75,7 @@ public void testBatchletProcess() throws Exception {
 
         BatchTestHelper.keepTestAlive(jobExecution);
 
+        // <1> Job should be completed.
         assertEquals(jobExecution.getBatchStatus(), BatchStatus.COMPLETED);
     }
 }
diff --git a/batch/chunk-checkpoint/src/test/java/org/javaee7/batch/chunk/checkpoint/BatchChunkCheckpointTest.java b/batch/chunk-checkpoint/src/test/java/org/javaee7/batch/chunk/checkpoint/BatchChunkCheckpointTest.java
@@ -33,7 +33,7 @@
  *
  * include::myJob.xml[]
  *
- * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and writer. For
+ * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and a writer. For
  * this sample, a custom checkpoint policy is going to be used. The custom policy needs to implement
  * +javax.batch.api.chunk.CheckpointAlgorithm+ or in alternative extend
  * +javax.batch.api.chunk.AbstractCheckpointAlgorithm+ that already provides empty implementations for all methods.
@@ -52,10 +52,10 @@ public class BatchChunkCheckpointTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * ----
      *
-     * The +myjob.xml+ file is needed for running the batch definition.
+     * The +myJob.xml+ file is needed for running the batch definition.
      */
     @Deployment
     public static WebArchive createDeployment() {
diff --git a/batch/chunk-csv-database/src/test/java/org/javaee7/batch/chunk/csv/database/BatchCSVDatabaseTest.java b/batch/chunk-csv-database/src/test/java/org/javaee7/batch/chunk/csv/database/BatchCSVDatabaseTest.java
@@ -38,7 +38,7 @@
  * Process the data by transforming it into a +Person+ object:
  * include::MyItemProcessor#processItem[]
  *
- * Finally write the data using JPA to a database:
+ * And finally write the data using JPA to a database:
  * include::MyItemWriter#writeItems[]
  *
  * @author Roberto Cortez
@@ -53,14 +53,14 @@ public class BatchCSVDatabaseTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * /META-INF/persistence.xml
      * /META-INF/create.sql
-     * /META-INF/drop-sql
+     * /META-INF/drop.sql
      * /META-INF/mydata.csv
      * ----
      *
-     * * The +myjob.xml+ file is needed for running the batch definition.
+     * * The +myJob.xml+ file is needed for running the batch definition.
      * * The +persistence.xml+ file is needed for JPA configuration, create schema, load-data and drop schema.
      * * The +create.sql+ file has the necessary database schema for the data.
      * * The +drop.sql+ file has the required commands to drop the database schema created.
@@ -81,8 +81,6 @@ public static WebArchive createDeployment() {
         return war;
     }
 
-    @SuppressWarnings("unchecked")
-    @Test
     /**
      * In the test, we're just going to invoke the batch execution and wait for completion. To validate the test
      * expected behaviour we need to query the +Metric[]+ object available in the step execution.
@@ -92,6 +90,8 @@ public static WebArchive createDeployment() {
      *
      * @throws Exception an exception if the batch could not complete successfully.
      */
+    @SuppressWarnings("unchecked")
+    @Test
     public void testBatchCSVDatabase() throws Exception {
         JobOperator jobOperator = BatchRuntime.getJobOperator();
         Long executionId = jobOperator.start("myJob", new Properties());
@@ -106,7 +106,7 @@ public void testBatchCSVDatabase() throws Exception {
 
                 // <1> The read count should be 7 elements. Check +MyItemReader+.
                 assertEquals(7L, metricsMap.get(Metric.MetricType.READ_COUNT).longValue());
-                // <2> The write count should be same 7 read elements.
+                // <2> The write count should be the same 7 read elements.
                 assertEquals(7L, metricsMap.get(Metric.MetricType.WRITE_COUNT).longValue());
                 // <3> The commit count should be 4. Checkpoint is on every 3rd read, 4 commits for read elements.
                 assertEquals(3L, metricsMap.get(Metric.MetricType.COMMIT_COUNT).longValue());
diff --git a/batch/chunk-exception/src/test/java/org/javaee7/batch/chunk/exception/BatchChunkExceptionTest.java b/batch/chunk-exception/src/test/java/org/javaee7/batch/chunk/exception/BatchChunkExceptionTest.java
@@ -21,17 +21,16 @@
 import static org.junit.Assert.assertTrue;
 
 /**
- * In this sample we're going to process a few record and mix some exceptions during read, processing and write of the
- * chunk. Exceptions are a natural part of batch processing, and the batch itself should be prepared to deal with
- * exceptions during processing. These exceptions are configured in the job xml file (+myjob.xml+).
+ * Exceptions are a natural part of Batch Processing, and the batch itself should be prepared to deal with
+ * exceptions during processing.
  *
- * Batch processing deals with two kinds of exceptions: skippable and retryable. Skippable Exceptions are used to skip
+ * Batch Processing deals with two kinds of exceptions: skippable and retryable. Skippable Exceptions are used to skip
  * elements during reading, processing and writing and continue to the next element. Retryable Exceptions on the other
- * hand when thrown will try to retry the chunk on which the exceptiong occurred.
+ * hand when thrown will try to retry the chunk on which the exception occurred.
  *
- * When the same exception is specified as both retryable and skippable, retryable takes precedence over skippable during
- * regular processing of the chunk. While the chunk is retrying, skippable takes precedence over retryable since the exception
- * is already being retried.
+ * When the same exception is specified as both retryable and skippable, retryable takes precedence over skippable
+ * during regular processing of the chunk. While the chunk is retrying, skippable takes precedence over retryable since
+ * the exception is already being retried.
  *
  * The Reader:
  * include::MyItemReader[]
@@ -58,6 +57,15 @@
  * * +MyRetryProcessorListener+
  * * +MyRetryWriteListener+
  *
+ * include::myJob.xml[]
+ *
+ * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and a writer. For
+ * this sample we are going to process a few records and mix some exceptions during read, processing and write of the
+ * chunk. Batch exception handling is achieved by defining the elements +skippable-exception-classes+ and
+ * +retryable-exception-classes+ into the +chunk+. Both elements should indicate the full qualified name of the
+ * exceptions that we are trying to catch. The +listeners+ element can be used at the +step+ level to define which
+ * listeners to run for each batch processing event.
+ *
  * @author Roberto Cortez
  */
 @RunWith(Arquillian.class)
@@ -67,10 +75,10 @@ public class BatchChunkExceptionTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * ----
      *
-     * The +myjob.xml+ file is needed for running the batch definition.
+     * The +myJob.xml+ file is needed for running the batch definition.
      */
     @Deployment
     public static WebArchive createDeployment() {
diff --git a/batch/chunk-mapper/src/test/java/org/javaee7/batch/sample/chunk/mapper/BatchChunkMapperTest.java b/batch/chunk-mapper/src/test/java/org/javaee7/batch/sample/chunk/mapper/BatchChunkMapperTest.java
@@ -59,10 +59,10 @@ public class BatchChunkMapperTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * ----
      *
-     * The +myjob.xml+ file is needed for running the batch definition.
+     * The +myJob.xml+ file is needed for running the batch definition.
      */
     @Deployment
     public static WebArchive createDeployment() {
diff --git a/batch/chunk-optional-processor/src/test/java/org/javaee7/batch/chunk/optional/processor/BatchChunkOptionalProcessorTest.java b/batch/chunk-optional-processor/src/test/java/org/javaee7/batch/chunk/optional/processor/BatchChunkOptionalProcessorTest.java
@@ -38,10 +38,10 @@ public class BatchChunkOptionalProcessorTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * ----
      *
-     * The +myjob.xml+ file is needed for running the batch definition.
+     * The +myJob.xml+ file is needed for running the batch definition.
      */
     @Deployment
     public static WebArchive createDeployment() {
diff --git a/batch/chunk-partition/src/test/java/org/javaee7/batch/sample/chunk/partition/BatchChunkPartitionTest.java b/batch/chunk-partition/src/test/java/org/javaee7/batch/sample/chunk/partition/BatchChunkPartitionTest.java
@@ -54,10 +54,10 @@ public class BatchChunkPartitionTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * ----
      *
-     * The +myjob.xml+ file is needed for running the batch definition.
+     * The +myJob.xml+ file is needed for running the batch definition.
      */
     @Deployment
     public static WebArchive createDeployment() {
diff --git a/batch/chunk-simple-nobeans/src/test/java/org/javaee7/batch/samples/chunk/simple/nobeans/BatchChunkSimpleNoBeansTest.java b/batch/chunk-simple-nobeans/src/test/java/org/javaee7/batch/samples/chunk/simple/nobeans/BatchChunkSimpleNoBeansTest.java
@@ -24,7 +24,7 @@
  *
  * include::myJob.xml[]
  *
- * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and writer.
+ * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and a writer.
  *
  * @author Roberto Cortez
  */
@@ -35,10 +35,10 @@ public class BatchChunkSimpleNoBeansTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * ----
      *
-     * The +myjob.xml+ file is needed for running the batch definition. This sample is also missing the +beans.xml+ for
+     * The +myJob.xml+ file is needed for running the batch definition. This sample is also missing the +beans.xml+ for
      * CDI discovery, since for Java EE 7 this file is now optional, but you need to annotated batch dependent beans
      * with +@Dependent+.
      */
diff --git a/batch/chunk-simple/src/test/java/org/javaee7/batch/chunk/simple/ChunkSimpleTest.java b/batch/chunk-simple/src/test/java/org/javaee7/batch/chunk/simple/ChunkSimpleTest.java
@@ -26,7 +26,7 @@
  *
  * include::myJob.xml[]
  *
- * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and writer.
+ * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and a writer.
  *
  * @author Roberto Cortez
  */
@@ -37,10 +37,10 @@ public class ChunkSimpleTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * ----
      *
-     * The +myjob.xml+ file is needed for running the batch definition.
+     * The +myJob.xml+ file is needed for running the batch definition.
      */
     @Deployment
     public static WebArchive createDeployment() {
diff --git a/batch/decision/src/test/java/org/javaee7/batch/decision/BatchDecisionTest.java b/batch/decision/src/test/java/org/javaee7/batch/decision/BatchDecisionTest.java
@@ -22,7 +22,7 @@
 import static org.junit.Assert.*;
 
 /**
- * The Batch specification allows you to implement process workflows using a Job Specification Language (JSL). In this
+ * The Batch specification allows you to implement process workflow using a Job Specification Language (JSL). In this
  * sample, by using the +decision+ element, it's possible to configure a job that follows different paths of execution
  * based on your own criteria by implementing a +javax.batch.api.Decider+
  *
diff --git a/batch/flow/src/test/java/org/javaee7/batch/flow/BatchFlowTest.java b/batch/flow/src/test/java/org/javaee7/batch/flow/BatchFlowTest.java
@@ -21,14 +21,14 @@
 import static org.junit.Assert.assertEquals;
 
 /**
- * The Batch specification allows you to implement process workflows using a Job Specification Language (JSL). In this
+ * The Batch specification allows you to implement process workflow using a Job Specification Language (JSL). In this
  * sample, by using the +flow+ element, we define a sequence of elements that execute together as a unit. When the
  * flow is finished the flow transitions to the next execution element. The execution elements of a flow cannot
  * transition to elements outside the flow.
  *
  * include::myJob.xml[]
  *
- * The flow element is usefull to build self contained workflows that you can reference and build as a part of a bigger
+ * The flow element is useful to build a self contained workflow that you can reference and build as a part of a bigger
  * workflow.
  *
  * @author Roberto Cortez
diff --git a/batch/multiple-steps/src/test/java/org/javaee7/batch/multiple/steps/BatchMultipleStepsTest.java b/batch/multiple-steps/src/test/java/org/javaee7/batch/multiple/steps/BatchMultipleStepsTest.java
@@ -21,12 +21,14 @@
 import static org.junit.Assert.assertEquals;
 
 /**
- * The Batch specification allows you to implement process workflows using a Job Specification Language (JSL). In this
+ * The Batch specification allows you to implement process workflow using a Job Specification Language (JSL). In this
  * sample, by using the +step+ element, it's possible to configure a job that runs multiple steps.
  *
  * One Chunk oriented Step and a Batchlet are configured in the file +myJob.xml+. They both execute in order of
  * declaration. First the Chunk oriented Step and finally the Batchlet Step.
  *
+ * include::myJob.xml[]
+ *
  * @author Roberto Cortez
  */
 @RunWith(Arquillian.class)
@@ -36,10 +38,10 @@ public class BatchMultipleStepsTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * ----
      *
-     * The +myjob.xml+ file is needed for running the batch definition.
+     * The +myJob.xml+ file is needed for running the batch definition.
      */
     @Deployment
     public static WebArchive createDeployment() {
diff --git a/batch/split/src/test/java/org/javaee7/batch/split/BatchSplitTest.java b/batch/split/src/test/java/org/javaee7/batch/split/BatchSplitTest.java
@@ -23,15 +23,17 @@
 import static org.junit.Assert.assertTrue;
 
 /**
- * The Batch specification allows you to implement process workflows using a Job Specification Language (JSL). In this
+ * The Batch specification allows you to implement process workflow using a Job Specification Language (JSL). In this
  * sample, by using the +split+ element, it's possible to configure a job that runs parallel flows. A +split+ can only
  * contain +flow+ elements. These +flow+ elements can be used to implement separate executions to be processed by the
  * job.
  *
- * Three simple Batchlet's are configured in the file +myjob.xml+. +MyBatchlet1+ and +MyBatchlet2+ are setted up to
+ * Three simple Batchlet's are configured in the file +myJob.xml+. +MyBatchlet1+ and +MyBatchlet2+ are setted up to
  * execute in parallel by using the +split+ and +flow+ elements. +MyBatchlet3+ is only going to execute after
  * +MyBatchlet1+ and +MyBatchlet2+ are both done with their job.
  *
+ * include::myJob.xml[]
+ *
  * @author Roberto Cortez
  */
 @RunWith(Arquillian.class)
@@ -41,10 +43,10 @@ public class BatchSplitTest {
      *
      * [source,file]
      * ----
-     * /META-INF/batch-jobs/myjob.xml
+     * /META-INF/batch-jobs/myJob.xml
      * ----
      *
-     * The +myjob.xml+ file is needed for running the batch definition.
+     * The +myJob.xml+ file is needed for running the batch definition.
      */
     @Deployment
     public static WebArchive createDeployment() {

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@`
`21`	`21`	`import static org.junit.Assert.assertTrue;`
`22`	`22`
`23`	`23`	`/**`
`24`		`- * The Batch specification, provides several listeners to notify about specific event ocurring during the batch`
	`24`	`+ * The Batch specification, provides several listeners to notify about specific event occurring during the batch`
`25`	`25`	`* processing execution.`
`26`	`26`	`*`
`27`	`27`	`* Events can be caught via extending the following classes, for the appropriate batch lifecycle event:`
`@@ -47,7 +47,7 @@`
`47`	`47`	`* The Chunk Listener:`
`48`	`48`	`* include::MyChunkListener[]`
`49`	`49`	`*`
`50`		`- * Allows you to execude code before and after the chunk processing. Useful to setup and clear resources needed by the`
	`50`	`+ * Allows you to execute code before and after the chunk processing. Useful to setup and clear resources needed by the`
`51`	`51`	`* chunk.`
`52`	`52`	`*`
`53`	`53`	`* The Read Listener:`
`@@ -71,7 +71,10 @@`
`71`	`71`	`* Useful to setup additional resources and add additional information to the object writing. You can also provide`
`72`	`72`	`* some logic to treat a failed object write.`
`73`	`73`	`*`
`74`		`- * Remember that listeners need to be configured in the job xml file (+myjob.xml+).`
	`74`	`+ * The +listeners+ element can be used at the +step+ level or the +job+ level to define which listeners to run for each`
	`75`	`+ * batch processing event.`
	`76`	`+ *`
	`77`	`+ * include::myJob.xml[]`
`75`	`78`	`*`
`76`	`79`	`* @author Roberto Cortez`
`77`	`80`	`*/`
`@@ -82,10 +85,10 @@ public class BatchListenersTest {`
`82`	`85`	`*`
`83`	`86`	`* [source,file]`
`84`	`87`	`* ----`
`85`		`- * /META-INF/batch-jobs/myjob.xml`
	`88`	`+ * /META-INF/batch-jobs/myJob.xml`
`86`	`89`	`* ----`
`87`	`90`	`*`
`88`		`- * The +myjob.xml+ file is needed for running the batch definition.`
	`91`	`+ * The +myJob.xml+ file is needed for running the batch definition.`
`89`	`92`	`*/`
`90`	`93`	`@Deployment`
`91`	`94`	`public static WebArchive createDeployment() {`
Original file line number	Diff line number	Diff line change
`@@ -75,6 +75,7 @@ public void testBatchletProcess() throws Exception {`
`75`	`75`
`76`	`76`	`BatchTestHelper.keepTestAlive(jobExecution);`
`77`	`77`
	`78`	`+ // <1> Job should be completed.`
`78`	`79`	`assertEquals(jobExecution.getBatchStatus(), BatchStatus.COMPLETED);`
`79`	`80`	`}`
`80`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@`
`33`	`33`	`*`
`34`	`34`	`* include::myJob.xml[]`
`35`	`35`	`*`
`36`		`- * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and writer. For`
	`36`	`+ * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and a writer. For`
`37`	`37`	`* this sample, a custom checkpoint policy is going to be used. The custom policy needs to implement`
`38`	`38`	`* +javax.batch.api.chunk.CheckpointAlgorithm+ or in alternative extend`
`39`	`39`	`* +javax.batch.api.chunk.AbstractCheckpointAlgorithm+ that already provides empty implementations for all methods.`
`@@ -52,10 +52,10 @@ public class BatchChunkCheckpointTest {`
`52`	`52`	`*`
`53`	`53`	`* [source,file]`
`54`	`54`	`* ----`
`55`		`- * /META-INF/batch-jobs/myjob.xml`
	`55`	`+ * /META-INF/batch-jobs/myJob.xml`
`56`	`56`	`* ----`
`57`	`57`	`*`
`58`		`- * The +myjob.xml+ file is needed for running the batch definition.`
	`58`	`+ * The +myJob.xml+ file is needed for running the batch definition.`
`59`	`59`	`*/`
`60`	`60`	`@Deployment`
`61`	`61`	`public static WebArchive createDeployment() {`
Original file line number	Diff line number	Diff line change
`@@ -59,10 +59,10 @@ public class BatchChunkMapperTest {`
`59`	`59`	`*`
`60`	`60`	`* [source,file]`
`61`	`61`	`* ----`
`62`		`- * /META-INF/batch-jobs/myjob.xml`
	`62`	`+ * /META-INF/batch-jobs/myJob.xml`
`63`	`63`	`* ----`
`64`	`64`	`*`
`65`		`- * The +myjob.xml+ file is needed for running the batch definition.`
	`65`	`+ * The +myJob.xml+ file is needed for running the batch definition.`
`66`	`66`	`*/`
`67`	`67`	`@Deployment`
`68`	`68`	`public static WebArchive createDeployment() {`
Original file line number	Diff line number	Diff line change
`@@ -38,10 +38,10 @@ public class BatchChunkOptionalProcessorTest {`
`38`	`38`	`*`
`39`	`39`	`* [source,file]`
`40`	`40`	`* ----`
`41`		`- * /META-INF/batch-jobs/myjob.xml`
	`41`	`+ * /META-INF/batch-jobs/myJob.xml`
`42`	`42`	`* ----`
`43`	`43`	`*`
`44`		`- * The +myjob.xml+ file is needed for running the batch definition.`
	`44`	`+ * The +myJob.xml+ file is needed for running the batch definition.`
`45`	`45`	`*/`
`46`	`46`	`@Deployment`
`47`	`47`	`public static WebArchive createDeployment() {`
Original file line number	Diff line number	Diff line change
`@@ -54,10 +54,10 @@ public class BatchChunkPartitionTest {`
`54`	`54`	`*`
`55`	`55`	`* [source,file]`
`56`	`56`	`* ----`
`57`		`- * /META-INF/batch-jobs/myjob.xml`
	`57`	`+ * /META-INF/batch-jobs/myJob.xml`
`58`	`58`	`* ----`
`59`	`59`	`*`
`60`		`- * The +myjob.xml+ file is needed for running the batch definition.`
	`60`	`+ * The +myJob.xml+ file is needed for running the batch definition.`
`61`	`61`	`*/`
`62`	`62`	`@Deployment`
`63`	`63`	`public static WebArchive createDeployment() {`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@`
`24`	`24`	`*`
`25`	`25`	`* include::myJob.xml[]`
`26`	`26`	`*`
`27`		`- * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and writer.`
	`27`	`+ * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and a writer.`
`28`	`28`	`*`
`29`	`29`	`* @author Roberto Cortez`
`30`	`30`	`*/`
`@@ -35,10 +35,10 @@ public class BatchChunkSimpleNoBeansTest {`
`35`	`35`	`*`
`36`	`36`	`* [source,file]`
`37`	`37`	`* ----`
`38`		`- * /META-INF/batch-jobs/myjob.xml`
	`38`	`+ * /META-INF/batch-jobs/myJob.xml`
`39`	`39`	`* ----`
`40`	`40`	`*`
`41`		`- * The +myjob.xml+ file is needed for running the batch definition. This sample is also missing the +beans.xml+ for`
	`41`	`+ * The +myJob.xml+ file is needed for running the batch definition. This sample is also missing the +beans.xml+ for`
`42`	`42`	`* CDI discovery, since for Java EE 7 this file is now optional, but you need to annotated batch dependent beans`
`43`	`43`	`* with +@Dependent+.`
`44`	`44`	`*/`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@`
`26`	`26`	`*`
`27`	`27`	`* include::myJob.xml[]`
`28`	`28`	`*`
`29`		`- * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and writer.`
	`29`	`+ * A very simple job is defined in the +myJob.xml+ file. Just a single step with a reader, a processor and a writer.`
`30`	`30`	`*`
`31`	`31`	`* @author Roberto Cortez`
`32`	`32`	`*/`
`@@ -37,10 +37,10 @@ public class ChunkSimpleTest {`
`37`	`37`	`*`
`38`	`38`	`* [source,file]`
`39`	`39`	`* ----`
`40`		`- * /META-INF/batch-jobs/myjob.xml`
	`40`	`+ * /META-INF/batch-jobs/myJob.xml`
`41`	`41`	`* ----`
`42`	`42`	`*`
`43`		`- * The +myjob.xml+ file is needed for running the batch definition.`
	`43`	`+ * The +myJob.xml+ file is needed for running the batch definition.`
`44`	`44`	`*/`
`45`	`45`	`@Deployment`
`46`	`46`	`public static WebArchive createDeployment() {`