source: trunk/java-utils-test/src/test/java/de/ugoe/cs/util/console/ConsoleTest.java @ 927

Last change on this file since 927 was 927, checked in by sherbold, 12 years ago
  • added copyright under the Apache License, Version 2.0
  • Property svn:mime-type set to text/plain
File size: 14.0 KB
Line 
1//   Copyright 2012 Georg-August-Universität Göttingen, Germany
2//
3//   Licensed under the Apache License, Version 2.0 (the "License");
4//   you may not use this file except in compliance with the License.
5//   You may obtain a copy of the License at
6//
7//       http://www.apache.org/licenses/LICENSE-2.0
8//
9//   Unless required by applicable law or agreed to in writing, software
10//   distributed under the License is distributed on an "AS IS" BASIS,
11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//   See the License for the specific language governing permissions and
13//   limitations under the License.
14
15package de.ugoe.cs.util.console;
16
17import java.util.logging.Level;
18
19import org.junit.*;
20import de.ugoe.cs.util.console.mock.MockCommandListener;
21import de.ugoe.cs.util.console.mock.MockErrorListener;
22import de.ugoe.cs.util.console.mock.MockExceptionListener;
23import de.ugoe.cs.util.console.mock.MockObserver;
24import de.ugoe.cs.util.console.mock.MockOutputListener;
25import de.ugoe.cs.util.console.mock.MockTraceListener;
26import static org.junit.Assert.*;
27
28/**
29 * The class <code>ConsoleTest</code> contains tests for the class <code>{@link Console}</code>.
30 *
31 * @author Steffen Herbold
32 * @version 1.0
33 */
34public class ConsoleTest {
35       
36        private static final String ENDLINE = System.getProperty("line.separator");
37       
38        @Test
39        public void testCommandNotification_1()
40                throws Exception {
41                String command = "test";
42               
43                MockCommandListener commandListener1 = new MockCommandListener();
44                MockCommandListener commandListener2 = new MockCommandListener();
45               
46                Console.getInstance().registerCommandListener(commandListener1);
47                Console.getInstance().registerCommandListener(commandListener2);
48                Console.commandNotification(command);
49               
50                assertEquals(command, commandListener1.getLastCommand());
51                assertEquals(command, commandListener2.getLastCommand());
52        }
53
54        @SuppressWarnings("deprecation")
55        @Test
56        public void testDeleteObserver_1()
57                throws Exception {
58                Console fixture = Console.getInstance();
59               
60                MockObserver mockObserver1 = new MockObserver();
61                MockObserver mockObserver2 = new MockObserver();
62                fixture.registerObserver(mockObserver1);
63                fixture.registerObserver(mockObserver2);
64
65                fixture.deleteObserver(mockObserver1);
66               
67                assertFalse(fixture.hasCommandListener(mockObserver1));
68                assertFalse(fixture.hasErrorListener(mockObserver1));
69                assertFalse(fixture.hasExceptionListener(mockObserver1));
70                assertFalse(fixture.hasOutputListener(mockObserver1));
71                assertFalse(fixture.hasTraceListener(mockObserver1));
72               
73                assertTrue(fixture.hasCommandListener(mockObserver2));
74                assertTrue(fixture.hasErrorListener(mockObserver2));
75                assertTrue(fixture.hasExceptionListener(mockObserver2));
76                assertTrue(fixture.hasOutputListener(mockObserver2));
77                assertTrue(fixture.hasTraceListener(mockObserver2));
78
79                // add additional test code here
80        }
81
82        @Test
83        public void testGetInstance()
84                throws Exception {
85
86                Console result = Console.getInstance();
87                assertNotNull(result);
88        }
89
90        @Test
91        public void testLogException()
92                throws Exception {
93                Exception e = new Exception();
94                MockExceptionListener mockExceptionListener1 = new MockExceptionListener();
95                MockExceptionListener mockExceptionListener2 = new MockExceptionListener();
96               
97                Console.getInstance().registerExceptionListener(mockExceptionListener1);
98                Console.getInstance().registerExceptionListener(mockExceptionListener2);
99               
100                Console.logException(e);
101               
102                assertEquals(e, mockExceptionListener1.getLastException());
103                assertEquals(e, mockExceptionListener2.getLastException());
104        }
105
106        @Test
107        public void testPrint_1()
108                throws Exception {
109                String msg = "test";
110               
111                MockOutputListener mockOutputListener1 = new MockOutputListener();
112                MockOutputListener mockOutputListener2 = new MockOutputListener();
113               
114                Console.getInstance().registerOutputListener(mockOutputListener1);
115                Console.getInstance().registerOutputListener(mockOutputListener2);
116
117                Console.print(msg);
118               
119                assertEquals(msg, mockOutputListener1.getLastOutput());
120                assertEquals(msg, mockOutputListener2.getLastOutput());
121        }
122
123        @Test
124        public void testPrinterr_1()
125                throws Exception {
126                String errMsg = "test";
127               
128                MockErrorListener mockErrorListener1 = new MockErrorListener();
129                MockErrorListener mockErrorListener2 = new MockErrorListener();
130               
131                Console.getInstance().registerErrorListener(mockErrorListener1);
132                Console.getInstance().registerErrorListener(mockErrorListener2);               
133
134                Console.printerr(errMsg);
135               
136                assertEquals(errMsg, mockErrorListener1.getLastError());
137                assertEquals(errMsg, mockErrorListener2.getLastError());
138        }
139
140        @Test
141        public void testPrinterrln_1()
142                throws Exception {
143                String errMsg = "test";
144               
145                MockErrorListener mockErrorListener1 = new MockErrorListener();
146                MockErrorListener mockErrorListener2 = new MockErrorListener();
147               
148                Console.getInstance().registerErrorListener(mockErrorListener1);
149                Console.getInstance().registerErrorListener(mockErrorListener2);               
150
151                Console.printerrln(errMsg);
152               
153                assertEquals(errMsg+ENDLINE, mockErrorListener1.getLastError());
154                assertEquals(errMsg+ENDLINE, mockErrorListener2.getLastError());
155        }
156
157
158        @Test
159        public void testPrintln_1()
160                throws Exception {
161                String msg = "test";
162               
163                MockOutputListener mockOutputListener1 = new MockOutputListener();
164                MockOutputListener mockOutputListener2 = new MockOutputListener();
165               
166                Console.getInstance().registerOutputListener(mockOutputListener1);
167                Console.getInstance().registerOutputListener(mockOutputListener2);
168
169                Console.println(msg);
170               
171                assertEquals(msg+ENDLINE, mockOutputListener1.getLastOutput());
172                assertEquals(msg+ENDLINE, mockOutputListener2.getLastOutput());
173        }
174
175
176        @Test
177        public void testRegisterCommandListener_1()
178                throws Exception {
179                Console fixture = Console.getInstance();
180                MockCommandListener mockCommandListener = new MockCommandListener();
181
182                fixture.registerCommandListener(mockCommandListener);
183               
184                assertTrue(fixture.hasCommandListener(mockCommandListener));
185        }
186
187        @Test
188        public void testRegisterErrorListener_1()
189                throws Exception {
190                Console fixture = Console.getInstance();
191               
192                MockErrorListener mockErrorListener = new MockErrorListener();
193
194                fixture.registerErrorListener(mockErrorListener);
195               
196                assertTrue(fixture.hasErrorListener(mockErrorListener));
197        }
198
199        @Test
200        public void testRegisterExceptionListener_1()
201                throws Exception {
202                Console fixture = Console.getInstance();
203               
204                MockExceptionListener mockExceptionListener = new MockExceptionListener();
205
206                fixture.registerExceptionListener(mockExceptionListener);
207
208                assertTrue(fixture.hasExceptionListener(mockExceptionListener));
209        }
210
211        @SuppressWarnings("deprecation")
212        @Test
213        public void testRegisterObserver_1()
214                throws Exception {
215                Console fixture = Console.getInstance();
216               
217                MockObserver mockObserver = new MockObserver();
218
219                fixture.registerObserver(mockObserver);
220               
221                assertTrue(fixture.hasCommandListener(mockObserver));
222                assertTrue(fixture.hasErrorListener(mockObserver));
223                assertTrue(fixture.hasExceptionListener(mockObserver));
224                assertTrue(fixture.hasOutputListener(mockObserver));
225                assertTrue(fixture.hasTraceListener(mockObserver));
226        }
227
228        @Test
229        public void testRegisterOutputListener_1()
230                throws Exception {
231                Console fixture = Console.getInstance();
232               
233                MockOutputListener mockOutputListener = new MockOutputListener();
234
235                fixture.registerOutputListener(mockOutputListener);
236               
237                assertTrue(fixture.hasOutputListener(mockOutputListener));
238        }
239
240        @Test
241        public void testRegisterTraceListener_1()
242                throws Exception {
243                Console fixture = Console.getInstance();
244               
245                MockTraceListener mockTraceListener = new MockTraceListener();
246
247                fixture.registerTraceListener(mockTraceListener);
248               
249                assertTrue(fixture.hasTraceListener(mockTraceListener));
250        }
251
252        @Test
253        public void testRemoveCommandListener_1()
254                throws Exception {
255                Console fixture = Console.getInstance();
256               
257                MockCommandListener mockCommandListener1 = new MockCommandListener();
258                MockCommandListener mockCommandListener2 = new MockCommandListener();
259                fixture.registerCommandListener(mockCommandListener1);
260                fixture.registerCommandListener(mockCommandListener2);
261               
262                fixture.removeCommandListener(mockCommandListener1);
263               
264                assertFalse(fixture.hasCommandListener(mockCommandListener1));
265                assertTrue(fixture.hasCommandListener(mockCommandListener2));
266        }
267
268        @Test
269        public void testRemoveErrorListener_1()
270                throws Exception {
271                Console fixture = Console.getInstance();
272               
273                MockErrorListener mockErrorListener1 = new MockErrorListener();
274                MockErrorListener mockErrorListener2 = new MockErrorListener();
275                fixture.registerErrorListener(mockErrorListener1);
276                fixture.registerErrorListener(mockErrorListener2);
277
278                fixture.removeErrorListener(mockErrorListener1);
279               
280                assertFalse(fixture.hasErrorListener(mockErrorListener1));
281                assertTrue(fixture.hasErrorListener(mockErrorListener2));
282        }
283
284        @Test
285        public void testRemoveExceptionListener_1()
286                throws Exception {
287                Console fixture = Console.getInstance();
288               
289                MockExceptionListener mockExceptionListener1 = new MockExceptionListener();
290                MockExceptionListener mockExceptionListener2 = new MockExceptionListener();
291               
292                fixture.registerExceptionListener(mockExceptionListener1);
293                fixture.registerExceptionListener(mockExceptionListener2);
294               
295                fixture.removeExceptionListener(mockExceptionListener1);
296               
297                assertFalse(fixture.hasExceptionListener(mockExceptionListener1));
298                assertTrue(fixture.hasExceptionListener(mockExceptionListener2));
299        }
300
301        @Test
302        public void testRemoveOutputListener_1()
303                throws Exception {
304                Console fixture = Console.getInstance();
305               
306                MockOutputListener mockOutputListener1 = new MockOutputListener();
307                MockOutputListener mockOutputListener2 = new MockOutputListener();
308               
309                fixture.registerOutputListener(mockOutputListener1);
310                fixture.registerOutputListener(mockOutputListener2);
311               
312                fixture.removeOutputListener(mockOutputListener1);
313               
314                assertFalse(fixture.hasOutputListener(mockOutputListener1));
315                assertTrue(fixture.hasOutputListener(mockOutputListener2));
316        }
317
318        @Test
319        public void testRemoveTraceListener_1()
320                throws Exception {
321                Console fixture = Console.getInstance();
322               
323                MockTraceListener mockTraceListener1 = new MockTraceListener();
324                MockTraceListener mockTraceListener2 = new MockTraceListener();
325               
326                fixture.registerTraceListener(mockTraceListener1);
327                fixture.registerTraceListener(mockTraceListener2);
328               
329                fixture.removeTraceListener(mockTraceListener1);
330               
331                assertFalse(fixture.hasTraceListener(mockTraceListener1));
332                assertTrue(fixture.hasTraceListener(mockTraceListener2));
333        }
334
335        @SuppressWarnings("deprecation")
336    @Test
337        public void testTrace_1()
338                throws Exception {
339                String traceMsg = "test";
340               
341                MockTraceListener mockTraceListener1 = new MockTraceListener();
342                MockTraceListener mockTraceListener2 = new MockTraceListener();
343               
344                Console.getInstance().registerTraceListener(mockTraceListener1);
345                Console.getInstance().registerTraceListener(mockTraceListener2);
346
347                Console.trace(traceMsg);
348
349                assertEquals(traceMsg, mockTraceListener1.getLastTrace());
350                assertEquals(Level.INFO, mockTraceListener1.getLastLevel());
351                assertEquals(traceMsg, mockTraceListener2.getLastTrace());
352                assertEquals(Level.INFO, mockTraceListener2.getLastLevel());
353        }
354       
355               @Test
356                public void testTrace_2()
357                        throws Exception {
358                        String traceMsg = "test";
359                        Level traceLevel = Level.SEVERE;
360                       
361                        MockTraceListener mockTraceListener1 = new MockTraceListener();
362                        MockTraceListener mockTraceListener2 = new MockTraceListener();
363                       
364                        Console.getInstance().registerTraceListener(mockTraceListener1);
365                        Console.getInstance().registerTraceListener(mockTraceListener2);
366
367                        Console.trace(traceLevel, traceMsg);
368
369                        assertEquals(traceMsg, mockTraceListener1.getLastTrace());
370                        assertEquals(traceLevel, mockTraceListener1.getLastLevel());
371                        assertEquals(traceMsg, mockTraceListener2.getLastTrace());
372                        assertEquals(traceLevel, mockTraceListener2.getLastLevel());
373                }
374       
375        @SuppressWarnings("deprecation")
376    @Test
377        public void testTraceln_1()
378                throws Exception {
379                String traceMsg = "test";
380
381                MockTraceListener mockTraceListener1 = new MockTraceListener();
382                MockTraceListener mockTraceListener2 = new MockTraceListener();
383               
384                Console.getInstance().registerTraceListener(mockTraceListener1);
385                Console.getInstance().registerTraceListener(mockTraceListener2);
386
387                Console.traceln(traceMsg);
388
389                assertEquals(traceMsg+ENDLINE, mockTraceListener1.getLastTrace());
390                assertEquals(Level.INFO, mockTraceListener1.getLastLevel());
391                assertEquals(traceMsg+ENDLINE, mockTraceListener2.getLastTrace());
392                assertEquals(Level.INFO, mockTraceListener1.getLastLevel());
393        }
394       
395        @Test
396        public void testTraceln_2()
397                throws Exception {
398                String traceMsg = "test";
399                Level traceLevel = Level.SEVERE;
400
401                MockTraceListener mockTraceListener1 = new MockTraceListener();
402                MockTraceListener mockTraceListener2 = new MockTraceListener();
403               
404                Console.getInstance().registerTraceListener(mockTraceListener1);
405                Console.getInstance().registerTraceListener(mockTraceListener2);
406
407                Console.traceln(traceLevel, traceMsg);
408
409                assertEquals(traceMsg+ENDLINE, mockTraceListener1.getLastTrace());
410                assertEquals(traceLevel, mockTraceListener1.getLastLevel());
411                assertEquals(traceMsg+ENDLINE, mockTraceListener2.getLastTrace());
412                assertEquals(traceLevel, mockTraceListener2.getLastLevel());
413        }
414
415        @Before
416        public void setUp()
417                throws Exception {
418                Console.reset();
419        }
420
421        public static void main(String[] args) {
422                new org.junit.runner.JUnitCore().run(ConsoleTest.class);
423        }
424}
Note: See TracBrowser for help on using the repository browser.