1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package eu.simuline.octave;
20
21 import java.io.File;
22 import java.io.IOException;
23 import java.io.StringReader;
24 import java.io.StringWriter;
25 import java.io.Writer;
26
27 import static org.junit.Assert.assertEquals;
28 import static org.junit.Assert.assertTrue;
29 import static org.junit.Assert.fail;
30
31 import org.junit.Ignore;
32 import org.junit.Test;
33
34 import eu.simuline.octave.exception.OctaveException;
35 import eu.simuline.octave.exception.OctaveIOException;
36 import eu.simuline.octave.type.Octave;
37 import eu.simuline.octave.type.OctaveDouble;
38 import eu.simuline.octave.type.OctaveObject;
39
40
41
42
43 public class TestOctave {
44
45
46
47
48 public static void main(final String[] args) {
49 org.junit.runner.JUnitCore.runClasses(TestOctave.class);
50 }
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67 @Test public void testExecute() throws Exception {
68 final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();
69
70 final OctaveObject Y = Octave.scalar(2);
71 octave.put("y", Y);
72 final OctaveObject X = Octave.scalar(42);
73 octave.put("x", X);
74 final OctaveObject Z = Octave.scalar(4);
75 octave.put("z", Z);
76
77 OctaveDouble x = octave.get(OctaveDouble.class, "x");
78 assertEquals(42.0, x.get(1, 1), 0.0);
79
80 octave.eval("x = x + 10;");
81 x = octave.get(OctaveDouble.class, "x");
82 assertEquals(52.0, x.get(1, 1), 0.0);
83 octave.close();
84 }
85
86
87
88
89
90
91 @Test public void testExec() throws Exception {
92 final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();
93 octave.put("x", Octave.scalar(42));
94 octave.unsafeEval(new StringReader("x=x+10;"));
95 final OctaveDouble octaveScalar = octave.get(OctaveDouble.class, "x");
96 final double x = octaveScalar.get(1, 1);
97 assertEquals(52.0, x, 0.0);
98 octave.close();
99 }
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120 @Test public void testDestroy() throws Exception {
121 final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();
122 octave.eval("sigterm_dumps_octave_core(0);");
123 Thread thread = new DestroyThread(octave);
124
125
126 thread.start();
127 try {
128
129 octave.eval("pause(10);");
130 fail("Exception expected. ");
131 } catch (final OctaveException oe) {
132 assertTrue(oe.isDestroyed());
133 System.out.println("Stacktrace above is intended: is by logging. ");
134 System.out.println("Message 'Uncaught:...' also. ");
135 } catch (final Throwable th) {
136 assertTrue(false);
137 }
138 }
139
140
141
142
143
144
145 private static class DestroyThread extends Thread {
146 private final OctaveEngine octave;
147
148 private DestroyThread(final OctaveEngine octave) {
149 this.octave = octave;
150 }
151
152 @Override
153 public void run() {
154 try {
155 sleep(1000);
156 octave.destroy();
157 } catch (final Throwable e) {
158 e.printStackTrace();
159 }
160 }
161 }
162
163
164
165
166
167
168 @Test public void testConstructor() throws Exception {
169 final OctaveEngineFactory octaveEngineFactory =
170 new OctaveEngineFactory();
171 octaveEngineFactory.setOctaveProgramFile(new File("octave"));
172 final OctaveEngine octave = octaveEngineFactory.getScriptEngine();
173 octave.setWriter(null);
174 octave.eval("disp('testConstructor');");
175 octave.close();
176 }
177
178
179
180
181
182
183 @Test public void testFileClose() throws Exception {
184 final Writer stdin = new DontCloseWriter("stdin");
185 final Writer stdout = new DontCloseWriter("stdout");
186 final Writer stderr = new DontCloseWriter("stderr");
187 final OctaveEngineFactory octaveEngineFactory =
188 new OctaveEngineFactory();
189 octaveEngineFactory.setErrorWriter(stderr);
190 octaveEngineFactory.setOctaveInputLog(stdin);
191 final OctaveEngine octave = octaveEngineFactory.getScriptEngine();
192 octave.setWriter(stdout);
193 octave.eval("disp('testFileClose');");
194 octave.close();
195
196 final OctaveEngine octave2 = octaveEngineFactory.getScriptEngine();
197 octave.setWriter(stdout);
198 try {
199 octave2.unsafeEval("error('testFileClose2');");
200 fail();
201 } catch (final OctaveException e) {
202 assertTrue(e instanceof OctaveIOException);
203 }
204 }
205
206 private static class DontCloseWriter extends Writer {
207 private final String name;
208
209 private DontCloseWriter(final String name) {
210 this.name = name;
211 }
212
213 @Override
214 public void write(final char[] cbuf, final int off, final int len) {
215
216 }
217
218 @Override
219 public void flush() {
220
221 }
222
223 @Override
224 public void close() throws IOException {
225 throw new IOException("DontCloseWriter '" + name + "' closed.");
226 }
227 }
228
229
230
231
232 @Test public void testOutputWithoutNewline() {
233 final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();
234 final StringWriter result = new StringWriter();
235 octave.setWriter(result);
236 octave.eval("printf('testOutputWithoutNewline1');");
237 assertEquals("testOutputWithoutNewline1", result.toString());
238 result.getBuffer().setLength(0);
239 octave.eval("disp('testOutputWithoutNewline2');");
240 assertEquals("testOutputWithoutNewline2\n", result.toString());
241 result.getBuffer().setLength(0);
242 octave.eval("printf('testOutput\\nWithoutNewline3');");
243 assertEquals("testOutput\nWithoutNewline3", result.toString());
244 result.getBuffer().setLength(0);
245 octave.eval("disp('testOutput\\nWithoutNewline4');");
246 assertEquals("testOutput\\nWithoutNewline4\n", result.toString());
247 result.getBuffer().setLength(0);
248 octave.eval("disp(\"testOutput\\nWithoutNewline5\");");
249 assertEquals("testOutput\nWithoutNewline5\n", result.toString());
250 result.getBuffer().setLength(0);
251 octave.eval("'testOutputWithoutNewline6'");
252 assertEquals("ans = testOutputWithoutNewline6\n", result.toString());
253 octave.close();
254 }
255
256 }