477 lines
14 KiB
Java
477 lines
14 KiB
Java
package terminal;
|
|
|
|
import static org.junit.Assert.*;
|
|
import static terminal.LispTerminal.END_OF_SEGMENT;
|
|
|
|
import java.io.*;
|
|
|
|
import org.junit.*;
|
|
|
|
import com.googlecode.lanterna.*;
|
|
import com.googlecode.lanterna.input.*;
|
|
import com.googlecode.lanterna.terminal.virtual.*;
|
|
|
|
public class LispTerminalTest {
|
|
|
|
private PipedInputStream inputReader;
|
|
private PipedOutputStream inputWriter;
|
|
private PipedInputStream outputReader;
|
|
private PipedOutputStream outputWriter;
|
|
private FlushListener flushListener;
|
|
private VirtualTerminal virtualTerminal;
|
|
private LispTerminal lispTerminal;
|
|
|
|
private void pressKey(KeyType keyType) {
|
|
virtualTerminal.addInput(new KeyStroke(keyType));
|
|
waitForFlushes(1);
|
|
}
|
|
|
|
private void pressKeyTimes(KeyType keyType, int times) {
|
|
for (int i = times; i > 0; i--)
|
|
virtualTerminal.addInput(new KeyStroke(keyType));
|
|
|
|
waitForFlushes(times);
|
|
}
|
|
|
|
private void pressControlKey(KeyType keyType) {
|
|
virtualTerminal.addInput(new KeyStroke(keyType, true, false));
|
|
waitForFlushes(1);
|
|
}
|
|
|
|
private void enterCharacter(char character) {
|
|
virtualTerminal.addInput(new KeyStroke(character, false, false));
|
|
waitForFlushes(1);
|
|
}
|
|
|
|
private void enterControlCharacter(char character) {
|
|
virtualTerminal.addInput(new KeyStroke(character, true, false));
|
|
waitForFlushes(1);
|
|
}
|
|
|
|
private void enterCharacters(String characters) {
|
|
for (char c : characters.toCharArray())
|
|
virtualTerminal.addInput(new KeyStroke(c, false, false));
|
|
|
|
waitForFlushes(characters.length());
|
|
}
|
|
|
|
private void produceOutput(String output) {
|
|
try {
|
|
for (char c : output.toCharArray())
|
|
outputWriter.write(c);
|
|
|
|
outputWriter.write(END_OF_SEGMENT);
|
|
outputWriter.flush();
|
|
waitForFlushes(1);
|
|
} catch (IOException ignored) {}
|
|
}
|
|
|
|
private void waitForFlushes(int flushCount) {
|
|
try {
|
|
synchronized (flushListener) {
|
|
while (flushListener.getFlushCount() < flushCount)
|
|
flushListener.wait();
|
|
|
|
flushListener.resetFlushCount();
|
|
}
|
|
} catch (InterruptedException ignored) {}
|
|
}
|
|
|
|
private void setColumns(int columns) {
|
|
int rows = virtualTerminal.getTerminalSize().getRows();
|
|
virtualTerminal.setTerminalSize(new TerminalSize(columns, rows));
|
|
}
|
|
|
|
private void setRows(int rows) {
|
|
int columns = virtualTerminal.getTerminalSize().getColumns();
|
|
virtualTerminal.setTerminalSize(new TerminalSize(columns, rows));
|
|
}
|
|
|
|
private void assertCursorPosition(int column, int row) {
|
|
assertEquals(column, virtualTerminal.getCursorPosition().getColumn());
|
|
assertEquals(row, virtualTerminal.getCursorPosition().getRow());
|
|
}
|
|
|
|
private void assertCharacterAtPosition(char character, int column, int row) {
|
|
TerminalPosition position = new TerminalPosition(column, row);
|
|
String expected = String.valueOf(character);
|
|
String actual = String.valueOf(virtualTerminal.getCharacter(position).getCharacter());
|
|
assertEquals(expected, actual);
|
|
}
|
|
|
|
private void assertCharacterPositions(char[][] positions) {
|
|
for (int row = 0; row < positions.length; row++)
|
|
for (int column = 0; column < positions[row].length; column++)
|
|
assertCharacterAtPosition(positions[row][column], column, row);
|
|
}
|
|
|
|
private void assertInputWritten(String expected) {
|
|
String actual = "";
|
|
|
|
try {
|
|
inputWriter.close();
|
|
|
|
for (int c = inputReader.read(); c != -1; c = inputReader.read())
|
|
actual += (char) c;
|
|
} catch (IOException ignored) {}
|
|
|
|
assertEquals(expected, actual);
|
|
}
|
|
|
|
private void assertInputStreamClosed() {
|
|
try {
|
|
inputWriter.write(0);
|
|
fail("input stream not closed");
|
|
} catch (IOException ignored) {}
|
|
}
|
|
|
|
@Before
|
|
public void setUp() throws IOException {
|
|
inputReader = new PipedInputStream();
|
|
inputWriter = new PipedOutputStream(inputReader);
|
|
outputReader = new PipedInputStream();
|
|
outputWriter = new PipedOutputStream(outputReader);
|
|
virtualTerminal = new DefaultVirtualTerminal();
|
|
flushListener = new FlushListener();
|
|
virtualTerminal.addVirtualTerminalListener(flushListener);
|
|
lispTerminal = new LispTerminal(virtualTerminal, inputWriter, outputReader);
|
|
lispTerminal.start();
|
|
}
|
|
|
|
@After
|
|
public void tearDown() throws IOException {
|
|
lispTerminal.stop();
|
|
outputWriter.close();
|
|
}
|
|
|
|
@Test
|
|
public void leftArrowDoesNotMovePastOrigin() {
|
|
pressKey(KeyType.ArrowLeft);
|
|
assertCursorPosition(0, 0);
|
|
}
|
|
|
|
@Test
|
|
public void leftArrowWorksAfterEnteringCharacters() {
|
|
enterCharacters("abc");
|
|
assertCursorPosition(3, 0);
|
|
pressKey(KeyType.ArrowLeft);
|
|
assertCursorPosition(2, 0);
|
|
pressKey(KeyType.ArrowLeft);
|
|
assertCursorPosition(1, 0);
|
|
pressKey(KeyType.ArrowLeft);
|
|
assertCursorPosition(0, 0);
|
|
pressKey(KeyType.ArrowLeft);
|
|
assertCursorPosition(0, 0);
|
|
}
|
|
|
|
@Test
|
|
public void leftArrowWorksAcrossRows() {
|
|
setColumns(5);
|
|
enterCharacters("123451");
|
|
assertCursorPosition(1, 1);
|
|
pressKeyTimes(KeyType.ArrowLeft, 2);
|
|
assertCursorPosition(4, 0);
|
|
}
|
|
|
|
@Test
|
|
public void rightArrowDoesNotMovePastEndOfInput() {
|
|
pressKey(KeyType.ArrowRight);
|
|
assertCursorPosition(0, 0);
|
|
}
|
|
|
|
@Test
|
|
public void rightArrowWorksAfterMovingLeft() {
|
|
enterCharacters("12");
|
|
assertCursorPosition(2, 0);
|
|
pressKey(KeyType.ArrowLeft);
|
|
assertCursorPosition(1, 0);
|
|
pressKey(KeyType.ArrowRight);
|
|
assertCursorPosition(2, 0);
|
|
pressKey(KeyType.ArrowRight);
|
|
assertCursorPosition(2, 0);
|
|
}
|
|
|
|
@Test
|
|
public void rightArrowWorksAcrossRow() {
|
|
setColumns(5);
|
|
enterCharacters("123451");
|
|
assertCursorPosition(1, 1);
|
|
pressKeyTimes(KeyType.ArrowLeft, 3);
|
|
assertCursorPosition(3, 0);
|
|
pressKeyTimes(KeyType.ArrowRight, 3);
|
|
assertCursorPosition(1, 1);
|
|
}
|
|
|
|
@Test
|
|
public void characterKeyIsEchoed() {
|
|
enterCharacter('a');
|
|
assertCursorPosition(1, 0);
|
|
assertCharacterAtPosition('a', 0, 0);
|
|
}
|
|
|
|
@Test
|
|
public void characterIsInserted() {
|
|
enterCharacters("abcd");
|
|
pressKeyTimes(KeyType.ArrowLeft, 2);
|
|
enterCharacter('x');
|
|
assertCharacterPositions(new char[][] { { 'a', 'b', 'x', 'c', 'd' } });
|
|
}
|
|
|
|
@Test
|
|
public void characterIsInserted_PushesInputToNextRow() {
|
|
setColumns(4);
|
|
enterCharacters("abcd");
|
|
pressKeyTimes(KeyType.ArrowLeft, 2);
|
|
enterCharacter('x');
|
|
assertCharacterPositions(new char[][] { { 'a', 'b', 'x', 'c' }, { 'd', ' ', ' ', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void backspaceDoesNothingAtOrigin() {
|
|
pressKey(KeyType.Backspace);
|
|
assertCursorPosition(0, 0);
|
|
}
|
|
|
|
@Test
|
|
public void backspaceWorksAfterInput() {
|
|
enterCharacters("12345");
|
|
pressKeyTimes(KeyType.Backspace, 2);
|
|
assertCursorPosition(3, 0);
|
|
assertCharacterPositions(new char[][] { { '1', '2', '3', ' ', ' ', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void backspaceWorksAcrossRow() {
|
|
setColumns(4);
|
|
enterCharacters("1234567");
|
|
pressKeyTimes(KeyType.Backspace, 5);
|
|
assertCursorPosition(2, 0);
|
|
assertCharacterPositions(new char[][] { { '1', '2', ' ', ' ' }, { ' ', ' ', ' ', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void backspaceWorksInMiddleOfInput() {
|
|
enterCharacters("12345");
|
|
pressKeyTimes(KeyType.ArrowLeft, 2);
|
|
pressKey(KeyType.Backspace);
|
|
assertCursorPosition(2, 0);
|
|
assertCharacterPositions(new char[][] { { '1', '2', '4', '5' } });
|
|
}
|
|
|
|
@Test
|
|
public void deleteDoesNothingAtOrigin() {
|
|
pressKey(KeyType.Delete);
|
|
assertCursorPosition(0, 0);
|
|
}
|
|
|
|
@Test
|
|
public void deleteDoesNothingAtEndOfInput() {
|
|
enterCharacters("del");
|
|
pressKey(KeyType.Delete);
|
|
assertCursorPosition(3, 0);
|
|
assertCharacterPositions(new char[][] { { 'd', 'e', 'l' } });
|
|
}
|
|
|
|
@Test
|
|
public void deleteWorksAtStartOfInput() {
|
|
enterCharacters("del");
|
|
pressKeyTimes(KeyType.ArrowLeft, 3);
|
|
pressKeyTimes(KeyType.Delete, 3);
|
|
assertCursorPosition(0, 0);
|
|
assertCharacterPositions(new char[][] { { ' ', ' ', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void deleteWorksAcrossRow() {
|
|
setColumns(4);
|
|
enterCharacters("delete");
|
|
pressKeyTimes(KeyType.ArrowLeft, 5);
|
|
pressKey(KeyType.Delete);
|
|
assertCursorPosition(1, 0);
|
|
assertCharacterPositions(new char[][] { { 'd', 'l', 'e', 't' }, { 'e', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void enterMovesToNextLine() {
|
|
pressKey(KeyType.Enter);
|
|
assertCursorPosition(0, 1);
|
|
}
|
|
|
|
@Test
|
|
public void enterWritesLineToPipedStream() {
|
|
enterCharacters("enter");
|
|
pressKey(KeyType.Enter);
|
|
assertInputWritten("enter\n");
|
|
}
|
|
|
|
@Test
|
|
public void enterPressedInMiddleOfInput_WritesEntireLineToPipedStream() {
|
|
enterCharacters("enter");
|
|
pressKeyTimes(KeyType.ArrowLeft, 2);
|
|
pressKey(KeyType.Enter);
|
|
assertInputWritten("enter\n");
|
|
}
|
|
|
|
@Test
|
|
public void enterAfterInsertedText_WritesLineToPipedStream() {
|
|
enterCharacters("enter");
|
|
pressKeyTimes(KeyType.ArrowLeft, 2);
|
|
enterCharacters("||");
|
|
pressKey(KeyType.Enter);
|
|
assertInputWritten("ent||er\n");
|
|
}
|
|
|
|
@Test
|
|
public void enterAfterBackspace_WritesLineToPipedStream() {
|
|
enterCharacters("enter");
|
|
pressKeyTimes(KeyType.Backspace, 2);
|
|
pressKey(KeyType.Enter);
|
|
assertInputWritten("ent\n");
|
|
}
|
|
|
|
@Test
|
|
public void enterAfterDelete_WritesLineToPipedStream() {
|
|
enterCharacters("enter");
|
|
pressKeyTimes(KeyType.ArrowLeft, 2);
|
|
pressKeyTimes(KeyType.Delete, 2);
|
|
pressKey(KeyType.Enter);
|
|
assertInputWritten("ent\n");
|
|
}
|
|
|
|
@Test
|
|
public void controlDWorks() {
|
|
enterCharacters("control-d");
|
|
enterControlCharacter('d');
|
|
assertInputStreamClosed();
|
|
assertInputWritten("control-d\n");
|
|
}
|
|
|
|
@Test
|
|
public void controlDWorksInMiddleOfInput() {
|
|
enterCharacters("control-d");
|
|
pressKeyTimes(KeyType.ArrowLeft, 2);
|
|
enterControlCharacter('d');
|
|
assertInputStreamClosed();
|
|
assertInputWritten("control-d\n");
|
|
}
|
|
|
|
@Test
|
|
public void escapeDoesNothing() {
|
|
pressKey(KeyType.Escape);
|
|
assertCursorPosition(0, 0);
|
|
assertInputWritten("");
|
|
}
|
|
|
|
@Test
|
|
public void controlQDoesNothing() {
|
|
enterControlCharacter('q');
|
|
assertCursorPosition(0, 0);
|
|
assertInputWritten("");
|
|
}
|
|
|
|
@Test
|
|
public void controlEnterDoesNothing() {
|
|
pressControlKey(KeyType.Enter);
|
|
assertCursorPosition(0, 0);
|
|
assertInputWritten("");
|
|
}
|
|
|
|
@Test
|
|
public void outputIsWritten() {
|
|
produceOutput("output");
|
|
assertCursorPosition(6, 0);
|
|
assertCharacterPositions(new char[][] { { 'o', 'u', 't', 'p', 'u', 't' } });
|
|
}
|
|
|
|
@Test
|
|
public void endOfSegmentCharacterIsNotPrinted() {
|
|
produceOutput("> " + END_OF_SEGMENT);
|
|
assertCursorPosition(2, 0);
|
|
assertCharacterPositions(new char[][] { { '>', ' ', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void enterTextPastLastLineOfBuffer() {
|
|
setColumns(3);
|
|
setRows(2);
|
|
enterCharacters("01201201");
|
|
assertCursorPosition(2, 1);
|
|
assertCharacterPositions(new char[][] { { '0', '1', '2' }, { '0', '1', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void insertingTextPushesInputPastEndOfBuffer() {
|
|
setColumns(3);
|
|
setRows(4);
|
|
pressKey(KeyType.Enter);
|
|
enterCharacters("00011122");
|
|
pressKeyTimes(KeyType.ArrowLeft, 4);
|
|
assertCursorPosition(1, 2);
|
|
enterCharacters("zz");
|
|
assertCursorPosition(0, 2);
|
|
assertCharacterPositions(new char[][] { { '0', '0', '0' }, { '1', 'z', 'z' }, { '1', '1', '2' },
|
|
{ '2', ' ', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void insertingTextDoesNothingWhenBufferFilled() {
|
|
setColumns(3);
|
|
setRows(3);
|
|
enterCharacters("00011122");
|
|
pressKeyTimes(KeyType.ArrowLeft, 4);
|
|
assertCursorPosition(1, 1);
|
|
enterCharacters("zz");
|
|
assertCursorPosition(1, 1);
|
|
assertCharacterPositions(new char[][] { { '0', '0', '0' }, { '1', '1', '1' }, { '2', '2', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void appendingTextDoesNothingWhenBufferFilled() {
|
|
setColumns(3);
|
|
setRows(3);
|
|
enterCharacters("000111222333444");
|
|
assertCursorPosition(2, 2);
|
|
assertCharacterPositions(new char[][] { { '0', '0', '0' }, { '1', '1', '1' }, { '2', '2', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void printedOutputToEndOfRow_MovesCursorToNextRow() {
|
|
setColumns(3);
|
|
produceOutput("out");
|
|
assertCursorPosition(0, 1);
|
|
}
|
|
|
|
@Test
|
|
public void printedOutputToEndOfBuffer_MovesCursorToNewRow() {
|
|
setColumns(3);
|
|
setRows(2);
|
|
produceOutput("output");
|
|
assertCursorPosition(0, 1);
|
|
assertCharacterPositions(new char[][] { { 'p', 'u', 't' }, { ' ', ' ', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void printedOutputDoesNotOverwriteInput() {
|
|
setColumns(3);
|
|
enterCharacters("01201201");
|
|
pressKeyTimes(KeyType.ArrowLeft, 5);
|
|
produceOutput("out");
|
|
assertCursorPosition(0, 4);
|
|
assertCharacterPositions(new char[][] { { '0', '1', '2' }, { '0', '1', '2' }, { '0', '1', 'o' },
|
|
{ 'u', 't', ' ' } });
|
|
}
|
|
|
|
@Test
|
|
public void printedOutputDoesNotOverwriteInput_AfterEnter() {
|
|
setColumns(3);
|
|
enterCharacters("01201201");
|
|
pressKeyTimes(KeyType.ArrowLeft, 5);
|
|
pressKey(KeyType.Enter);
|
|
produceOutput("out");
|
|
assertCursorPosition(0, 4);
|
|
assertCharacterPositions(new char[][] { { '0', '1', '2' }, { '0', '1', '2' }, { '0', '1', ' ' },
|
|
{ 'o', 'u', 't' } });
|
|
}
|
|
|
|
}
|