001: package com.mockrunner.test.gen;
002:
003: import java.io.BufferedReader;
004: import java.io.StringReader;
005: import java.util.ArrayList;
006: import java.util.List;
007:
008: import junit.framework.TestCase;
009:
010: import com.mockrunner.gen.proc.JavaLineParser;
011: import com.mockrunner.gen.proc.JavaLineProcessor;
012: import com.mockrunner.gen.proc.JavaLineParser.Block;
013: import com.mockrunner.gen.proc.JavaLineParser.Line;
014:
015: public class JavaLineProcessorTest extends TestCase {
016: private final static String NL = System
017: .getProperty("line.separator");
018:
019: private String getValidTestCode() {
020: StringBuffer testJava = new StringBuffer();
021: testJava.append("package com.mockrunner.test.consistency;\n");
022: testJava.append("\n");
023: testJava.append("import java.io.FileInputStream;\n");
024: testJava.append("import java.io.FileReader;\n");
025: testJava.append("\n");
026: testJava.append("import junit.framework.TestCase;\n");
027: testJava.append("\n");
028: testJava
029: .append("public class JavaLineParserTest extends TestCase\n");
030: testJava.append("{\n");
031: testJava.append(" private String test;\n");
032: testJava.append(" protected int myInt;\n");
033: testJava.append(" public test()\n");
034: testJava.append("{\n");
035: testJava.append(" //do it\n");
036: testJava.append(" if(true)\n");
037: testJava.append("{\n");
038: testJava.append(" \t}\n");
039: testJava.append("}\n");
040: testJava.append("\n");
041: testJava.append("public anotherMethod()\n");
042: testJava.append("{\n");
043: testJava.append("} \n");
044: testJava.append("}");
045: return testJava.toString();
046: }
047:
048: private String getInvalidTestCode() {
049: StringBuffer testJava = new StringBuffer();
050: testJava.append("package com.mockrunner.test.consistency;\n");
051: testJava.append("\n");
052: testJava.append("import java.io.FileInputStream;\n");
053: testJava.append("import java.io.FileReader;\n");
054: testJava.append("");
055: testJava.append("import junit.framework.TestCase;\n");
056: testJava.append("\n");
057: testJava
058: .append("public class JavaLineParserTest extends TestCase\n");
059: testJava.append("{\n");
060: testJava.append(" private String test;\n");
061: testJava.append(" protected int myInt;\n");
062: testJava.append(" public test()\n");
063: testJava.append("{\n");
064: testJava.append(" //do it\n");
065: testJava.append(" if(true)\n");
066: testJava.append("{\n");
067: testJava.append("{\n");
068: testJava.append(" \t}\n");
069: testJava.append("}}}}}}}}}}}}\n");
070: return testJava.toString();
071: }
072:
073: private String getNestedTestCode() {
074: StringBuffer testJava = new StringBuffer();
075: testJava.append("test\n");
076: testJava.append("\n");
077: testJava.append("\n");
078: testJava.append("{\n");
079: testJava.append("{\n");
080: testJava.append("ff{sfs\n");
081: testJava.append("yxv{yxvx\n");
082: testJava.append("\n");
083: testJava.append("abc\n");
084: testJava.append("}}\n");
085: testJava.append("abc\n");
086: testJava.append("\n");
087: testJava.append("\n");
088: testJava.append("}\n");
089: testJava.append("}\n");
090: testJava.append("}}}\n");
091: return testJava.toString();
092: }
093:
094: public void testParseValid() throws Exception {
095: JavaLineParser parser = new JavaLineParser();
096: List lineList = new ArrayList();
097: lineList.add("import java.io.FileReader");
098: lineList.add("java.io.FileInputStream");
099: parser.addLines(lineList);
100: parser.addLine("blic clas");
101: List blockList = new ArrayList();
102: blockList.add("public test()");
103: parser.addBlocks(blockList);
104: parser.addBlock("anotherMethod");
105: List result = parser.parse(getValidTestCode());
106: assertEquals(5, result.size());
107: Line line1 = (Line) result.get(0);
108: assertEquals("import java.io.FileInputStream;", line1.getLine());
109: assertEquals(3, line1.getLineNumber());
110: Line line2 = (Line) result.get(1);
111: assertEquals("import java.io.FileReader;", line2.getLine());
112: assertEquals(4, line2.getLineNumber());
113: Line line3 = (Line) result.get(2);
114: assertEquals(
115: "public class JavaLineParserTest extends TestCase",
116: line3.getLine());
117: assertEquals(8, line3.getLineNumber());
118: Block block1 = (Block) result.get(3);
119: assertEquals(" public test()", block1.getLine());
120: assertEquals(12, block1.getLineNumber());
121: assertEquals(18, block1.getEndLineNumber());
122: Block block2 = (Block) result.get(4);
123: assertEquals("public anotherMethod()", block2.getLine());
124: assertEquals(20, block2.getLineNumber());
125: assertEquals(22, block2.getEndLineNumber());
126: }
127:
128: public void testParseInvalid() throws Exception {
129: JavaLineParser parser = new JavaLineParser();
130: parser.addLine("import java.io.FileReader");
131: parser.addBlock("public test()");
132: try {
133: parser.parse(getInvalidTestCode());
134: fail();
135: } catch (RuntimeException exc) {
136: assertTrue(exc.getMessage().indexOf("Blocks not found") != -1);
137: assertTrue(exc.getMessage().indexOf("public test()") != -1);
138: assertTrue(exc.getMessage().indexOf("Lines not found") == -1);
139: }
140:
141: }
142:
143: public void testParseDeeplyNested() throws Exception {
144: String testJava = getNestedTestCode();
145: JavaLineParser parser = new JavaLineParser();
146: parser.addBlock("test");
147: List result = parser.parse(testJava);
148: assertEquals(1, result.size());
149: Block block1 = (Block) result.get(0);
150: assertEquals("test", block1.getLine());
151: assertEquals(1, block1.getLineNumber());
152: assertEquals(16, block1.getEndLineNumber());
153: }
154:
155: public void testParseError() throws Exception {
156: JavaLineParser parser = new JavaLineParser();
157: List lineList = new ArrayList();
158: lineList.add("imprt java.io.FileReader");
159: lineList.add("java.io.FileInputStream");
160: parser.addLines(lineList);
161: parser.addLine("blic clas");
162: List blockList = new ArrayList();
163: blockList.add("public test)");
164: parser.addBlocks(blockList);
165: parser.addBlock("anotherethod");
166: try {
167: parser.parse(getValidTestCode());
168: fail();
169: } catch (RuntimeException exc) {
170: assertTrue(exc.getMessage().indexOf("Lines not found") != -1);
171: assertTrue(exc.getMessage().indexOf(
172: "imprt java.io.FileReader") != -1);
173: assertTrue(exc.getMessage().indexOf("Blocks not found") != -1);
174: assertTrue(exc.getMessage().indexOf("public test)") != -1);
175: assertTrue(exc.getMessage().indexOf("anotherethod") != -1);
176: }
177: }
178:
179: public void testProcessValid() throws Exception {
180: String testCode = getValidTestCode();
181: JavaLineProcessor processor = new JavaLineProcessor();
182: List lineList = new ArrayList();
183: lineList.add("import java.io.FileReader");
184: processor.addLines(lineList);
185: processor.addLine("java.io.FileInputStream");
186: List blockList = new ArrayList();
187: blockList.add("public test()");
188: processor.addBlocks(blockList);
189: processor.addBlock("anotherMethod");
190: String result = processor.process(testCode);
191: assertTrue(-1 != result.indexOf("//import java.io.FileReader"));
192: assertTrue(-1 != result
193: .indexOf("//import java.io.FileInputStream"));
194: assertTrue(-1 != result.indexOf(" /*public test()" + NL
195: + "{" + NL + " //do it" + NL + " if(true)" + NL + "{"
196: + NL + " \t}" + NL + "}*/"));
197: assertTrue(-1 != result.indexOf("/*public anotherMethod()" + NL
198: + "{" + NL + "}*/"));
199: assertEquals(stripChars(testCode), stripChars(result));
200: }
201:
202: public void testProcessDeeplyNested() throws Exception {
203: String testJava = getNestedTestCode();
204: JavaLineProcessor processor = new JavaLineProcessor();
205: List blockList = new ArrayList();
206: blockList.add("test");
207: processor.addBlocks(blockList);
208: String result = processor.process(testJava);
209: assertTrue(result.trim().startsWith("/*"));
210: assertTrue(result.trim().endsWith("*/"));
211: }
212:
213: public void testProcessCommentAll() throws Exception {
214: String testCode = getValidTestCode();
215: JavaLineProcessor processor = new JavaLineProcessor();
216: List lineList = new ArrayList();
217: lineList.add("");
218: processor.addLines(lineList);
219: String result = processor.process(testCode);
220: BufferedReader reader = new BufferedReader(new StringReader(
221: result));
222: String currentLine = null;
223: while ((currentLine = reader.readLine()) != null) {
224: assertTrue(currentLine.trim().startsWith("//"));
225: }
226: }
227:
228: public void testProcessDoubleLine() throws Exception {
229: String testCode = "First line\nSecond line\nFirst line";
230: JavaLineProcessor processor = new JavaLineProcessor();
231: List lineList = new ArrayList();
232: lineList.add("First line");
233: processor.addLines(lineList);
234: String result = processor.process(testCode);
235: BufferedReader reader = new BufferedReader(new StringReader(
236: result));
237: assertTrue(reader.readLine().trim().startsWith("//"));
238: assertFalse(reader.readLine().trim().startsWith("//"));
239: assertTrue(reader.readLine().trim().startsWith("//"));
240: }
241:
242: public void testProcessDoubleBlock() throws Exception {
243: String testCode = "Block\n{\n}\notherBlock\n{\n}\notherBlock\n{\n}\n";
244: JavaLineProcessor processor = new JavaLineProcessor();
245: List blockList = new ArrayList();
246: blockList.add("otherBlock");
247: processor.addBlocks(blockList);
248: String result = processor.process(testCode);
249: String expected = "Block" + NL + "{" + NL + "}" + NL
250: + "/*otherBlock" + NL + "{" + NL + "}*/" + NL
251: + "/*otherBlock" + NL + "{" + NL + "}*/" + NL;
252: assertEquals(result, expected);
253: }
254:
255: private String stripChars(String theString) {
256: StringBuffer buffer = new StringBuffer(theString);
257: int ii = 0;
258: while (ii < buffer.length()) {
259: char currentChar = buffer.charAt(ii);
260: if (Character.isWhitespace(currentChar)
261: || currentChar == '/' || currentChar == '*') {
262: buffer.deleteCharAt(ii);
263: } else {
264: ii++;
265: }
266: }
267: return buffer.toString();
268: }
269: }
|