63 public void assertEditInput(boolean after, String cmd, String input, Action action) { |
63 public void assertEditInput(boolean after, String cmd, String input, Action action) { |
64 assertEditInput(after, cmd, s -> assertEquals(s, input, "Input"), action); |
64 assertEditInput(after, cmd, s -> assertEquals(s, input, "Input"), action); |
65 } |
65 } |
66 |
66 |
67 public void assertEditOutput(boolean after, String cmd, String output, Action action) { |
67 public void assertEditOutput(boolean after, String cmd, String output, Action action) { |
68 assertEditOutput(after, cmd, s -> assertEquals(s, output, "command"), action); |
68 assertEditOutput(after, cmd, s -> assertEquals(s.trim(), output.trim(), "command"), action); |
69 } |
69 } |
70 |
70 |
71 @Test |
71 @Test |
72 public void testEditNegative() { |
72 public void testEditNegative() { |
73 for (String edit : new String[] {"/e", "/edit"}) { |
73 for (String edit : new String[] {"/ed", "/edit"}) { |
74 test(new String[]{"-nostartup"}, |
74 test(new String[]{"-nostartup"}, |
75 a -> assertCommand(a, edit + " 1", |
75 a -> assertCommandOutputStartsWith(a, edit + " 1", |
76 "| No definition or id named 1 found. See /classes, /methods, /vars, or /list\n"), |
76 "| No definition or id found named: 1"), |
77 a -> assertCommand(a, edit + " -1", |
77 a -> assertCommandOutputStartsWith(a, edit + " -1", |
78 "| No definition or id named -1 found. See /classes, /methods, /vars, or /list\n"), |
78 "| No definition or id found named: -1"), |
79 a -> assertCommand(a, edit + " unknown", |
79 a -> assertCommandOutputStartsWith(a, edit + " unknown", |
80 "| No definition or id named unknown found. See /classes, /methods, /vars, or /list\n") |
80 "| No definition or id found named: unknown") |
81 ); |
81 ); |
82 } |
82 } |
83 } |
83 } |
84 |
84 |
85 @Test |
85 @Test |
86 public void testDoNothing() { |
86 public void testDoNothing() { |
87 testEditor( |
87 testEditor( |
88 a -> assertVariable(a, "int", "a", "0", "0"), |
88 a -> assertVariable(a, "int", "a", "0", "0"), |
89 a -> assertEditOutput(a, "/e 1", "", this::exit), |
89 a -> assertEditOutput(a, "/ed 1", "", this::exit), |
90 a -> assertCommandCheckOutput(a, "/v", assertVariables()) |
90 a -> assertCommandCheckOutput(a, "/v", assertVariables()) |
91 ); |
91 ); |
92 } |
92 } |
93 |
93 |
94 @Test |
94 @Test |
95 public void testEditVariable1() { |
95 public void testEditVariable1() { |
96 testEditor( |
96 testEditor( |
97 a -> assertVariable(a, "int", "a", "0", "0"), |
97 a -> assertVariable(a, "int", "a", "0", "0"), |
98 a -> assertEditOutput(a, "/e 1", "| Modified variable a of type int with initial value 10\n", () -> { |
98 a -> assertEditOutput(a, "/ed 1", "a ==> 10", () -> { |
99 writeSource("\n\n\nint a = 10;\n\n\n"); |
99 writeSource("\n\n\nint a = 10;\n\n\n"); |
100 exit(); |
100 exit(); |
101 loadVariable(true, "int", "a", "10", "10"); |
101 loadVariable(true, "int", "a", "10", "10"); |
102 }), |
102 }), |
103 a -> assertEditOutput(a, "/e 1", "| Modified variable a of type int with initial value 15\n", () -> { |
103 a -> assertEditOutput(a, "/ed 1", "a ==> 15", () -> { |
104 writeSource("int a = 15;"); |
104 writeSource("int a = 15;"); |
105 exit(); |
105 exit(); |
106 loadVariable(true, "int", "a", "15", "15"); |
106 loadVariable(true, "int", "a", "15", "15"); |
107 }), |
107 }), |
108 a -> assertCommandCheckOutput(a, "/v", assertVariables()) |
108 a -> assertCommandCheckOutput(a, "/v", assertVariables()) |
111 |
111 |
112 @Test |
112 @Test |
113 public void testEditVariable2() { |
113 public void testEditVariable2() { |
114 testEditor( |
114 testEditor( |
115 a -> assertVariable(a, "int", "a", "0", "0"), |
115 a -> assertVariable(a, "int", "a", "0", "0"), |
116 a -> assertEditOutput(a, "/e 1", "| Added variable b of type int with initial value 10\n", () -> { |
116 a -> assertEditOutput(a, "/ed 1", "b ==> 10", () -> { |
117 writeSource("int b = 10;"); |
117 writeSource("int b = 10;"); |
118 exit(); |
118 exit(); |
119 loadVariable(true, "int", "b", "10", "10"); |
119 loadVariable(true, "int", "b", "10", "10"); |
120 }), |
120 }), |
121 a -> assertEditOutput(a, "/e 1", "| Modified variable a of type int with initial value 15\n", () -> { |
121 a -> assertEditOutput(a, "/ed 1", "a ==> 15", () -> { |
122 writeSource("int a = 15;"); |
122 writeSource("int a = 15;"); |
123 exit(); |
123 exit(); |
124 loadVariable(true, "int", "a", "15", "15"); |
124 loadVariable(true, "int", "a", "15", "15"); |
125 }), |
125 }), |
126 a -> assertCommandCheckOutput(a, "/v", assertVariables()) |
126 a -> assertCommandCheckOutput(a, "/v", assertVariables()) |
129 |
129 |
130 @Test |
130 @Test |
131 public void testEditClass1() { |
131 public void testEditClass1() { |
132 testEditor( |
132 testEditor( |
133 a -> assertClass(a, "class A {}", "class", "A"), |
133 a -> assertClass(a, "class A {}", "class", "A"), |
134 a -> assertEditOutput(a, "/e 1", "", () -> { |
134 a -> assertEditOutput(a, "/ed 1", "", () -> { |
135 writeSource("\n\n\nclass A {}\n\n\n"); |
135 writeSource("\n\n\nclass A {}\n\n\n"); |
136 exit(); |
136 exit(); |
137 loadClass(true, "class A {}", "class", "A"); |
137 loadClass(true, "class A {}", "class", "A"); |
138 }), |
138 }), |
139 a -> assertEditOutput(a, "/e 1", |
139 a -> assertEditOutput(a, "/ed 1", |
140 "| Replaced enum A\n" + |
140 "| replaced enum A", () -> { |
141 "| Update overwrote class A\n", () -> { |
|
142 writeSource("enum A {}"); |
141 writeSource("enum A {}"); |
143 exit(); |
142 exit(); |
144 loadClass(true, "enum A {}", "enum", "A"); |
143 loadClass(true, "enum A {}", "enum", "A"); |
145 }), |
144 }), |
146 a -> assertCommandCheckOutput(a, "/c", assertClasses()) |
145 a -> assertCommandCheckOutput(a, "/classes", assertClasses()) |
147 ); |
146 ); |
148 } |
147 } |
149 |
148 |
150 @Test |
149 @Test |
151 public void testEditClass2() { |
150 public void testEditClass2() { |
152 testEditor( |
151 testEditor( |
153 a -> assertClass(a, "class A {}", "class", "A"), |
152 a -> assertClass(a, "class A {}", "class", "A"), |
154 a -> assertEditOutput(a, "/e 1", "| Added class B\n", () -> { |
153 a -> assertEditOutput(a, "/ed 1", "| created class B", () -> { |
155 writeSource("class B { }"); |
154 writeSource("class B { }"); |
156 exit(); |
155 exit(); |
157 loadClass(true, "class B {}", "class", "B"); |
156 loadClass(true, "class B {}", "class", "B"); |
158 }), |
157 }), |
159 a -> assertEditOutput(a, "/e 1", |
158 a -> assertEditOutput(a, "/ed 1", |
160 "| Replaced enum A\n" + |
159 "| replaced enum A", () -> { |
161 "| Update overwrote class A\n", () -> { |
|
162 writeSource("enum A {}"); |
160 writeSource("enum A {}"); |
163 exit(); |
161 exit(); |
164 loadClass(true, "enum A {}", "enum", "A"); |
162 loadClass(true, "enum A {}", "enum", "A"); |
165 }), |
163 }), |
166 a -> assertCommandCheckOutput(a, "/c", assertClasses()) |
164 a -> assertCommandCheckOutput(a, "/classes", assertClasses()) |
167 ); |
165 ); |
168 } |
166 } |
169 |
167 |
170 @Test |
168 @Test |
171 public void testEditMethod1() { |
169 public void testEditMethod1() { |
172 testEditor( |
170 testEditor( |
173 a -> assertMethod(a, "void f() {}", "()void", "f"), |
171 a -> assertMethod(a, "void f() {}", "()void", "f"), |
174 a -> assertEditOutput(a, "/e 1", "", () -> { |
172 a -> assertEditOutput(a, "/ed 1", "", () -> { |
175 writeSource("\n\n\nvoid f() {}\n\n\n"); |
173 writeSource("\n\n\nvoid f() {}\n\n\n"); |
176 exit(); |
174 exit(); |
177 loadMethod(true, "void f() {}", "()void", "f"); |
175 loadMethod(true, "void f() {}", "()void", "f"); |
178 }), |
176 }), |
179 a -> assertEditOutput(a, "/e 1", |
177 a -> assertEditOutput(a, "/ed 1", |
180 "| Replaced method f()\n" + |
178 "| replaced method f()", () -> { |
181 "| Update overwrote method f()\n", () -> { |
|
182 writeSource("double f() { return 0; }"); |
179 writeSource("double f() { return 0; }"); |
183 exit(); |
180 exit(); |
184 loadMethod(true, "double f() { return 0; }", "()double", "f"); |
181 loadMethod(true, "double f() { return 0; }", "()double", "f"); |
185 }), |
182 }), |
186 a -> assertCommandCheckOutput(a, "/m", assertMethods()) |
183 a -> assertCommandCheckOutput(a, "/m", assertMethods()) |
189 |
186 |
190 @Test |
187 @Test |
191 public void testEditMethod2() { |
188 public void testEditMethod2() { |
192 testEditor( |
189 testEditor( |
193 a -> assertMethod(a, "void f() {}", "()void", "f"), |
190 a -> assertMethod(a, "void f() {}", "()void", "f"), |
194 a -> assertEditOutput(a, "/e 1", "| Added method g()\n", () -> { |
191 a -> assertEditOutput(a, "/ed 1", "| created method g()", () -> { |
195 writeSource("void g() {}"); |
192 writeSource("void g() {}"); |
196 exit(); |
193 exit(); |
197 loadMethod(true, "void g() {}", "()void", "g"); |
194 loadMethod(true, "void g() {}", "()void", "g"); |
198 }), |
195 }), |
199 a -> assertEditOutput(a, "/e 1", |
196 a -> assertEditOutput(a, "/ed 1", |
200 "| Replaced method f()\n" + |
197 "| replaced method f()", () -> { |
201 "| Update overwrote method f()\n", () -> { |
|
202 writeSource("double f() { return 0; }"); |
198 writeSource("double f() { return 0; }"); |
203 exit(); |
199 exit(); |
204 loadMethod(true, "double f() { return 0; }", "()double", "f"); |
200 loadMethod(true, "double f() { return 0; }", "()double", "f"); |
205 }), |
201 }), |
206 a -> assertCommandCheckOutput(a, "/m", assertMethods()) |
202 a -> assertCommandCheckOutput(a, "/m", assertMethods()) |
211 public void testNoArguments() { |
207 public void testNoArguments() { |
212 testEditor( |
208 testEditor( |
213 a -> assertVariable(a, "int", "a"), |
209 a -> assertVariable(a, "int", "a"), |
214 a -> assertMethod(a, "void f() {}", "()void", "f"), |
210 a -> assertMethod(a, "void f() {}", "()void", "f"), |
215 a -> assertClass(a, "class A {}", "class", "A"), |
211 a -> assertClass(a, "class A {}", "class", "A"), |
216 a -> assertEditInput(a, "/e", s -> { |
212 a -> assertEditInput(a, "/ed", s -> { |
217 String[] ss = s.split("\n"); |
213 String[] ss = s.split("\n"); |
218 assertEquals(ss.length, 3, "Expected 3 lines: " + s); |
214 assertEquals(ss.length, 3, "Expected 3 lines: " + s); |
219 assertEquals(ss[0], "int a;"); |
215 assertEquals(ss[0], "int a;"); |
220 assertEquals(ss[1], "void f() {}"); |
216 assertEquals(ss[1], "void f() {}"); |
221 assertEquals(ss[2], "class A {}"); |
217 assertEquals(ss[2], "class A {}"); |
224 } |
220 } |
225 |
221 |
226 @Test |
222 @Test |
227 public void testStartup() { |
223 public void testStartup() { |
228 testEditor(true, new String[0], |
224 testEditor(true, new String[0], |
229 a -> assertEditInput(a, "/e", s -> assertTrue(s.isEmpty(), "Checking of startup: " + s), this::cancel), |
225 a -> assertEditInput(a, "/ed", s -> assertTrue(s.isEmpty(), "Checking of startup: " + s), this::cancel), |
230 a -> assertEditInput(a, "/e printf", assertStartsWith("void printf"), this::cancel)); |
226 a -> assertEditInput(a, "/ed printf", assertStartsWith("void printf"), this::cancel)); |
231 } |
227 } |
232 |
228 |
233 @Test |
229 @Test |
234 public void testCancel() { |
230 public void testCancel() { |
235 testEditor( |
231 testEditor( |
236 a -> assertVariable(a, "int", "a"), |
232 a -> assertVariable(a, "int", "a"), |
237 a -> assertEditOutput(a, "/e a", "", () -> { |
233 a -> assertEditOutput(a, "/ed a", "", () -> { |
238 writeSource("int b = 10"); |
234 writeSource("int b = 10"); |
239 cancel(); |
235 cancel(); |
240 }) |
236 }) |
241 ); |
237 ); |
242 } |
238 } |
243 |
239 |
244 @Test |
240 @Test |
245 public void testAccept() { |
241 public void testAccept() { |
246 testEditor( |
242 testEditor( |
247 a -> assertVariable(a, "int", "a"), |
243 a -> assertVariable(a, "int", "a"), |
248 a -> assertEditOutput(a, "/e a", "| Added variable b of type int with initial value 10\n", () -> { |
244 a -> assertEditOutput(a, "/ed a", "b ==> 10", () -> { |
249 writeSource("int b = 10"); |
245 writeSource("int b = 10"); |
250 accept(); |
246 accept(); |
251 exit(); |
247 exit(); |
252 }) |
248 }) |
253 ); |
249 ); |