#SpringBatch SynchronizedItemStreamWriterTest PR#665 for BATCH-2762

SynchronizedItemStreamWriterTest.java

package org.springframework.batch.item.support;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.verification.VerificationMode;

import org.springframework.batch.item.ExecutionContext;
import org.springframework.batch.item.ItemStreamWriter;

@RunWith(MockitoJUnitRunner.class)
public class SynchronizedItemStreamWriterTest {

	@Mock
	private ItemStreamWriter<Integer> delegate;

	private List<Integer> items = new ArrayList<>(10);

	private SynchronizedItemStreamWriter<Integer> synchronizedItemStreamWriter = new SynchronizedItemStreamWriter<>();

	@Before
	public void setUp() throws Exception {
		synchronizedItemStreamWriter.setDelegate(delegate);
	}

	@Test
	public void write() throws Exception {

		class WorkerThread extends Thread {

			private SynchronizedItemStreamWriter<Integer> synchronizedItemStreamWriter;
			private List<Integer> itemsToWrite;

			private WorkerThread(SynchronizedItemStreamWriter<Integer> synchronizedItemStreamWriter, List<Integer> itemsToWrite) {
				this.synchronizedItemStreamWriter = synchronizedItemStreamWriter;
				this.itemsToWrite = itemsToWrite;
			}

			@Override
			public void run() {
				try {
					System.out.println("itemsToWrite = " + itemsToWrite);
					synchronizedItemStreamWriter.write(itemsToWrite);
				} catch (Exception e) {
					throw new RuntimeException(e);
				}
			}
		}

		WorkerThread[] workerThreads = new WorkerThread[10];
		for (int i = 0; i < 10; i++) {
			WorkerThread workerThread = new WorkerThread(synchronizedItemStreamWriter, Collections.singletonList(i));
			workerThreads[i] = workerThread;
			workerThread.start();
		}

		for (int i = 0; i < 10; i++) {
			workerThreads[i].join();
		}

		Mockito.verify(delegate, Mockito.times(10)).write(Mockito.any());
	}

	@Test
	public void open() {
		ExecutionContext executionContext = new ExecutionContext();
		synchronizedItemStreamWriter.open(executionContext);

		Mockito.verify(delegate).open(executionContext);
	}

	@Test
	public void update() {
		ExecutionContext executionContext = new ExecutionContext();
		synchronizedItemStreamWriter.update(executionContext);

		Mockito.verify(delegate).update(executionContext);
	}

	@Test
	public void close() {
		synchronizedItemStreamWriter.close();

		Mockito.verify(delegate).close();
	}

}