Viewing CSV Files I (limited work time kata)

CSV_VIEWER_UI.java

enum CSV_VIEWER_UI {

	FIRST_PAGE_VIEW,
	NEXT_PAGE_VIEW,
	PREVIOUS_PAGE_VIEW,
	LAST_PAGE_VIEW;
}

CsvViewer.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class CsvViewer {

	private static final String FIRST_PAGE_KEY_ACTION = "F";
	private static final String NEXT_PAGE_KEY_ACTION = "N";
	private static final String PREVIOUS_PAGE_KEY_ACTION = "P";
	private static final String LAST_PAGE_KEY_ACTION = "L";
	private static final String EXIT_KEY_ACTION = "eX";
	private static final String CSV_DELIMITER = ";";
	private static final int DEFAULT_PAGE_LENGTH = 2;	
	
	private static final String WRONG_COMMAND_LINE_ARGUMENTS = "\nWrong command line arguments!\n" +
	                                                           "Usage: java CsvViewer filename [pagelength]";	
	private CsvViewerConsoleUI view;
	
	public static void main(final String ... args) {
		
		final CommandLineArguments commandLineArguments = assertCommanLineArguments(args);		
		final CsvViewer csvViewerConsole = new CsvViewer(commandLineArguments.filename(), 
				                                 commandLineArguments.pageLength());							 
		csvViewerConsole.actionHandler();
	}

	private static class CommandLineArguments {
		
		private final String filename;
		private final int pageLength;
		
		private CommandLineArguments(final String filename) {
			
			this(filename, DEFAULT_PAGE_LENGTH);
		}
		
		private CommandLineArguments(final String filename,
				             final int pageLength) {
		
			this.filename = filename;
			this.pageLength= pageLength;			
		}

		private String filename() {
			
			return filename;
		}

		private int pageLength() {
			
			return pageLength;
		}				
	}
	
	private static CommandLineArguments assertCommanLineArguments(final String... args) {
		
		if(null == args || args.length == 0) {
					
			throw new IllegalArgumentException(WRONG_COMMAND_LINE_ARGUMENTS);
		}
		else if(args.length == 1) {
		
			return new CommandLineArguments(args[0]);
		}
		else if(args.length == 2) {
		
			int pageLength = assertPageLengthArgument(args);
			return new CommandLineArguments(args[0], pageLength);
		}
		
		throw new IllegalArgumentException(WRONG_COMMAND_LINE_ARGUMENTS);
	}

	private static int assertPageLengthArgument(final String... args) {
		
		try {
		
			return Integer.parseInt(args[1]);
		}
		catch(NumberFormatException ex) {
			
			throw new IllegalArgumentException(WRONG_COMMAND_LINE_ARGUMENTS);
		}
	}
	
	private CsvViewer(final String filename, final int pageLength) {
		
		initialize(filename, pageLength);
	}

	private void initialize(final String filename, final int pageLength) {
		
		view = CsvViewerConsoleUI.newInstance(CsvViewerController.newInstance(filename, pageLength, CSV_DELIMITER));			
	}
	
	private void actionHandler() {
		
		view.page(CSV_VIEWER_UI.FIRST_PAGE_VIEW);	
		
		BufferedReader buffer = null;
		try {
			
			buffer = new BufferedReader(new InputStreamReader(System.in));
			String input;
			while ((input = buffer.readLine()) != null) {
			  			 
			     if(input.equalsIgnoreCase(FIRST_PAGE_KEY_ACTION)) {
					
				 view.page(CSV_VIEWER_UI.FIRST_PAGE_VIEW);	
			     }
			     else if(input.equalsIgnoreCase(NEXT_PAGE_KEY_ACTION)) {
					 					 					
			    	 view.page(CSV_VIEWER_UI.NEXT_PAGE_VIEW);	
			     }
			     else if(input.equalsIgnoreCase(PREVIOUS_PAGE_KEY_ACTION)) {

				 view.page(CSV_VIEWER_UI.PREVIOUS_PAGE_VIEW);	
			     }
		             else if(input.equalsIgnoreCase(LAST_PAGE_KEY_ACTION)) {

				 view.page(CSV_VIEWER_UI.LAST_PAGE_VIEW);	
			     }
			     else if(input.equalsIgnoreCase(EXIT_KEY_ACTION)) {
					 					 
				 view.goodByeMessage();
				 break;
			     }
			     else {
					 
			         view.prompt();
			     }					
			 }		
		}
		catch(IOException ex) {
			
			throw new IllegalStateException("Can't read from command line (standard input): ", ex);
		}
		finally {
			
			if(null != buffer) {
				
				try {
					
					buffer.close();
				} 
				catch (IOException ex) {
				
					throw new IllegalStateException("Can't close command line (standard input): ", ex);
				}
			}
		}
	}
}

CsvViewerConsoleUI.java

class CsvViewerConsoleUI {

	private static final String CONSOLE_MENU_BAR = "N(ext page, P(revious page, F(irst page, L(ast page, eX(it\n";
	private static final String GOOD_BYE_CSV_VIEWER_MESSAGE = "Good bye CsvViewer...\n";
	private static final String CONSOLE_PROMPT = ">";

	private String tableColumnWidthFormat;
	private int tableWidth;
	
	private CsvViewerController controller;
	
	static CsvViewerConsoleUI newInstance(final CsvViewerController controller) {
		
		return new CsvViewerConsoleUI(controller);
	}
	
	private CsvViewerConsoleUI(final CsvViewerController controller) {
		
		this.controller = controller;
		
		initialize();	
	}

	private void initialize() {
		
		tableColumnWidthFormat = calculateTableColumnWidthFormat();		
		tableWidth = calculateTableWidth();		
	}
	
	public void page(final CSV_VIEWER_UI pageViewType) {
					
		clear();
		horizontalDelimiter();		
		print(controller.header());		
		horizontalDelimiter();
		
		for(CsvViewerEntry entry: pageViewEntries(pageViewType)) {
			
			print(entry);
		}
		
		horizontalDelimiter();
		
		menuBar();
		prompt();
	}

	private void menuBar() {
		
		System.out.printf(CONSOLE_MENU_BAR);
	}

	public void prompt() {
		
		System.out.printf(CONSOLE_PROMPT);
	}

	public CsvViewerEntry[] pageViewEntries(final CSV_VIEWER_UI pageViewType) {
		
		switch(pageViewType) {
		
			case FIRST_PAGE_VIEW:
			default:				
				return controller.firstPage();			
				
			case NEXT_PAGE_VIEW:
				
				return controller.nextPage();
				
			case PREVIOUS_PAGE_VIEW:
				
				return controller.previousPage();
				
			case LAST_PAGE_VIEW:
				
				return controller.lastPage();
		}
	}

	void print(final CsvViewerEntry entry) {
							
		System.out.printf(tableColumnWidthFormat, 
				  (Object[]) entry.getColumns());
	}

	private void horizontalDelimiter() {
				
		for(int i= 0; i < tableWidth; i++) {
			
			System.out.printf("%s","-");
		}
		
		System.out.printf("\n");
	}
	
	private String calculateTableColumnWidthFormat() {
		
		final StringBuilder strBuilder = new StringBuilder();
		int[] columnsWidths = controller.columnWidths();
		for(int i = 0; i < columnsWidths.length; i++) {
			    strBuilder.append("|%-");		
				strBuilder.append(columnsWidths[i]);
				strBuilder.append("s");
		}
		strBuilder.append("|\n");
		
		return strBuilder.toString();
	}
	
	private int calculateTableWidth() {
		
		return controller.tableWidth() + controller.columnWidths().length + 1;
	}
	
        private void clear() {
		
    	        final int CONSOLE_WINDOW_HEIGHT = 80;
		for(int i= 0; i < CONSOLE_WINDOW_HEIGHT; i++) {
			
			System.out.printf("\n");
		}
	}
    
        public void goodByeMessage() {
    	
    	     horizontalDelimiter();
    	     System.out.printf(GOOD_BYE_CSV_VIEWER_MESSAGE);
    	     horizontalDelimiter();
        }
}

CsvViewerController.java

class CsvViewerController {
	
	private CsvViewerModel model;
		
	static CsvViewerController newInstance(final String filename, 
			                       final int pageLength, 
			                       final String delimiter) {
		
		return new CsvViewerController(filename, pageLength, delimiter);
	}
	
	private CsvViewerController(final String filename, 
			            final int pageLength,
			            final String delimiter) {
				
		this.model = CsvViewerModel.newInstance(filename, pageLength, delimiter);
	}
	
	CsvViewerEntry header() {
		
		return model.header();
	}
	
	CsvViewerEntry[] firstPage() {
	
		return model.firstPage();
    }

	CsvViewerEntry[] lastPage() {
		
		return model.lastPage();
	}
	
	CsvViewerEntry[] nextPage() {

		return model.nextPage();
	}
		
	CsvViewerEntry[] previousPage() {

		return model.previousPage();
	}
	
	int[] columnWidths() {
		
		return model.columnWidths();
	}

        int tableWidth() {
    	
		return model.tableWidth();
	}    
}

CsvViewerEntry.java

class CsvViewerEntry {
	
	private final int index;
	
	private final String columns[];
	
	CsvViewerEntry(final int index, 
		       final String columns[]) {
		
		this.index = index;
		this.columns = columns;
	}

	String[] getColumns() {
		
		return columns;
	}

	int getIndex() {
		
		return index;
	}

	@Override
	public int hashCode() {
		
		final int prime = 31;
		int result = 1;
		result = prime * result + index;
		
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		final CsvViewerEntry other = (CsvViewerEntry) obj;
		if (index != other.index)
			return false;
		
		return true;
	}

	@Override
	public String toString() {
				
		return "|" + index + "|";
	}		
}

CsvViewerFormatter.java

class CsvViewerFormatter {
	
	private int columnsWidths[];

	static CsvViewerFormatter newInstance() {
		
		return new CsvViewerFormatter();
	}
		
	void recalculateColumnWidths(final String[] columns) {
		
		createColumnsWidthsField(columns);		
		caluclateColumnWidth(columns);
	}

	private void caluclateColumnWidth(final String[] columns) {
		
		for(int i = 0; i < columns.length; i++) {
			
			if(columns[i].length() > columnsWidths[i]) {
				
				columnsWidths[i] = columns[i].length();
			}
		}
	}
	
	private void createColumnsWidthsField(final String[] columns) {
		
		if(null == columnsWidths) {
			
			columnsWidths = new int[columns.length];
		}
	}

	int[] columnWidths() {
		
		return columnsWidths;
	}
	
        int tableWidth() {
    	
    	        int tableWidth = 0;
		for(int i = 0; i < columnsWidths.length; i++) {
	
				tableWidth += columnsWidths[i];
		}
		
		return tableWidth;
	}
}

CsvViewerModel.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;

class CsvViewerModel {

	private static final int HEADER_ID = 0;
	private static final int FIRST_PAGE_ID = 1;
	
	private final int pageLength;
	private final String delimiter;

	private CsvViewerEntry[] entries;
	private int currentPage = FIRST_PAGE_ID;
	
	private CsvViewerFormatter formatter;

	static CsvViewerModel newInstance(final String filename, 
			                  final int pageLength, 
			                  final String delimiter) {
				
		return new CsvViewerModel(filename, pageLength, delimiter);
	}
	
	private CsvViewerModel(final String filename,
			       final int pageLength,
			       final String delimiter) {
		
		this.pageLength = pageLength;
		this.delimiter = delimiter;	
		
		initialize(filename);		
	}
	
	private void initialize(final String filename) {
		
		formatter = CsvViewerFormatter.newInstance();
		
		final Map<CsvViewerEntry, CsvViewerEntry> csvEntries = readCsvFile(filename);		
		entries = csvEntries.values().toArray(new CsvViewerEntry[0]);
	}
	
	CsvViewerEntry header() {
		
		return entries[HEADER_ID];
	}
	
	CsvViewerEntry[] firstPage() {
	
		currentPage = 1;
		return Arrays.copyOfRange(entries, currentPage, currentPage + pageLength);
    }

	CsvViewerEntry[] lastPage() {
		
		currentPage= entries.length - pageLength;		
		return Arrays.copyOfRange(entries, currentPage, currentPage + pageLength);
	}
	
	CsvViewerEntry[] nextPage() {

		currentPage+= pageLength;
		if(currentPage + pageLength <= entries.length) { 
		
			return Arrays.copyOfRange(entries, currentPage, currentPage + pageLength);
		}
		
		currentPage= entries.length - pageLength;
		return Arrays.copyOfRange(entries, currentPage, entries.length);
	}
		
	CsvViewerEntry[] previousPage() {

		currentPage-= pageLength;
		if(currentPage <= FIRST_PAGE_ID) { 
		
			return firstPage();
		}
				
		return Arrays.copyOfRange(entries, currentPage, currentPage + pageLength);
	}
	
	Map<CsvViewerEntry, CsvViewerEntry> readCsvFile(final String filename) {
		
		Map<CsvViewerEntry, CsvViewerEntry> csvEntries;
		try {
			
			csvEntries = read(filename);
		} 
		catch (IOException ex) {
		
			throw new IllegalStateException("Can't read csv file: ", ex);
		}
		return csvEntries;
	}
	
	private Map<CsvViewerEntry,CsvViewerEntry> read(final String csvFilename) throws IOException {

		if(csvFilename == null || csvFilename.trim().length() == 0) {
			
			throw new IllegalArgumentException(String.format("Filename %s must not be null or empty!", csvFilename));			
		}
		
		final Map<CsvViewerEntry,CsvViewerEntry> csvEntries = new LinkedHashMap<CsvViewerEntry, CsvViewerEntry>();
		BufferedReader reader = null;
		try {
			
			reader = new BufferedReader(new FileReader(csvFilename));
		    String line; int lineNumber = 0;

		    while ((line = reader.readLine()) != null) {		    
	        
		    	parseLine(csvEntries, line, lineNumber++);
		    }		    		    			
		}
		finally {
			
			if(null != reader) {
				
				reader.close();
			}
		}
		
		return Collections.unmodifiableMap(csvEntries);
	}

	private void parseLine(final Map<CsvViewerEntry,CsvViewerEntry> csvEntries, 
                               final String line, final int lineNumber) {
	
		final String columns[] = line.split(delimiter);	            
		final CsvViewerEntry entry = new CsvViewerEntry(lineNumber, columns);
		csvEntries.put(entry, entry);
				
		formatter.recalculateColumnWidths(columns);
	}
	
	int[] columnWidths() {
		
		return formatter.columnWidths();
	}
   
        int tableWidth() {
    	
		return formatter.tableWidth();
	}
}

CsvViewerTest.java

import static org.junit.Assert.assertEquals;

import java.util.Map;

import org.junit.Before;
import org.junit.Test;

public class CsvViewerTest {

	private static final String CSV_EVEN_COUNT_FILE_ENTRIES = "{Root-Pfad}//katas//csv//kata_even.csv";
	private static final String CSV_ODD_COUNT_FILE_ENTRIES = "{Root-Pfad}//katas//csv//kata_odd.csv";
	private static final int DOUBLE_PAGE = 2;
	private static final int TRIPLE_PAGE = 3;
	private static final String DELIMITER = ";";

	private CsvViewerModel csvViewerModel;
	private CsvViewerModel csvOddTwoEntriesPageLengthModel;
	private CsvViewerModel csvOddThreeEntriesPageLengthModel;	
	private CsvViewerModel csvEvenTwoEntriesPageLengthModel;
	private CsvViewerModel csvEvenThreeEntriesPageLengthModel;
			
	@Before
	public void setUp() throws Exception {
		
		csvViewerModel = CsvViewerModel.newInstance(CSV_ODD_COUNT_FILE_ENTRIES, DOUBLE_PAGE, DELIMITER);		
		csvOddTwoEntriesPageLengthModel = CsvViewerModel.newInstance(CSV_ODD_COUNT_FILE_ENTRIES, DOUBLE_PAGE, DELIMITER);	
		csvOddThreeEntriesPageLengthModel = CsvViewerModel.newInstance(CSV_ODD_COUNT_FILE_ENTRIES, TRIPLE_PAGE, DELIMITER);
		csvEvenTwoEntriesPageLengthModel = CsvViewerModel.newInstance(CSV_EVEN_COUNT_FILE_ENTRIES, DOUBLE_PAGE, DELIMITER);		
		csvEvenThreeEntriesPageLengthModel = CsvViewerModel.newInstance(CSV_EVEN_COUNT_FILE_ENTRIES, TRIPLE_PAGE, DELIMITER);
	}

	@Test
	public void testHeader() {
				
		assertEquals(new CsvViewerEntry(0,new String[]{"Name","Age","City"}), csvOddTwoEntriesPageLengthModel.header());
	}
	
	@Test
	public void testFirstPageTwoEntriesPageLengthOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(1,new String[]{"","",""}), 
				                        new CsvViewerEntry(2,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvOddTwoEntriesPageLengthModel.firstPage();
		
		assertPaging(testFixture, page);
	}

	@Test
	public void testNextPageTwoEntriesPageLengthOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(3,new String[]{"","",""}), 
				                        new CsvViewerEntry(4,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvOddTwoEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
	
	@Test
	public void testNextPageTwoEntriesPageLengthWithLimitOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(5,new String[]{"","",""}), 
				                        new CsvViewerEntry(6,new String[]{"","",""})};
		
		csvOddTwoEntriesPageLengthModel.nextPage();		
		final CsvViewerEntry[] page = csvOddTwoEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
	
	@Test
	public void testNextPageTwoEntriesPageLengthWithOverflowOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(6,new String[]{"","",""}), 
				                        new CsvViewerEntry(7,new String[]{"","",""})};
		
		csvOddTwoEntriesPageLengthModel.nextPage();
		csvOddTwoEntriesPageLengthModel.nextPage();
		csvOddTwoEntriesPageLengthModel.nextPage();
		csvOddTwoEntriesPageLengthModel.nextPage();
		final CsvViewerEntry[] page = csvOddTwoEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
	
	@Test
	public void testPreviousPageTwoEntriesPageLengthOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(4,new String[]{"","",""}), 
				                        new CsvViewerEntry(5,new String[]{"","",""})};
		
		csvOddTwoEntriesPageLengthModel.lastPage();		
		final CsvViewerEntry[] page = csvOddTwoEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testPreviousPageTwoEntriesPageLengthWithLimitOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(2,new String[]{"","",""}), 
				                        new CsvViewerEntry(3,new String[]{"","",""})};
		
		csvOddTwoEntriesPageLengthModel.lastPage();	
		csvOddTwoEntriesPageLengthModel.previousPage();
		final CsvViewerEntry[] page = csvOddTwoEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testPreviousPageTwoEntriesPageLengthWithOverflowOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(1,new String[]{"","",""}), 
				                        new CsvViewerEntry(2,new String[]{"","",""})};
		
		csvOddTwoEntriesPageLengthModel.lastPage();
		csvOddTwoEntriesPageLengthModel.previousPage();
		csvOddTwoEntriesPageLengthModel.previousPage();
		csvOddTwoEntriesPageLengthModel.previousPage();
		csvOddTwoEntriesPageLengthModel.previousPage();
		final CsvViewerEntry[] page = csvOddTwoEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testLastPageTwoEntriesPageLengthOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(6,new String[]{"","",""}), 
				new CsvViewerEntry(7,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvOddTwoEntriesPageLengthModel.lastPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testFirstPageTwoEntriesPageLengthEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(1,new String[]{"","",""}), 
				                        new CsvViewerEntry(2,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvEvenTwoEntriesPageLengthModel.firstPage();
		
		assertPaging(testFixture, page);
	}

	@Test
	public void testNextPageTwoEntriesPageLengthEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(3,new String[]{"","",""}), 
				                        new CsvViewerEntry(4,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvEvenTwoEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
	
	@Test
	public void testNextPageTwoEntriesPageLengthWithLimitEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(5,new String[]{"","",""}), 
				                        new CsvViewerEntry(6,new String[]{"","",""})};
		
		csvEvenTwoEntriesPageLengthModel.nextPage();		
		final CsvViewerEntry[] page = csvEvenTwoEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
	
	@Test
	public void testNextPageTwoEntriesPageLengthWithOverflowEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(7,new String[]{"","",""}), 
				                        new CsvViewerEntry(8,new String[]{"","",""})};
		
		csvEvenTwoEntriesPageLengthModel.nextPage();
		csvEvenTwoEntriesPageLengthModel.nextPage();
		csvEvenTwoEntriesPageLengthModel.nextPage();
		csvEvenTwoEntriesPageLengthModel.nextPage();
		final CsvViewerEntry[] page = csvEvenTwoEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
	
	@Test
	public void testPreviousPageTwoEntriesPageLengthEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(5,new String[]{"","",""}), 
				                        new CsvViewerEntry(6,new String[]{"","",""})};
		
		csvEvenTwoEntriesPageLengthModel.lastPage();		
		final CsvViewerEntry[] page = csvEvenTwoEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testPreviousPageTwoEntriesPageLengthWithLimitEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(3,new String[]{"","",""}), 
				                        new CsvViewerEntry(4,new String[]{"","",""})};
		
		csvEvenTwoEntriesPageLengthModel.lastPage();	
		csvEvenTwoEntriesPageLengthModel.previousPage();
		final CsvViewerEntry[] page = csvEvenTwoEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testPreviousPageTwoEntriesPageLengthWithOverflowEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(1,new String[]{"","",""}), 
				                        new CsvViewerEntry(2,new String[]{"","",""})};
		
		csvEvenTwoEntriesPageLengthModel.lastPage();
		csvEvenTwoEntriesPageLengthModel.previousPage();
		csvEvenTwoEntriesPageLengthModel.previousPage();
		csvEvenTwoEntriesPageLengthModel.previousPage();
		csvEvenTwoEntriesPageLengthModel.previousPage();
		final CsvViewerEntry[] page = csvEvenTwoEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testLastPageTwoEntriesPageLengthEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(7,new String[]{"","",""}), 
				                        new CsvViewerEntry(8,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvEvenTwoEntriesPageLengthModel.lastPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testFirstPageThreeEntriesPageLengthOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(1,new String[]{"","",""}), 
				                        new CsvViewerEntry(2,new String[]{"","",""}),
				                        new CsvViewerEntry(3,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvOddThreeEntriesPageLengthModel.firstPage();
		
		assertPaging(testFixture, page);
	}

	@Test
	public void testNextPageThreeEntriesPageLengthOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(4,new String[]{"","",""}), 
				                        new CsvViewerEntry(5,new String[]{"","",""}),
				                        new CsvViewerEntry(6,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvOddThreeEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
	
	@Test
	public void testNextPageThreeEntriesPageLengthWithLimitOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(5,new String[]{"","",""}), 
				                        new CsvViewerEntry(6,new String[]{"","",""}),
				                        new CsvViewerEntry(7,new String[]{"","",""})};
		
		csvOddThreeEntriesPageLengthModel.nextPage();
		
		final CsvViewerEntry[] page = csvOddThreeEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
	
	@Test
	public void testNextPageThreeEntriesPageLengthWithOverflowOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(5,new String[]{"","",""}), 
				                        new CsvViewerEntry(6,new String[]{"","",""}),
				                        new CsvViewerEntry(7,new String[]{"","",""})};
		
		csvOddThreeEntriesPageLengthModel.nextPage();
		csvOddThreeEntriesPageLengthModel.nextPage();
		csvOddThreeEntriesPageLengthModel.nextPage();
		csvOddThreeEntriesPageLengthModel.nextPage();
		final CsvViewerEntry[] page = csvOddThreeEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
		
	@Test
	public void testPreviousPageThreeEntriesPageLengthOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(2,new String[]{"","",""}), 
				                        new CsvViewerEntry(3,new String[]{"","",""}),
				                        new CsvViewerEntry(4,new String[]{"","",""})};
		
		csvOddThreeEntriesPageLengthModel.lastPage();
		final CsvViewerEntry[] page = csvOddThreeEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testPreviousPageThreeEntriesPageLengthWithLimitOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(1,new String[]{"","",""}), 
				                        new CsvViewerEntry(2,new String[]{"","",""}),
				                        new CsvViewerEntry(3,new String[]{"","",""})};
		
		csvOddThreeEntriesPageLengthModel.lastPage();
		csvOddThreeEntriesPageLengthModel.previousPage();
		final CsvViewerEntry[] page = csvOddThreeEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testPreviousPageThreeEntriesPageLengthWithOverflowOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(1,new String[]{"","",""}), 
				                        new CsvViewerEntry(2,new String[]{"","",""}),
				                        new CsvViewerEntry(3,new String[]{"","",""})};
		
		csvOddThreeEntriesPageLengthModel.lastPage();
		csvOddThreeEntriesPageLengthModel.previousPage();
		csvOddThreeEntriesPageLengthModel.previousPage();
		csvOddThreeEntriesPageLengthModel.previousPage();
		csvOddThreeEntriesPageLengthModel.previousPage();
		final CsvViewerEntry[] page = csvOddThreeEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testLastPageThreeEntriesPageLengthOdd() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(5,new String[]{"","",""}), 
				                        new CsvViewerEntry(6,new String[]{"","",""}),
				                        new CsvViewerEntry(7,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvOddThreeEntriesPageLengthModel.lastPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testFirstPageThreeEntriesPageLengthEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(1,new String[]{"","",""}), 
				                        new CsvViewerEntry(2,new String[]{"","",""}),
				                        new CsvViewerEntry(3,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvEvenThreeEntriesPageLengthModel.firstPage();
		
		assertPaging(testFixture, page);
	}

	@Test
	public void testNextPageThreeEntriesPageLengthEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(4,new String[]{"","",""}), 
				                        new CsvViewerEntry(5,new String[]{"","",""}),
				                        new CsvViewerEntry(6,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvEvenThreeEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
	
	@Test
	public void testNextPageThreeEntriesPageLengthWithLimitEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(6,new String[]{"","",""}), 
				                        new CsvViewerEntry(7,new String[]{"","",""}),
				                        new CsvViewerEntry(8,new String[]{"","",""})};
		
		csvEvenThreeEntriesPageLengthModel.nextPage();
		
		final CsvViewerEntry[] page = csvEvenThreeEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
	
	@Test
	public void testNextPageThreeEntriesPageLengthWithOverflowEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(6,new String[]{"","",""}), 
				                        new CsvViewerEntry(7,new String[]{"","",""}),
				                        new CsvViewerEntry(8,new String[]{"","",""})};
		
		csvEvenThreeEntriesPageLengthModel.nextPage();
		csvEvenThreeEntriesPageLengthModel.nextPage();
		csvEvenThreeEntriesPageLengthModel.nextPage();
		csvEvenThreeEntriesPageLengthModel.nextPage();
		final CsvViewerEntry[] page = csvEvenThreeEntriesPageLengthModel.nextPage();
		
		assertPaging(testFixture, page);
    }
		
	@Test
	public void testPreviousPageThreeEntriesPageLengthEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(3,new String[]{"","",""}), 
				                        new CsvViewerEntry(4,new String[]{"","",""}),
				                        new CsvViewerEntry(5,new String[]{"","",""})};
		
		csvEvenThreeEntriesPageLengthModel.lastPage();
		final CsvViewerEntry[] page = csvEvenThreeEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testPreviousPageThreeEntriesPageLengthWithLimitEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(1,new String[]{"","",""}), 
				                        new CsvViewerEntry(2,new String[]{"","",""}),
				                        new CsvViewerEntry(3,new String[]{"","",""})};
		
		csvEvenThreeEntriesPageLengthModel.lastPage();
		csvEvenThreeEntriesPageLengthModel.previousPage();
		final CsvViewerEntry[] page = csvEvenThreeEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testPreviousPageThreeEntriesPageLengthWithOverflowEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(1,new String[]{"","",""}), 
				                        new CsvViewerEntry(2,new String[]{"","",""}),
				                        new CsvViewerEntry(3,new String[]{"","",""})};
		
		csvEvenThreeEntriesPageLengthModel.lastPage();
		csvEvenThreeEntriesPageLengthModel.previousPage();
		csvEvenThreeEntriesPageLengthModel.previousPage();
		csvEvenThreeEntriesPageLengthModel.previousPage();
		csvEvenThreeEntriesPageLengthModel.previousPage();
		final CsvViewerEntry[] page = csvEvenThreeEntriesPageLengthModel.previousPage();
		
		assertPaging(testFixture, page);
	}
	
	@Test
	public void testLastPageThreeEntriesPageLengthEven() {
		
		final CsvViewerEntry[] testFixture = {new CsvViewerEntry(6,new String[]{"","",""}), 
				                        new CsvViewerEntry(7,new String[]{"","",""}),
				                        new CsvViewerEntry(8,new String[]{"","",""})};
		
		final CsvViewerEntry[] page = csvEvenThreeEntriesPageLengthModel.lastPage();
		
		assertPaging(testFixture, page);
	}

	@Test
	public void testReadWithCorrectFormat() {
		
		final Map<CsvViewerEntry, CsvViewerEntry> csvEntries = csvViewerModel.readCsvFile(CSV_ODD_COUNT_FILE_ENTRIES);		
		final CsvViewerEntry csvEntry = csvEntries.get(new CsvViewerEntry(0,new String[]{"Name","Age","City"}));
		
		assertEquals(csvEntries.get(csvEntry), csvEntry);
	}

	@Test(expected=IllegalArgumentException.class)
	public void testReadWithFilenameEqualsNull() {
		
		csvViewerModel.readCsvFile(null);		
	}

	@Test(expected=IllegalArgumentException.class)
	public void testReadWithEmptyFilename() {
		
		csvViewerModel.readCsvFile("");		
    }
	
	private void assertPaging(final CsvViewerEntry[] testFixture, final CsvViewerEntry[] page) {
		
		for(int i = 0; i < page.length; i++) {
			
			assertEquals(testFixture[i], page[i]);
		}
	}
}

kata_odd.csv

Name;Age;City
Peter;42;New York
Paul;57;London
Mary;35;Munich
Jaques;66;Paris
Yuri;23;Moscow
Stephanie;47;Stockholm
Nadia;29;Madrid

TODOs:

(1) improve command line parsing
(a) pagelength <= 0
(b) pagelength > count csv file lines

(2) parameterized unit test (@RunWith / @parameters annotations)

(3) rename page to showPage or viewPage in class CsvViewerConsoleUI

(4) refactor table width

(5) write more unit tests for formatter and user interface

31.05.2011/JR