Update versions and update code format

spring-cloud-starter-single-step-batch-job/src/main/java/org/springframework/cloud/task/batch/autoconfigure/RangeConverter.java

@@ -48,7 +48,7 @@ public class RangeConverter implements Converter<String, Range> {
 		}
 		else {
 			throw new IllegalArgumentException(String
-					.format("%s is in an illegal format.  Ranges must be specified as startIndex-endIndex", source));
+				.format("%s is in an illegal format.  Ranges must be specified as startIndex-endIndex", source));
 		}
 	}
 

spring-cloud-starter-single-step-batch-job/src/main/java/org/springframework/cloud/task/batch/autoconfigure/SingleStepJobAutoConfiguration.java

@@ -81,9 +81,8 @@ public class SingleStepJobAutoConfiguration {
 
 		SimpleStepBuilder<Map<String, Object>, Map<String, Object>> stepBuilder = new StepBuilder(
 				this.properties.getStepName(), this.jobRepository)
-						.<Map<String, Object>, Map<String, Object>>chunk(this.properties.getChunkSize(),
-								this.transactionManager)
-						.reader(itemReader);
+			.<Map<String, Object>, Map<String, Object>>chunk(this.properties.getChunkSize(), this.transactionManager)
+			.reader(itemReader);
 
 		stepBuilder.processor(this.itemProcessor);
 

spring-cloud-starter-single-step-batch-job/src/main/java/org/springframework/cloud/task/batch/autoconfigure/flatfile/FlatFileItemReaderAutoConfiguration.java

@@ -67,11 +67,15 @@ public class FlatFileItemReaderAutoConfiguration {
 			@Autowired(required = false) LineCallbackHandler skippedLinesCallback,
 			@Autowired(required = false) RecordSeparatorPolicy recordSeparatorPolicy) {
 		FlatFileItemReaderBuilder<Map<String, Object>> mapFlatFileItemReaderBuilder = new FlatFileItemReaderBuilder<Map<String, Object>>()
-				.name(this.properties.getName()).resource(this.properties.getResource())
-				.saveState(this.properties.isSaveState()).maxItemCount(this.properties.getMaxItemCount())
-				.currentItemCount(this.properties.getCurrentItemCount()).strict(this.properties.isStrict())
-				.encoding(this.properties.getEncoding()).linesToSkip(this.properties.getLinesToSkip())
-				.comments(this.properties.getComments().toArray(new String[this.properties.getComments().size()]));
+			.name(this.properties.getName())
+			.resource(this.properties.getResource())
+			.saveState(this.properties.isSaveState())
+			.maxItemCount(this.properties.getMaxItemCount())
+			.currentItemCount(this.properties.getCurrentItemCount())
+			.strict(this.properties.isStrict())
+			.encoding(this.properties.getEncoding())
+			.linesToSkip(this.properties.getLinesToSkip())
+			.comments(this.properties.getComments().toArray(new String[this.properties.getComments().size()]));
 
 		mapFlatFileItemReaderBuilder.lineTokenizer(lineTokenizer);
 		if (recordSeparatorPolicy != null) {
@@ -82,19 +86,23 @@ public class FlatFileItemReaderAutoConfiguration {
 		mapFlatFileItemReaderBuilder.skippedLinesCallback(skippedLinesCallback);
 
 		if (this.properties.isDelimited()) {
-			mapFlatFileItemReaderBuilder.delimited().quoteCharacter(this.properties.getQuoteCharacter())
-					.delimiter(this.properties.getDelimiter())
-					.includedFields(this.properties.getIncludedFields().toArray(new Integer[0]))
-					.names(this.properties.getNames()).beanMapperStrict(this.properties.isParsingStrict())
-					.fieldSetMapper(new MapFieldSetMapper());
+			mapFlatFileItemReaderBuilder.delimited()
+				.quoteCharacter(this.properties.getQuoteCharacter())
+				.delimiter(this.properties.getDelimiter())
+				.includedFields(this.properties.getIncludedFields().toArray(new Integer[0]))
+				.names(this.properties.getNames())
+				.beanMapperStrict(this.properties.isParsingStrict())
+				.fieldSetMapper(new MapFieldSetMapper());
 		}
 		else if (this.properties.isFixedLength()) {
 			RangeConverter rangeConverter = new RangeConverter();
 			List<Range> ranges = new ArrayList<>();
 			this.properties.getRanges().forEach(range -> ranges.add(rangeConverter.convert(range)));
-			mapFlatFileItemReaderBuilder.fixedLength().columns(ranges.toArray(new Range[0]))
-					.names(this.properties.getNames()).fieldSetMapper(new MapFieldSetMapper())
-					.beanMapperStrict(this.properties.isParsingStrict());
+			mapFlatFileItemReaderBuilder.fixedLength()
+				.columns(ranges.toArray(new Range[0]))
+				.names(this.properties.getNames())
+				.fieldSetMapper(new MapFieldSetMapper())
+				.beanMapperStrict(this.properties.isParsingStrict());
 		}
 
 		return mapFlatFileItemReaderBuilder.build();

spring-cloud-starter-single-step-batch-job/src/main/java/org/springframework/cloud/task/batch/autoconfigure/flatfile/FlatFileItemWriterAutoConfiguration.java

@@ -80,17 +80,22 @@ public class FlatFileItemWriterAutoConfiguration {
 		}
 
 		FlatFileItemWriterBuilder<Map<String, Object>> builder = new FlatFileItemWriterBuilder<Map<String, Object>>()
-				.name(this.properties.getName()).resource((WritableResource) this.properties.getResource())
-				.append(this.properties.isAppend()).encoding(this.properties.getEncoding())
-				.forceSync(this.properties.isForceSync()).lineSeparator(this.properties.getLineSeparator())
-				.saveState(this.properties.isSaveState()).shouldDeleteIfEmpty(this.properties.isShouldDeleteIfEmpty())
-				.shouldDeleteIfExists(this.properties.isShouldDeleteIfExists())
-				.transactional(this.properties.isTransactional()).headerCallback(this.headerCallback)
-				.footerCallback(this.footerCallback);
+			.name(this.properties.getName())
+			.resource((WritableResource) this.properties.getResource())
+			.append(this.properties.isAppend())
+			.encoding(this.properties.getEncoding())
+			.forceSync(this.properties.isForceSync())
+			.lineSeparator(this.properties.getLineSeparator())
+			.saveState(this.properties.isSaveState())
+			.shouldDeleteIfEmpty(this.properties.isShouldDeleteIfEmpty())
+			.shouldDeleteIfExists(this.properties.isShouldDeleteIfExists())
+			.transactional(this.properties.isTransactional())
+			.headerCallback(this.headerCallback)
+			.footerCallback(this.footerCallback);
 
 		if (this.properties.isDelimited()) {
 			FlatFileItemWriterBuilder.DelimitedBuilder<Map<String, Object>> delimitedBuilder = builder.delimited()
-					.delimiter(this.properties.getDelimiter());
+				.delimiter(this.properties.getDelimiter());
 
 			if (this.fieldExtractor != null) {
 				delimitedBuilder.fieldExtractor(this.fieldExtractor);
@@ -101,9 +106,10 @@ public class FlatFileItemWriterAutoConfiguration {
 		}
 		else if (this.properties.isFormatted()) {
 			FlatFileItemWriterBuilder.FormattedBuilder<Map<String, Object>> formattedBuilder = builder.formatted()
-					.format(this.properties.getFormat()).locale(this.properties.getLocale())
-					.maximumLength(this.properties.getMaximumLength())
-					.minimumLength(this.properties.getMinimumLength());
+				.format(this.properties.getFormat())
+				.locale(this.properties.getLocale())
+				.maximumLength(this.properties.getMaximumLength())
+				.minimumLength(this.properties.getMinimumLength());
 
 			if (this.fieldExtractor != null) {
 				formattedBuilder.fieldExtractor(this.fieldExtractor);

spring-cloud-starter-single-step-batch-job/src/main/java/org/springframework/cloud/task/batch/autoconfigure/jdbc/JdbcBatchItemWriterAutoConfiguration.java

@@ -87,7 +87,8 @@ public class JdbcBatchItemWriterAutoConfiguration {
 		}
 
 		JdbcBatchItemWriterBuilder<Map<String, Object>> jdbcBatchItemWriterBuilder = new JdbcBatchItemWriterBuilder<Map<String, Object>>()
-				.dataSource(writerDataSource).sql(this.properties.getSql());
+			.dataSource(writerDataSource)
+			.sql(this.properties.getSql());
 		if (this.itemPreparedStatementSetter != null) {
 			jdbcBatchItemWriterBuilder.itemPreparedStatementSetter(this.itemPreparedStatementSetter);
 		}

spring-cloud-starter-single-step-batch-job/src/main/java/org/springframework/cloud/task/batch/autoconfigure/jdbc/JdbcCursorItemReaderAutoConfiguration.java

@@ -85,14 +85,21 @@ public class JdbcCursorItemReaderAutoConfiguration {
 
 		}
 		return new JdbcCursorItemReaderBuilder<Map<String, Object>>().name(this.properties.getName())
-				.currentItemCount(this.properties.getCurrentItemCount()).dataSource(readerDataSource)
-				.driverSupportsAbsolute(this.properties.isDriverSupportsAbsolute())
-				.fetchSize(this.properties.getFetchSize()).ignoreWarnings(this.properties.isIgnoreWarnings())
-				.maxItemCount(this.properties.getMaxItemCount()).maxRows(this.properties.getMaxRows())
-				.queryTimeout(this.properties.getQueryTimeout()).saveState(this.properties.isSaveState())
-				.sql(this.properties.getSql()).rowMapper(rowMapper).preparedStatementSetter(preparedStatementSetter)
-				.verifyCursorPosition(this.properties.isVerifyCursorPosition())
-				.useSharedExtendedConnection(this.properties.isUseSharedExtendedConnection()).build();
+			.currentItemCount(this.properties.getCurrentItemCount())
+			.dataSource(readerDataSource)
+			.driverSupportsAbsolute(this.properties.isDriverSupportsAbsolute())
+			.fetchSize(this.properties.getFetchSize())
+			.ignoreWarnings(this.properties.isIgnoreWarnings())
+			.maxItemCount(this.properties.getMaxItemCount())
+			.maxRows(this.properties.getMaxRows())
+			.queryTimeout(this.properties.getQueryTimeout())
+			.saveState(this.properties.isSaveState())
+			.sql(this.properties.getSql())
+			.rowMapper(rowMapper)
+			.preparedStatementSetter(preparedStatementSetter)
+			.verifyCursorPosition(this.properties.isVerifyCursorPosition())
+			.useSharedExtendedConnection(this.properties.isUseSharedExtendedConnection())
+			.build();
 	}
 
 	@Bean

spring-cloud-starter-single-step-batch-job/src/main/java/org/springframework/cloud/task/batch/autoconfigure/kafka/KafkaItemReaderAutoConfiguration.java

@@ -64,10 +64,13 @@ public class KafkaItemReaderAutoConfiguration {
 			kafkaItemReaderProperties.getPartitions().add(0);
 		}
 		return new KafkaItemReaderBuilder<Object, Map<String, Object>>()
-				.partitions(kafkaItemReaderProperties.getPartitions()).consumerProperties(consumerProperties)
-				.name(kafkaItemReaderProperties.getName())
-				.pollTimeout(Duration.ofSeconds(kafkaItemReaderProperties.getPollTimeOutInSeconds()))
-				.saveState(kafkaItemReaderProperties.isSaveState()).topic(kafkaItemReaderProperties.getTopic()).build();
+			.partitions(kafkaItemReaderProperties.getPartitions())
+			.consumerProperties(consumerProperties)
+			.name(kafkaItemReaderProperties.getName())
+			.pollTimeout(Duration.ofSeconds(kafkaItemReaderProperties.getPollTimeOutInSeconds()))
+			.saveState(kafkaItemReaderProperties.isSaveState())
+			.topic(kafkaItemReaderProperties.getTopic())
+			.build();
 	}
 
 	private void validateProperties(KafkaItemReaderProperties kafkaItemReaderProperties) {

spring-cloud-starter-single-step-batch-job/src/main/java/org/springframework/cloud/task/batch/autoconfigure/kafka/KafkaItemWriterAutoConfiguration.java

@@ -66,7 +66,9 @@ public class KafkaItemWriterAutoConfiguration {
 		KafkaTemplate template = new KafkaTemplate(producerFactory);
 		template.setDefaultTopic(kafkaItemWriterProperties.getTopic());
 		return new KafkaItemWriterBuilder<Object, Map<String, Object>>().delete(kafkaItemWriterProperties.isDelete())
-				.kafkaTemplate(template).itemKeyMapper(itemKeyMapper).build();
+			.kafkaTemplate(template)
+			.itemKeyMapper(itemKeyMapper)
+			.build();
 	}
 
 	@Bean

spring-cloud-starter-single-step-batch-job/src/main/java/org/springframework/cloud/task/batch/autoconfigure/rabbit/AmqpItemReaderAutoConfiguration.java

@@ -57,7 +57,7 @@ public class AmqpItemReaderAutoConfiguration {
 	public AmqpItemReader<Map<String, Object>> amqpItemReader(AmqpTemplate amqpTemplate,
 			@Autowired(required = false) Class itemType) {
 		AmqpItemReaderBuilder<Map<String, Object>> builder = new AmqpItemReaderBuilder<Map<String, Object>>()
-				.amqpTemplate(amqpTemplate);
+			.amqpTemplate(amqpTemplate);
 		if (itemType != null) {
 			builder.itemType(itemType);
 		}

spring-cloud-starter-single-step-batch-job/src/test/java/org/springframework/cloud/task/batch/autoconfigure/SingleStepJobAutoConfigurationTests.java

@@ -104,12 +104,12 @@ public class SingleStepJobAutoConfigurationTests {
 	@Test
 	public void testSimpleConfiguration() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(SimpleConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5");
+			.withUserConfiguration(SimpleConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5");
 
 		validateConfiguration(applicationContextRunner);
 	}
@@ -117,12 +117,12 @@ public class SingleStepJobAutoConfigurationTests {
 	@Test
 	public void testSimpleConfigurationKabobStyle() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(SimpleConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.job-name=job", "spring.batch.job.step-name=step1",
-						"spring.batch.job.chunk-size=5");
+			.withUserConfiguration(SimpleConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.job-name=job", "spring.batch.job.step-name=step1",
+					"spring.batch.job.chunk-size=5");
 
 		validateConfiguration(applicationContextRunner);
 	}

spring-cloud-starter-single-step-batch-job/src/test/java/org/springframework/cloud/task/batch/autoconfigure/flatfile/FlatFileItemReaderAutoConfigurationTests.java

@@ -76,26 +76,26 @@ public class FlatFileItemReaderAutoConfigurationTests {
 	@Test
 	public void testFullDelimitedConfiguration() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(JobConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						FlatFileItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemreader.savestate=true",
-						"spring.batch.job.flatfileitemreader.name=fullDelimitedConfiguration",
-						"spring.batch.job.flatfileitemreader.maxItemCount=5",
-						"spring.batch.job.flatfileitemreader.currentItemCount=2",
-						"spring.batch.job.flatfileitemreader.comments=#,$",
-						"spring.batch.job.flatfileitemreader.resource=/testUTF16.csv",
-						"spring.batch.job.flatfileitemreader.strict=true",
-						"spring.batch.job.flatfileitemreader.encoding=UTF-16",
-						"spring.batch.job.flatfileitemreader.linesToSkip=1",
-						"spring.batch.job.flatfileitemreader.delimited=true",
-						"spring.batch.job.flatfileitemreader.delimiter=@",
-						"spring.batch.job.flatfileitemreader.quoteCharacter=%",
-						"spring.batch.job.flatfileitemreader.includedFields=1,3,5",
-						"spring.batch.job.flatfileitemreader.names=foo,bar,baz",
-						"spring.batch.job.flatfileitemreader.parsingStrict=false");
+			.withUserConfiguration(JobConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemreader.savestate=true",
+					"spring.batch.job.flatfileitemreader.name=fullDelimitedConfiguration",
+					"spring.batch.job.flatfileitemreader.maxItemCount=5",
+					"spring.batch.job.flatfileitemreader.currentItemCount=2",
+					"spring.batch.job.flatfileitemreader.comments=#,$",
+					"spring.batch.job.flatfileitemreader.resource=/testUTF16.csv",
+					"spring.batch.job.flatfileitemreader.strict=true",
+					"spring.batch.job.flatfileitemreader.encoding=UTF-16",
+					"spring.batch.job.flatfileitemreader.linesToSkip=1",
+					"spring.batch.job.flatfileitemreader.delimited=true",
+					"spring.batch.job.flatfileitemreader.delimiter=@",
+					"spring.batch.job.flatfileitemreader.quoteCharacter=%",
+					"spring.batch.job.flatfileitemreader.includedFields=1,3,5",
+					"spring.batch.job.flatfileitemreader.names=foo,bar,baz",
+					"spring.batch.job.flatfileitemreader.parsingStrict=false");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -130,21 +130,20 @@ public class FlatFileItemReaderAutoConfigurationTests {
 	@Test
 	public void testFixedWidthConfiguration() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(JobConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, FlatFileItemReaderAutoConfiguration.class,
-								RangeConverter.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemreader.savestate=true",
-						"spring.batch.job.flatfileitemreader.name=fixedWidthConfiguration",
-						"spring.batch.job.flatfileitemreader.comments=#,$",
-						"spring.batch.job.flatfileitemreader.resource=/test.txt",
-						"spring.batch.job.flatfileitemreader.strict=true",
-						"spring.batch.job.flatfileitemreader.fixedLength=true",
-						"spring.batch.job.flatfileitemreader.ranges=3-4,7-8,11",
-						"spring.batch.job.flatfileitemreader.names=foo,bar,baz",
-						"spring.batch.job.flatfileitemreader.parsingStrict=false");
+			.withUserConfiguration(JobConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemReaderAutoConfiguration.class, RangeConverter.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemreader.savestate=true",
+					"spring.batch.job.flatfileitemreader.name=fixedWidthConfiguration",
+					"spring.batch.job.flatfileitemreader.comments=#,$",
+					"spring.batch.job.flatfileitemreader.resource=/test.txt",
+					"spring.batch.job.flatfileitemreader.strict=true",
+					"spring.batch.job.flatfileitemreader.fixedLength=true",
+					"spring.batch.job.flatfileitemreader.ranges=3-4,7-8,11",
+					"spring.batch.job.flatfileitemreader.names=foo,bar,baz",
+					"spring.batch.job.flatfileitemreader.parsingStrict=false");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -188,15 +187,14 @@ public class FlatFileItemReaderAutoConfigurationTests {
 	@Test
 	public void testCustomLineMapper() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(CustomLineMapperConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						FlatFileItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5",
-						"spring.batch.job.flatfileitemreader.name=fixedWidthConfiguration",
-						"spring.batch.job.flatfileitemreader.resource=/test.txt",
-						"spring.batch.job.flatfileitemreader.strict=true");
+			.withUserConfiguration(CustomLineMapperConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemreader.name=fixedWidthConfiguration",
+					"spring.batch.job.flatfileitemreader.resource=/test.txt",
+					"spring.batch.job.flatfileitemreader.strict=true");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -225,20 +223,18 @@ public class FlatFileItemReaderAutoConfigurationTests {
 	@Test
 	public void testCustomRecordSeparatorAndSkippedLines() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(RecordSeparatorAndSkippedLinesJobConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, FlatFileItemReaderAutoConfiguration.class,
-								RangeConverter.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5",
-						"spring.batch.job.flatfileitemreader.name=fixedWidthConfiguration",
-						"spring.batch.job.flatfileitemreader.resource=/test.txt",
-						"spring.batch.job.flatfileitemreader.linesToSkip=2",
-						"spring.batch.job.flatfileitemreader.fixedLength=true",
-						"spring.batch.job.flatfileitemreader.ranges=3-4,7-8,11",
-						"spring.batch.job.flatfileitemreader.names=foo,bar,baz",
-						"spring.batch.job.flatfileitemreader.strict=true");
+			.withUserConfiguration(RecordSeparatorAndSkippedLinesJobConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemReaderAutoConfiguration.class, RangeConverter.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemreader.name=fixedWidthConfiguration",
+					"spring.batch.job.flatfileitemreader.resource=/test.txt",
+					"spring.batch.job.flatfileitemreader.linesToSkip=2",
+					"spring.batch.job.flatfileitemreader.fixedLength=true",
+					"spring.batch.job.flatfileitemreader.ranges=3-4,7-8,11",
+					"spring.batch.job.flatfileitemreader.names=foo,bar,baz",
+					"spring.batch.job.flatfileitemreader.strict=true");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -268,17 +264,15 @@ public class FlatFileItemReaderAutoConfigurationTests {
 	@Test
 	public void testCustomMapping() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(CustomMappingConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, FlatFileItemReaderAutoConfiguration.class,
-								RangeConverter.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5",
-						"spring.batch.job.flatfileitemreader.name=fixedWidthConfiguration",
-						"spring.batch.job.flatfileitemreader.resource=/test.txt",
-						"spring.batch.job.flatfileitemreader.maxItemCount=1",
-						"spring.batch.job.flatfileitemreader.strict=true");
+			.withUserConfiguration(CustomMappingConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemReaderAutoConfiguration.class, RangeConverter.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemreader.name=fixedWidthConfiguration",
+					"spring.batch.job.flatfileitemreader.resource=/test.txt",
+					"spring.batch.job.flatfileitemreader.maxItemCount=1",
+					"spring.batch.job.flatfileitemreader.strict=true");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);

spring-cloud-starter-single-step-batch-job/src/test/java/org/springframework/cloud/task/batch/autoconfigure/flatfile/FlatFileItemWriterAutoConfigurationTests.java

@@ -109,7 +109,7 @@ public class FlatFileItemWriterAutoConfigurationTests {
 		}
 		catch (IllegalStateException ise) {
 			assertThat(ise.getMessage())
-					.isEqualTo("A LineAggregator must be configured if the " + "output is not formatted or delimited");
+				.isEqualTo("A LineAggregator must be configured if the " + "output is not formatted or delimited");
 		}
 		catch (Exception e) {
 			fail("Incorrect exception thrown", e);
@@ -124,7 +124,7 @@ public class FlatFileItemWriterAutoConfigurationTests {
 		}
 		catch (IllegalStateException ise) {
 			assertThat(ise.getMessage())
-					.isEqualTo("A LineAggregator must be configured if the " + "output is not formatted or delimited");
+				.isEqualTo("A LineAggregator must be configured if the " + "output is not formatted or delimited");
 		}
 		catch (Exception e) {
 			fail("Incorrect exception thrown", e);
@@ -134,23 +134,22 @@ public class FlatFileItemWriterAutoConfigurationTests {
 	@Test
 	public void testDelimitedFileGeneration() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(DelimitedJobConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemwriter.name=fooWriter",
-						String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
-								this.outputFile.getAbsolutePath()),
-						"spring.batch.job.flatfileitemwriter.encoding=UTF-16",
-						"spring.batch.job.flatfileitemwriter.saveState=false",
-						"spring.batch.job.flatfileitemwriter.shouldDeleteIfEmpty=true",
-						"spring.batch.job.flatfileitemwriter.delimited=true",
-						"spring.batch.job.flatfileitemwriter.names=item",
-						"spring.batch.job.flatfileitemwriter.append=true",
-						"spring.batch.job.flatfileitemwriter.forceSync=true",
-						"spring.batch.job.flatfileitemwriter.shouldDeleteIfExists=false",
-						"spring.batch.job.flatfileitemwriter.transactional=false");
+			.withUserConfiguration(DelimitedJobConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemwriter.name=fooWriter",
+					String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
+							this.outputFile.getAbsolutePath()),
+					"spring.batch.job.flatfileitemwriter.encoding=UTF-16",
+					"spring.batch.job.flatfileitemwriter.saveState=false",
+					"spring.batch.job.flatfileitemwriter.shouldDeleteIfEmpty=true",
+					"spring.batch.job.flatfileitemwriter.delimited=true",
+					"spring.batch.job.flatfileitemwriter.names=item", "spring.batch.job.flatfileitemwriter.append=true",
+					"spring.batch.job.flatfileitemwriter.forceSync=true",
+					"spring.batch.job.flatfileitemwriter.shouldDeleteIfExists=false",
+					"spring.batch.job.flatfileitemwriter.transactional=false");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -169,7 +168,7 @@ public class FlatFileItemWriterAutoConfigurationTests {
 
 			assertThat(Assertions.linesOf(this.outputFile, StandardCharsets.UTF_16).size()).isEqualTo(3);
 			assertThat(Assertions.contentOf((new ClassPathResource("writerTestUTF16.txt")).getFile())
-					.equals(new FileSystemResource(this.outputFile)));
+				.equals(new FileSystemResource(this.outputFile)));
 
 			assertThat((Boolean) ReflectionTestUtils.getField(writer, "saveState")).isFalse();
 			assertThat((Boolean) ReflectionTestUtils.getField(writer, "append")).isTrue();
@@ -182,20 +181,20 @@ public class FlatFileItemWriterAutoConfigurationTests {
 	@Test
 	public void testFormattedFileGeneration() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(FormattedJobConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=2", "spring.batch.job.flatfileitemwriter.name=fooWriter",
-						String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
-								this.outputFile.getAbsolutePath()),
-						"spring.batch.job.flatfileitemwriter.encoding=UTF-8",
-						"spring.batch.job.flatfileitemwriter.formatted=true",
-						"spring.batch.job.flatfileitemwriter.names=item",
-						"spring.batch.job.flatfileitemwriter.format=item = %s",
-						"spring.batch.job.flatfileitemwriter.minimumLength=8",
-						"spring.batch.job.flatfileitemwriter.maximumLength=10");
+			.withUserConfiguration(FormattedJobConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=2", "spring.batch.job.flatfileitemwriter.name=fooWriter",
+					String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
+							this.outputFile.getAbsolutePath()),
+					"spring.batch.job.flatfileitemwriter.encoding=UTF-8",
+					"spring.batch.job.flatfileitemwriter.formatted=true",
+					"spring.batch.job.flatfileitemwriter.names=item",
+					"spring.batch.job.flatfileitemwriter.format=item = %s",
+					"spring.batch.job.flatfileitemwriter.minimumLength=8",
+					"spring.batch.job.flatfileitemwriter.maximumLength=10");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -213,7 +212,7 @@ public class FlatFileItemWriterAutoConfigurationTests {
 			assertThat(Assertions.linesOf(this.outputFile).size()).isEqualTo(2);
 
 			String results = FileCopyUtils
-					.copyToString(new InputStreamReader(new FileSystemResource(this.outputFile).getInputStream()));
+				.copyToString(new InputStreamReader(new FileSystemResource(this.outputFile).getInputStream()));
 			assertThat(results).isEqualTo("item = foo\nitem = bar\n");
 		});
 	}
@@ -221,18 +220,18 @@ public class FlatFileItemWriterAutoConfigurationTests {
 	@Test
 	public void testFormattedFieldExtractorFileGeneration() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(FormattedFieldExtractorJobConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemwriter.name=fooWriter",
-						String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
-								this.outputFile.getAbsolutePath()),
-						"spring.batch.job.flatfileitemwriter.encoding=UTF-8",
-						"spring.batch.job.flatfileitemwriter.formatted=true",
-						"spring.batch.job.flatfileitemwriter.names=item",
-						"spring.batch.job.flatfileitemwriter.format=item = %s");
+			.withUserConfiguration(FormattedFieldExtractorJobConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemwriter.name=fooWriter",
+					String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
+							this.outputFile.getAbsolutePath()),
+					"spring.batch.job.flatfileitemwriter.encoding=UTF-8",
+					"spring.batch.job.flatfileitemwriter.formatted=true",
+					"spring.batch.job.flatfileitemwriter.names=item",
+					"spring.batch.job.flatfileitemwriter.format=item = %s");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -250,7 +249,7 @@ public class FlatFileItemWriterAutoConfigurationTests {
 			assertThat(Assertions.linesOf(this.outputFile).size()).isEqualTo(3);
 
 			String results = FileCopyUtils
-					.copyToString(new InputStreamReader(new FileSystemResource(this.outputFile).getInputStream()));
+				.copyToString(new InputStreamReader(new FileSystemResource(this.outputFile).getInputStream()));
 			assertThat(results).isEqualTo("item = f\nitem = b\nitem = b\n");
 		});
 	}
@@ -258,16 +257,16 @@ public class FlatFileItemWriterAutoConfigurationTests {
 	@Test
 	public void testFieldExtractorFileGeneration() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(FieldExtractorConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemwriter.name=fooWriter",
-						String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
-								this.outputFile.getAbsolutePath()),
-						"spring.batch.job.flatfileitemwriter.encoding=UTF-8",
-						"spring.batch.job.flatfileitemwriter.delimited=true");
+			.withUserConfiguration(FieldExtractorConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemwriter.name=fooWriter",
+					String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
+							this.outputFile.getAbsolutePath()),
+					"spring.batch.job.flatfileitemwriter.encoding=UTF-8",
+					"spring.batch.job.flatfileitemwriter.delimited=true");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -285,7 +284,7 @@ public class FlatFileItemWriterAutoConfigurationTests {
 			assertThat(Assertions.linesOf(this.outputFile, StandardCharsets.UTF_8).size()).isEqualTo(3);
 
 			String results = FileCopyUtils
-					.copyToString(new InputStreamReader(new FileSystemResource(this.outputFile).getInputStream()));
+				.copyToString(new InputStreamReader(new FileSystemResource(this.outputFile).getInputStream()));
 			assertThat(results).isEqualTo("f\nb\nb\n");
 		});
 	}
@@ -293,15 +292,15 @@ public class FlatFileItemWriterAutoConfigurationTests {
 	@Test
 	public void testCustomLineAggregatorFileGeneration() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(LineAggregatorConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemwriter.name=fooWriter",
-						String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
-								this.outputFile.getAbsolutePath()),
-						"spring.batch.job.flatfileitemwriter.encoding=UTF-8");
+			.withUserConfiguration(LineAggregatorConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemwriter.name=fooWriter",
+					String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
+							this.outputFile.getAbsolutePath()),
+					"spring.batch.job.flatfileitemwriter.encoding=UTF-8");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -319,7 +318,7 @@ public class FlatFileItemWriterAutoConfigurationTests {
 			assertThat(Assertions.linesOf(this.outputFile, StandardCharsets.UTF_8).size()).isEqualTo(3);
 
 			String results = FileCopyUtils
-					.copyToString(new InputStreamReader(new FileSystemResource(this.outputFile).getInputStream()));
+				.copyToString(new InputStreamReader(new FileSystemResource(this.outputFile).getInputStream()));
 			assertThat(results).isEqualTo("{item=foo}\n{item=bar}\n{item=baz}\n");
 		});
 	}
@@ -327,17 +326,17 @@ public class FlatFileItemWriterAutoConfigurationTests {
 	@Test
 	public void testHeaderFooterFileGeneration() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(HeaderFooterConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemwriter.name=fooWriter",
-						String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
-								this.outputFile.getAbsolutePath()),
-						"spring.batch.job.flatfileitemwriter.encoding=UTF-8",
-						"spring.batch.job.flatfileitemwriter.delimited=true",
-						"spring.batch.job.flatfileitemwriter.names=item");
+			.withUserConfiguration(HeaderFooterConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					FlatFileItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.flatfileitemwriter.name=fooWriter",
+					String.format("spring.batch.job.flatfileitemwriter.resource=file://%s",
+							this.outputFile.getAbsolutePath()),
+					"spring.batch.job.flatfileitemwriter.encoding=UTF-8",
+					"spring.batch.job.flatfileitemwriter.delimited=true",
+					"spring.batch.job.flatfileitemwriter.names=item");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -355,7 +354,7 @@ public class FlatFileItemWriterAutoConfigurationTests {
 			assertThat(Assertions.linesOf(this.outputFile, StandardCharsets.UTF_8).size()).isEqualTo(5);
 
 			String results = FileCopyUtils
-					.copyToString(new InputStreamReader(new FileSystemResource(this.outputFile).getInputStream()));
+				.copyToString(new InputStreamReader(new FileSystemResource(this.outputFile).getInputStream()));
 			assertThat(results).isEqualTo("header\nfoo\nbar\nbaz\nfooter");
 		});
 	}

spring-cloud-starter-single-step-batch-job/src/test/java/org/springframework/cloud/task/batch/autoconfigure/jdbc/JdbcBatchItemWriterAutoConfigurationTests.java

@@ -101,12 +101,12 @@ public class JdbcBatchItemWriterAutoConfigurationTests {
 	@Test
 	public void baseTest() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(TaskLauncherConfiguration.class,
-						JdbcBatchItemWriterAutoConfigurationTests.DelimitedJobConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, JdbcBatchItemWriterAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jdbcsinglestep.datasource.enable=false");
+			.withUserConfiguration(TaskLauncherConfiguration.class,
+					JdbcBatchItemWriterAutoConfigurationTests.DelimitedJobConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, JdbcBatchItemWriterAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jdbcsinglestep.datasource.enable=false");
 		applicationContextRunner = updatePropertiesForTest(applicationContextRunner);
 
 		runTest(applicationContextRunner, false);
@@ -115,21 +115,21 @@ public class JdbcBatchItemWriterAutoConfigurationTests {
 	@Test
 	public void baseTestWithWriterDataSource() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(TaskLauncherConfiguration.class,
-						JdbcBatchItemWriterAutoConfigurationTests.DelimitedJobConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, JdbcBatchItemWriterAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jdbcbatchitemwriter.datasource.enable=true",
-						"spring.batch.job.jdbcsinglestep.datasource.enable=false", "spring.batch.job.jobName=job",
-						"spring.batch.job.stepName=step1", "spring.batch.job.chunkSize=5",
-						"spring.batch.job.jdbcbatchitemwriter.name=fooWriter",
-						"spring.batch.job.jdbcbatchitemwriter.sql=INSERT INTO item (item_name) VALUES (:item_name)",
-						"spring.batch.jdbc.initialize-schema=always",
-						"jdbcbatchitemwriter.datasource.url=" + DATASOURCE_URL,
-						"jdbcbatchitemwriter.datasource.username=" + DATASOURCE_USER_NAME,
-						"jdbcbatchitemwriter.datasource.password=" + DATASOURCE_USER_PASSWORD,
-						"jdbcbatchitemwriter.datasource.driverClassName=" + DATASOURCE_DRIVER_CLASS_NAME);
+			.withUserConfiguration(TaskLauncherConfiguration.class,
+					JdbcBatchItemWriterAutoConfigurationTests.DelimitedJobConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, JdbcBatchItemWriterAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jdbcbatchitemwriter.datasource.enable=true",
+					"spring.batch.job.jdbcsinglestep.datasource.enable=false", "spring.batch.job.jobName=job",
+					"spring.batch.job.stepName=step1", "spring.batch.job.chunkSize=5",
+					"spring.batch.job.jdbcbatchitemwriter.name=fooWriter",
+					"spring.batch.job.jdbcbatchitemwriter.sql=INSERT INTO item (item_name) VALUES (:item_name)",
+					"spring.batch.jdbc.initialize-schema=always",
+					"jdbcbatchitemwriter.datasource.url=" + DATASOURCE_URL,
+					"jdbcbatchitemwriter.datasource.username=" + DATASOURCE_USER_NAME,
+					"jdbcbatchitemwriter.datasource.password=" + DATASOURCE_USER_PASSWORD,
+					"jdbcbatchitemwriter.datasource.driverClassName=" + DATASOURCE_DRIVER_CLASS_NAME);
 
 		runTest(applicationContextRunner, true);
 	}
@@ -137,13 +137,13 @@ public class JdbcBatchItemWriterAutoConfigurationTests {
 	@Test
 	public void customSqlParameterSourceTest() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(TaskLauncherConfiguration.class,
-						JdbcBatchItemWriterAutoConfigurationTests.DelimitedDifferentKeyNameJobConfiguration.class,
-						CustomSqlParameterSourceProviderConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, JdbcBatchItemWriterAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jdbcsinglestep.datasource.enable=false");
+			.withUserConfiguration(TaskLauncherConfiguration.class,
+					JdbcBatchItemWriterAutoConfigurationTests.DelimitedDifferentKeyNameJobConfiguration.class,
+					CustomSqlParameterSourceProviderConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, JdbcBatchItemWriterAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jdbcsinglestep.datasource.enable=false");
 		applicationContextRunner = updatePropertiesForTest(applicationContextRunner);
 
 		runTest(applicationContextRunner, false);
@@ -152,13 +152,13 @@ public class JdbcBatchItemWriterAutoConfigurationTests {
 	@Test
 	public void preparedStatementSetterTest() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(TaskLauncherConfiguration.class,
-						JdbcBatchItemWriterAutoConfigurationTests.DelimitedJobConfiguration.class,
-						ItemPreparedStatementSetterConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, JdbcBatchItemWriterAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jdbcsinglestep.datasource.enable=false");
+			.withUserConfiguration(TaskLauncherConfiguration.class,
+					JdbcBatchItemWriterAutoConfigurationTests.DelimitedJobConfiguration.class,
+					ItemPreparedStatementSetterConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, JdbcBatchItemWriterAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jdbcsinglestep.datasource.enable=false");
 		applicationContextRunner = updatePropertiesForTest(applicationContextRunner);
 		runTest(applicationContextRunner, false);
 	}
@@ -193,8 +193,8 @@ public class JdbcBatchItemWriterAutoConfigurationTests {
 		assertThat((Boolean) ReflectionTestUtils.getField(writer, "usingNamedParameters")).isTrue();
 		if (!isWriterDataSourcePresent) {
 			assertThatThrownBy(() -> context.getBean("jdbcBatchItemWriterSpringDataSource"))
-					.isInstanceOf(NoSuchBeanDefinitionException.class)
-					.hasMessageContaining("No bean named 'jdbcBatchItemWriterSpringDataSource' available");
+				.isInstanceOf(NoSuchBeanDefinitionException.class)
+				.hasMessageContaining("No bean named 'jdbcBatchItemWriterSpringDataSource' available");
 		}
 		else {
 			assertThat(context.getBean("jdbcBatchItemWriterSpringDataSource")).isNotNull();
@@ -229,8 +229,10 @@ public class JdbcBatchItemWriterAutoConfigurationTests {
 			Server server = null;
 			try {
 				if (defaultServer == null) {
-					server = Server.createTcpServer("-ifNotExists", "-tcp", "-tcpAllowOthers", "-tcpPort",
-							String.valueOf(randomPort)).start();
+					server = Server
+						.createTcpServer("-ifNotExists", "-tcp", "-tcpAllowOthers", "-tcpPort",
+								String.valueOf(randomPort))
+						.start();
 					defaultServer = server;
 					DriverManagerDataSource dataSource = new DriverManagerDataSource();
 					dataSource.setDriverClassName(DATASOURCE_DRIVER_CLASS_NAME);

spring-cloud-starter-single-step-batch-job/src/test/java/org/springframework/cloud/task/batch/autoconfigure/jdbc/JdbcCursorItemReaderAutoConfigurationTests.java

@@ -121,16 +121,17 @@ public class JdbcCursorItemReaderAutoConfigurationTests {
 			assertThat(items.get(1).get("ITEM_NAME")).isEqualTo("bar");
 			assertThat(items.get(2).get("ITEM_NAME")).isEqualTo("baz");
 			assertThatThrownBy(() -> context.getBean("readerSpringDataSource"))
-					.isInstanceOf(NoSuchBeanDefinitionException.class)
-					.hasMessageContaining("No bean named 'readerSpringDataSource' available");
+				.isInstanceOf(NoSuchBeanDefinitionException.class)
+				.hasMessageContaining("No bean named 'readerSpringDataSource' available");
 		});
 	}
 
 	private ApplicationContextRunner applicationContextRunner() {
 		return new ApplicationContextRunner()
-				.withUserConfiguration(TaskLauncherConfiguration.class, BaseConfiguration.class).withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, JdbcCursorItemReaderAutoConfiguration.class));
+			.withUserConfiguration(TaskLauncherConfiguration.class, BaseConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, JdbcCursorItemReaderAutoConfiguration.class));
 	}
 
 	@Test
@@ -172,15 +173,15 @@ public class JdbcCursorItemReaderAutoConfigurationTests {
 	@Test
 	public void testCustomRowMapper() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(TaskLauncherConfiguration.class, RowMapperConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, JdbcCursorItemReaderAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=rowMapperJob", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.jdbccursoritemreader.name=fooReader",
-						"spring.batch.job.jdbccursoritemreader.sql=select * from item",
-						"spring.batch.jdbc.initialize-schema=always",
-						"spring.batch.job.jdbcsinglestep.datasource.enable=false");
+			.withUserConfiguration(TaskLauncherConfiguration.class, RowMapperConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, JdbcCursorItemReaderAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=rowMapperJob", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.jdbccursoritemreader.name=fooReader",
+					"spring.batch.job.jdbccursoritemreader.sql=select * from item",
+					"spring.batch.jdbc.initialize-schema=always",
+					"spring.batch.job.jdbcsinglestep.datasource.enable=false");
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -207,23 +208,23 @@ public class JdbcCursorItemReaderAutoConfigurationTests {
 	@Test
 	public void testRoseyScenario() {
 		final ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(TaskLauncherConfiguration.class, BaseConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, JdbcCursorItemReaderAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=roseyJob", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.jdbccursoritemreader.saveState=false",
-						"spring.batch.job.jdbccursoritemreader.name=fooReader",
-						"spring.batch.job.jdbccursoritemreader.maxItemCount=15",
-						"spring.batch.job.jdbccursoritemreader.currentItemCount=2",
-						"spring.batch.job.jdbccursoritemreader.fetchSize=4",
-						"spring.batch.job.jdbccursoritemreader.maxRows=6",
-						"spring.batch.job.jdbccursoritemreader.queryTimeout=8",
-						"spring.batch.job.jdbccursoritemreader.ignoreWarnings=true",
-						"spring.batch.job.jdbccursoritemreader.verifyCursorPosition=true",
-						"spring.batch.job.jdbccursoritemreader.driverSupportsAbsolute=true",
-						"spring.batch.job.jdbccursoritemreader.useSharedExtendedConnection=true",
-						"spring.batch.job.jdbccursoritemreader.sql=select * from foo");
+			.withUserConfiguration(TaskLauncherConfiguration.class, BaseConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, JdbcCursorItemReaderAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=roseyJob", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.jdbccursoritemreader.saveState=false",
+					"spring.batch.job.jdbccursoritemreader.name=fooReader",
+					"spring.batch.job.jdbccursoritemreader.maxItemCount=15",
+					"spring.batch.job.jdbccursoritemreader.currentItemCount=2",
+					"spring.batch.job.jdbccursoritemreader.fetchSize=4",
+					"spring.batch.job.jdbccursoritemreader.maxRows=6",
+					"spring.batch.job.jdbccursoritemreader.queryTimeout=8",
+					"spring.batch.job.jdbccursoritemreader.ignoreWarnings=true",
+					"spring.batch.job.jdbccursoritemreader.verifyCursorPosition=true",
+					"spring.batch.job.jdbccursoritemreader.driverSupportsAbsolute=true",
+					"spring.batch.job.jdbccursoritemreader.useSharedExtendedConnection=true",
+					"spring.batch.job.jdbccursoritemreader.sql=select * from foo");
 
 		applicationContextRunner.run((context) -> {
 
@@ -239,7 +240,8 @@ public class JdbcCursorItemReaderAutoConfigurationTests {
 		assertThat((Boolean) ReflectionTestUtils.getField(itemReader, "saveState")).isFalse();
 		assertThat(ReflectionTestUtils.getField(
 				(ExecutionContextUserSupport) ReflectionTestUtils.getField(itemReader, "executionContextUserSupport"),
-				"name")).isEqualTo("fooReader");
+				"name"))
+			.isEqualTo("fooReader");
 		assertThat((Integer) ReflectionTestUtils.getField(itemReader, "maxItemCount")).isEqualTo(15);
 		assertThat((Integer) ReflectionTestUtils.getField(itemReader, "currentItemCount")).isEqualTo(2);
 		assertThat((Integer) ReflectionTestUtils.getField(itemReader, "fetchSize")).isEqualTo(4);
@@ -254,12 +256,12 @@ public class JdbcCursorItemReaderAutoConfigurationTests {
 	@Test
 	public void testNoName() {
 		final ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(TaskLauncherConfiguration.class, BaseConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, JdbcCursorItemReaderAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=noNameJob", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5");
+			.withUserConfiguration(TaskLauncherConfiguration.class, BaseConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, JdbcCursorItemReaderAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=noNameJob", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5");
 
 		assertThatThrownBy(() -> {
 			runTest(applicationContextRunner);
@@ -269,12 +271,12 @@ public class JdbcCursorItemReaderAutoConfigurationTests {
 	@Test
 	public void testSqlName() {
 		final ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(TaskLauncherConfiguration.class, BaseConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, JdbcCursorItemReaderAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.jdbccursoritemreader.name=fooReader");
+			.withUserConfiguration(TaskLauncherConfiguration.class, BaseConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, JdbcCursorItemReaderAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.jdbccursoritemreader.name=fooReader");
 
 		assertThatThrownBy(() -> {
 			runTest(applicationContextRunner);
@@ -314,8 +316,10 @@ public class JdbcCursorItemReaderAutoConfigurationTests {
 			Server server = null;
 			try {
 				if (defaultServer == null) {
-					server = Server.createTcpServer("-ifNotExists", "-tcp", "-tcpAllowOthers", "-tcpPort",
-							String.valueOf(randomPort)).start();
+					server = Server
+						.createTcpServer("-ifNotExists", "-tcp", "-tcpAllowOthers", "-tcpPort",
+								String.valueOf(randomPort))
+						.start();
 					defaultServer = server;
 					DriverManagerDataSource dataSource = new DriverManagerDataSource();
 					dataSource.setDriverClassName(DATASOURCE_DRIVER_CLASS_NAME);

spring-cloud-starter-single-step-batch-job/src/test/java/org/springframework/cloud/task/batch/autoconfigure/kafka/KafkaItemReaderAutoConfigurationTests.java

@@ -71,17 +71,17 @@ public class KafkaItemReaderAutoConfigurationTests {
 		final String topicName = "topic1";
 		populateSingleTopic(topicName);
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(CustomMappingConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						KafkaItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5",
-						"spring.kafka.consumer.bootstrap-servers=" + embeddedKafkaBroker.getBrokersAsString(),
-						"spring.kafka.consumer.group-id=1", "spring.batch.job.kafkaitemreader.name=kafkaItemReader",
-						"spring.batch.job.kafkaitemreader.poll-time-out-in-seconds=2",
-						"spring.batch.job.kafkaitemreader.topic=" + topicName,
-						"spring.kafka.consumer.value-deserializer=" + JsonDeserializer.class.getName());
+			.withUserConfiguration(CustomMappingConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					KafkaItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5",
+					"spring.kafka.consumer.bootstrap-servers=" + embeddedKafkaBroker.getBrokersAsString(),
+					"spring.kafka.consumer.group-id=1", "spring.batch.job.kafkaitemreader.name=kafkaItemReader",
+					"spring.batch.job.kafkaitemreader.poll-time-out-in-seconds=2",
+					"spring.batch.job.kafkaitemreader.topic=" + topicName,
+					"spring.kafka.consumer.value-deserializer=" + JsonDeserializer.class.getName());
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -113,18 +113,18 @@ public class KafkaItemReaderAutoConfigurationTests {
 		final String topicName = "topic2";
 		populateSingleTopic(topicName);
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(CustomMappingConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						KafkaItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5",
-						"spring.kafka.consumer.bootstrap-servers=" + embeddedKafkaBroker.getBrokersAsString(),
-						"spring.kafka.consumer.group-id=1", "spring.batch.job.kafkaitemreader.name=kafkaItemReader",
-						"spring.batch.job.kafkaitemreader.partitions=0,1",
-						"spring.batch.job.kafkaitemreader.poll-time-out-in-seconds=2",
-						"spring.batch.job.kafkaitemreader.topic=" + topicName,
-						"spring.kafka.consumer.value-deserializer=" + JsonDeserializer.class.getName());
+			.withUserConfiguration(CustomMappingConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					KafkaItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5",
+					"spring.kafka.consumer.bootstrap-servers=" + embeddedKafkaBroker.getBrokersAsString(),
+					"spring.kafka.consumer.group-id=1", "spring.batch.job.kafkaitemreader.name=kafkaItemReader",
+					"spring.batch.job.kafkaitemreader.partitions=0,1",
+					"spring.batch.job.kafkaitemreader.poll-time-out-in-seconds=2",
+					"spring.batch.job.kafkaitemreader.topic=" + topicName,
+					"spring.kafka.consumer.value-deserializer=" + JsonDeserializer.class.getName());
 
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -150,16 +150,16 @@ public class KafkaItemReaderAutoConfigurationTests {
 		final String topicName = "topic3";
 		populateSingleTopic(topicName);
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(CustomMappingConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						KafkaItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5",
-						"spring.kafka.consumer.bootstrap-servers=" + embeddedKafkaBroker.getBrokersAsString(),
-						"spring.kafka.consumer.group-id=1", "spring.batch.job.kafkaitemreader.name=kafkaItemReader",
-						"spring.batch.job.kafkaitemreader.topic=" + topicName,
-						"spring.kafka.consumer.value-deserializer=" + JsonDeserializer.class.getName());
+			.withUserConfiguration(CustomMappingConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					KafkaItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5",
+					"spring.kafka.consumer.bootstrap-servers=" + embeddedKafkaBroker.getBrokersAsString(),
+					"spring.kafka.consumer.group-id=1", "spring.batch.job.kafkaitemreader.name=kafkaItemReader",
+					"spring.batch.job.kafkaitemreader.topic=" + topicName,
+					"spring.kafka.consumer.value-deserializer=" + JsonDeserializer.class.getName());
 		Date startTime = new Date();
 		applicationContextRunner.run((context) -> {
 			JobLauncher jobLauncher = context.getBean(JobLauncher.class);
@@ -196,7 +196,8 @@ public class KafkaItemReaderAutoConfigurationTests {
 	private void populateSingleTopic(String topic) {
 		Map<String, Object> configps = new HashMap<>(KafkaTestUtils.producerProps(embeddedKafkaBroker));
 		Producer<String, Object> producer = new DefaultKafkaProducerFactory<>(configps, new StringSerializer(),
-				new JsonSerializer<>()).createProducer();
+				new JsonSerializer<>())
+			.createProducer();
 		Map<String, Object> testMap = new HashMap<>();
 		testMap.put("first_name", "jane");
 		producer.send(new ProducerRecord<>(topic, "my-aggregate-id", testMap));

spring-cloud-starter-single-step-batch-job/src/test/java/org/springframework/cloud/task/batch/autoconfigure/kafka/KafkaItemWriterTests.java

@@ -68,15 +68,15 @@ public class KafkaItemWriterTests {
 	public void testBaseKafkaItemWriter() {
 		final String topicName = "topic1";
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(CustomMappingConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						KafkaItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5",
-						"spring.kafka.producer.bootstrap-servers=" + embeddedKafkaBroker.getBrokersAsString(),
-						"spring.kafka.producer.keySerializer=org.springframework.kafka.support.serializer.JsonSerializer",
-						"spring.batch.job.kafkaitemwriter.topic=" + topicName);
+			.withUserConfiguration(CustomMappingConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					KafkaItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=job", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5",
+					"spring.kafka.producer.bootstrap-servers=" + embeddedKafkaBroker.getBrokersAsString(),
+					"spring.kafka.producer.keySerializer=org.springframework.kafka.support.serializer.JsonSerializer",
+					"spring.batch.job.kafkaitemwriter.topic=" + topicName);
 
 		applicationContextRunner.run((context) -> {
 			waitForTopicPopulation(context);
@@ -87,7 +87,8 @@ public class KafkaItemWriterTests {
 	private void validateResults(String topicName) {
 		Map<String, Object> configs = new HashMap<>(KafkaTestUtils.consumerProps("1", "false", embeddedKafkaBroker));
 		Consumer<String, Object> consumer = new DefaultKafkaConsumerFactory<>(configs, new StringDeserializer(),
-				new JsonDeserializer<>()).createConsumer();
+				new JsonDeserializer<>())
+			.createConsumer();
 		consumer.subscribe(singleton(topicName));
 
 		ConsumerRecords<String, Object> consumerRecords = KafkaTestUtils.getRecords(consumer);

spring-cloud-starter-single-step-batch-job/src/test/java/org/springframework/cloud/task/batch/autoconfigure/rabbit/AmqpItemReaderAutoConfigurationTests.java

@@ -105,15 +105,15 @@ public class AmqpItemReaderAutoConfigurationTests {
 	@Test
 	void basicTest() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(BaseConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, AmqpItemReaderAutoConfiguration.class,
-								RabbitAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=integrationJob", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.amqpitemreader.enabled=true",
-						"spring.rabbitmq.template.default-receive-queue=foo", "spring.rabbitmq.host=" + host,
-						"spring.rabbitmq.port=" + amqpPort);
+			.withUserConfiguration(BaseConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, AmqpItemReaderAutoConfiguration.class,
+							RabbitAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=integrationJob", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.amqpitemreader.enabled=true",
+					"spring.rabbitmq.template.default-receive-queue=foo", "spring.rabbitmq.host=" + host,
+					"spring.rabbitmq.port=" + amqpPort);
 
 		applicationContextRunner.run((context) -> {
 			JobExecution jobExecution = runJob(context);
@@ -131,15 +131,15 @@ public class AmqpItemReaderAutoConfigurationTests {
 	@Test
 	void basicTestWithItemType() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(ItemTypeConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, AmqpItemReaderAutoConfiguration.class,
-								RabbitAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=integrationJob", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.amqpitemreader.enabled=true",
-						"spring.rabbitmq.template.default-receive-queue=foo", "spring.rabbitmq.host=" + host,
-						"spring.rabbitmq.port=" + amqpPort);
+			.withUserConfiguration(ItemTypeConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, AmqpItemReaderAutoConfiguration.class,
+							RabbitAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=integrationJob", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.amqpitemreader.enabled=true",
+					"spring.rabbitmq.template.default-receive-queue=foo", "spring.rabbitmq.host=" + host,
+					"spring.rabbitmq.port=" + amqpPort);
 
 		applicationContextRunner.run((context) -> {
 			JobExecution jobExecution = runJob(context);
@@ -156,13 +156,13 @@ public class AmqpItemReaderAutoConfigurationTests {
 	@Test
 	void useAmqpTemplateTest() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(MockTemplateConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						AmqpItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues("spring.batch.job.jobName=integrationJob", "spring.batch.job.stepName=step1",
-						"spring.batch.job.chunkSize=5", "spring.batch.job.amqpitemreader.enabled=true",
-						"spring.rabbitmq.host=" + host, "spring.rabbitmq.port=" + amqpPort);
+			.withUserConfiguration(MockTemplateConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					AmqpItemReaderAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues("spring.batch.job.jobName=integrationJob", "spring.batch.job.stepName=step1",
+					"spring.batch.job.chunkSize=5", "spring.batch.job.amqpitemreader.enabled=true",
+					"spring.rabbitmq.host=" + host, "spring.rabbitmq.port=" + amqpPort);
 
 		applicationContextRunner.run((context) -> {
 			runJob(context);

spring-cloud-starter-single-step-batch-job/src/test/java/org/springframework/cloud/task/batch/autoconfigure/rabbit/AmqpItemWriterAutoConfigurationTests.java

@@ -126,12 +126,12 @@ public class AmqpItemWriterAutoConfigurationTests {
 	@Test
 	void basicTest() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(BaseConfiguration.class)
-				.withConfiguration(
-						AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
-								SingleStepJobAutoConfiguration.class, AmqpItemWriterAutoConfiguration.class,
-								RabbitAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues(this.configurations);
+			.withUserConfiguration(BaseConfiguration.class)
+			.withConfiguration(
+					AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class, BatchAutoConfiguration.class,
+							SingleStepJobAutoConfiguration.class, AmqpItemWriterAutoConfiguration.class,
+							RabbitAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues(this.configurations);
 
 		applicationContextRunner.run((context) -> {
 			JobExecution jobExecution = runJob(context);
@@ -151,11 +151,11 @@ public class AmqpItemWriterAutoConfigurationTests {
 	@Test
 	void useAmqpTemplateTest() {
 		ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner()
-				.withUserConfiguration(MockConfiguration.class)
-				.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
-						BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
-						AmqpItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
-				.withPropertyValues(this.configurations);
+			.withUserConfiguration(MockConfiguration.class)
+			.withConfiguration(AutoConfigurations.of(PropertyPlaceholderAutoConfiguration.class,
+					BatchAutoConfiguration.class, SingleStepJobAutoConfiguration.class,
+					AmqpItemWriterAutoConfiguration.class, DataSourceAutoConfiguration.class))
+			.withPropertyValues(this.configurations);
 
 		applicationContextRunner.run((context) -> {
 			runJob(context);