source: trunk/loci/jvmlink/cpp/TestC2.cpp @ 3834

Revision 3834, 12.6 KB checked in by curtis, 12 years ago (diff)

Add support for nulls.

Line 
1//
2// TestC2.cpp
3//
4
5/*
6JVMLink client/server architecture for communicating between Java and
7non-Java programs using sockets.
8Copyright (c) 2008 Hidayath Ansari and Curtis Rueden. All rights reserved.
9
10Redistribution and use in source and binary forms, with or without
11modification, are permitted provided that the following conditions are met:
12  * Redistributions of source code must retain the above copyright
13    notice, this list of conditions and the following disclaimer.
14  * Redistributions in binary form must reproduce the above copyright
15    notice, this list of conditions and the following disclaimer in the
16    documentation and/or other materials provided with the distribution.
17  * Neither the name of the UW-Madison LOCI nor the names of its
18    contributors may be used to endorse or promote products derived from
19    this software without specific prior written permission.
20
21THIS SOFTWARE IS PROVIDED BY THE UW-MADISON LOCI ``AS IS'' AND ANY
22EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
25DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
28ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31*/
32
33#include "stdafx.h"
34#include "JVMLinkClient.h"
35#include <ctime> // for time()
36#include <cstdlib> // for srand() and rand()
37
38bool randomBool() {
39        return rand() % 2 == 0;
40}
41Byte randomByte() {
42        Byte b;
43        b.data = (int) (rand() % 128);
44        return b;
45}
46char randomChar() {
47        return (char) (rand() % (127 - 33 + 1)) + 33;
48}
49double randomDouble() {
50        return (double) rand();
51}
52float randomFloat() {
53        return (float) rand();
54}
55int randomInt() {
56        return rand() + 65536;
57}
58long long randomLong() {
59        return (long long) rand() + 0xffffffffL;
60}
61short randomShort() {
62        return (short) rand();
63}
64
65void printBools(bool* values, int len) {
66        for (int i=0; i<len; i++) std::cout << " " << values[i];
67}
68
69void printBytes(Byte* values, int off, int len) {
70        for (int i=off; i<off+len; i++) std::cout << " " << values[i].data;
71}
72
73void printChars(char* values, int len) {
74        for (int i=0; i<len; i++) std::cout << " " << values[i];
75}
76
77void printDoubles(double* values, int len) {
78        for (int i=0; i<len; i++) std::cout << " " << values[i];
79}
80
81void printFloats(float* values, int len) {
82        for (int i=0; i<len; i++) std::cout << " " << values[i];
83}
84
85void printInts(int* values, int len) {
86        for (int i=0; i<len; i++) std::cout << " " << values[i];
87}
88
89void printLongs(long long* values, int len) {
90        for (int i=0; i<len; i++) std::cout << " " << values[i];
91}
92
93void printShorts(short* values, int len) {
94        for (int i=0; i<len; i++) std::cout << " " << values[i];
95}
96
97void printStrings(CString* values, int len) {
98        for (int i=0; i<len; i++) {
99                std::cout << "\t" << values[i] << std::endl;
100        }
101}
102
103// Tests the JVMLink API.
104int _tmain(int argc, _TCHAR* argv[])
105{
106        JVMLinkClient *p = new JVMLinkClient();
107        p->startJava(20345, "jvmlink.jar");
108        while (p->establishConnection() != JVMLinkClient::CONNECTION_SUCCESS) Sleep(250);
109
110        srand((int) time(0));
111
112        // bool variables
113        bool myBool = randomBool();
114        p->setVar("myBool", myBool);
115        std::cout << "TestC2: setVar: myBool -> " << myBool << std::endl;
116        JVMLinkObject* jvmBool = p->getVar("myBool");
117        std::cout << "TestC2: getVar: myBool == " << jvmBool->getDataAsBool() << std::endl;
118
119        // Byte variables
120        Byte myByte = randomByte();
121        p->setVar("myByte", myByte);
122        std::cout << "TestC2: setVar: myByte -> " << myByte.data << std::endl;
123        JVMLinkObject* jvmByte = p->getVar("myByte");
124        std::cout << "TestC2: getVar: myByte == " << jvmByte->getDataAsByte().data << std::endl;
125
126        // char variables
127        char myChar = randomChar();
128        p->setVar("myChar", myChar);
129        std::cout << "TestC2: setVar: myChar -> " << myChar << std::endl;
130        JVMLinkObject* jvmChar = p->getVar("myChar");
131        std::cout << "TestC2: getVar: myChar == " << jvmChar->getDataAsChar() << std::endl;
132
133        // double variables
134        double myDouble = randomDouble();
135        p->setVar("myDouble", myDouble);
136        std::cout << "TestC2: setVar: myDouble -> " << myDouble << std::endl;
137        JVMLinkObject* jvmDouble = p->getVar("myDouble");
138        std::cout << "TestC2: getVar: myDouble == " << jvmDouble->getDataAsDouble() << std::endl;
139
140        // float variables
141        float myFloat = randomFloat();
142        p->setVar("myFloat", myFloat);
143        std::cout << "TestC2: setVar: myFloat -> " << myFloat << std::endl;
144        JVMLinkObject* jvmFloat = p->getVar("myFloat");
145        std::cout << "TestC2: getVar: myFloat == " << jvmFloat->getDataAsFloat() << std::endl;
146
147        // int variables
148        int myInt = randomInt();
149        p->setVar("myInt", myInt);
150        std::cout << "TestC2: setVar: myInt -> " << myInt << std::endl;
151        JVMLinkObject* jvmInt = p->getVar("myInt");
152        std::cout << "TestC2: getVar: myInt == " << jvmInt->getDataAsInt() <<
153                (jvmInt->isDataNull() ? " (NULL)" : " (not NULL)") << std::endl;
154
155        // long variables
156        long long myLong = randomLong();
157        p->setVar("myLong", myLong);
158        std::cout << "TestC2: setVar: myLong -> " << myLong << std::endl;
159        JVMLinkObject* jvmLong = p->getVar("myLong");
160        std::cout << "TestC2: getVar: myLong == " << jvmLong->getDataAsLong() << std::endl;
161
162        // short variables
163        short myShort = randomShort();
164        p->setVar("myShort", myShort);
165        std::cout << "TestC2: setVar: myShort -> " << myShort << std::endl;
166        JVMLinkObject* jvmShort = p->getVar("myShort");
167        std::cout << "TestC2: getVar: myShort == " << jvmShort->getDataAsShort() << std::endl;
168
169        // CString variables
170        CString myString = "<<The quick brown fox jumps over the lazy dog.>>";
171        p->setVar("myString", &myString);
172        std::cout << "TestC2: setVar: myString -> " << myString << std::endl;
173        JVMLinkObject* jvmString = p->getVar("myString");
174        std::cout << "TestC2: getVar: myString == " << *jvmString->getDataAsString() << std::endl;
175
176        // null variable
177        p->setVarNull("myInt");
178        std::cout << "TestC2: setVar: myInt -> NULL" << std::endl;
179        JVMLinkObject* jvmNull = p->getVar("myInt");
180        std::cout << "TestC2: getVar: myInt == " <<
181                (jvmNull->isDataNull() ? "NULL" : "not NULL") << std::endl;
182
183        // non-existent variable
184        JVMLinkObject* jvmNonExist = p->getVar("myNonExist");
185        std::cout << "TestC2: getVar: myNonExist == " <<
186                (jvmNonExist->isDataNull() ? "NULL" : "not NULL") << std::endl;
187
188        // arrays
189        const int num = 15;
190        bool* myBools = new bool[num];
191        Byte* myBytes = new Byte[num];
192        char* myChars = new char[num];
193        double* myDoubles = new double[num];
194        float* myFloats = new float[num];
195        int* myInts = new int[num];
196        long long* myLongs = new long long[num];
197        short* myShorts = new short[num];
198
199        for (int i=0; i<num; i++) {
200                myBools[i] = randomBool();
201                myBytes[i] = randomByte();
202                myChars[i] = randomChar();
203                myDoubles[i] = randomDouble();
204                myFloats[i] = randomFloat();
205                myInts[i] = randomInt();
206                myLongs[i] = randomLong();
207                myShorts[i] = randomShort();
208        }
209
210        CString* myStrings = new CString[6];
211        myStrings[0] = "\"There was an Old Man with a beard,";
212        myStrings[1] = "Who said, 'It is just as I feared!";
213        myStrings[2] = "Two Owls and a Hen,";
214        myStrings[3] = "Four Larks and a Wren,";
215        myStrings[4] = "Have all built their nests in my beard!'\"";
216        myStrings[5] = "- Edward Lear";
217
218        // bool arrays
219        p->setVar("myBools", myBools, num);
220        std::cout << "TestC2: setVar: myBools -> [";
221        printBools(myBools, num);
222        std::cout << " ]" << std::endl;
223        JVMLinkObject* jvmBools = p->getVar("myBools");
224        std::cout << "TestC2: getVar: myBools == [";
225        printBools(jvmBools->getDataAsBoolArray(), num);
226        std::cout << " ]" << std::endl;
227
228        // Byte arrays
229        p->setVar("myBytes", myBytes, num);
230        std::cout << "TestC2: setVar: myBytes -> [";
231        printBytes(myBytes, 0, num);
232        std::cout << " ]" << std::endl;
233        JVMLinkObject* jvmBytes = p->getVar("myBytes");
234        std::cout << "TestC2: getVar: myBytes == [";
235        printBytes(jvmBytes->getDataAsByteArray(), 0, num);
236        std::cout << " ]" << std::endl;
237
238        // char arrays
239        p->setVar("myChars", myChars, num);
240        std::cout << "TestC2: setVar: myChars -> [";
241        printChars(myChars, num);
242        std::cout << " ]" << std::endl;
243        JVMLinkObject* jvmChars = p->getVar("myChars");
244        std::cout << "TestC2: getVar: myChars == [";
245        printChars(jvmChars->getDataAsCharArray(), num);
246        std::cout << " ]" << std::endl;
247
248        // double arrays
249        p->setVar("myDoubles", myDoubles, num);
250        std::cout << "TestC2: setVar: myDoubles -> [";
251        printDoubles(myDoubles, num);
252        std::cout << " ]" << std::endl;
253        JVMLinkObject* jvmDoubles = p->getVar("myDoubles");
254        std::cout << "TestC2: getVar: myDoubles == [";
255        printDoubles(jvmDoubles->getDataAsDoubleArray(), num);
256        std::cout << " ]" << std::endl;
257
258        // float arrays
259        p->setVar("myFloats", myFloats, num);
260        std::cout << "TestC2: setVar: myFloats -> [";
261        printFloats(myFloats, num);
262        std::cout << " ]" << std::endl;
263        JVMLinkObject* jvmFloats = p->getVar("myFloats");
264        std::cout << "TestC2: getVar: myFloats == [";
265        printFloats(jvmFloats->getDataAsFloatArray(), num);
266        std::cout << " ]" << std::endl;
267
268        // int arrays
269        p->setVar("myInts", myInts, num);
270        std::cout << "TestC2: setVar: myInts -> [";
271        printInts(myInts, num);
272        std::cout << " ]" << std::endl;
273        JVMLinkObject* jvmInts = p->getVar("myInts");
274        std::cout << "TestC2: getVar: myInts == [";
275        printInts(jvmInts->getDataAsIntArray(), num);
276        std::cout << " ]" << std::endl;
277
278        // long arrays
279        p->setVar("myLongs", myLongs, num);
280        std::cout << "TestC2: setVar: myLongs -> [";
281        printLongs(myLongs, num);
282        std::cout << " ]" << std::endl;
283        JVMLinkObject* jvmLongs = p->getVar("myLongs");
284        std::cout << "TestC2: getVar: myLongs == [";
285        printLongs(jvmLongs->getDataAsLongArray(), num);
286        std::cout << " ]" << std::endl;
287
288        // short arrays
289        p->setVar("myShorts", myShorts, num);
290        std::cout << "TestC2: setVar: myShorts -> [";
291        printShorts(myShorts, num);
292        std::cout << " ]" << std::endl;
293        JVMLinkObject* jvmShorts = p->getVar("myShorts");
294        std::cout << "TestC2: getVar: myShorts == [";
295        printShorts(jvmShorts->getDataAsShortArray(), num);
296        std::cout << " ]" << std::endl;
297
298        // CString arrays
299        p->setVar("myStrings", myStrings, 6);
300        std::cout << "TestC2: setVar: myStrings -> [" << std::endl;
301        for (int i=0; i<6; i++) {
302                std::cout << "\t" << myStrings[i] << std::endl;
303        }
304        std::cout << "]" << std::endl;
305        JVMLinkObject* jvmStrings = p->getVar("myStrings");
306        std::cout << "TestC2: getVar: myStrings == [" << std::endl;
307        printStrings(jvmStrings->getDataAsStringArray(), 6);
308        std::cout << "]" << std::endl;
309
310        delete myBools;
311        delete myBytes;
312        delete myChars;
313        delete myDoubles;
314        delete myFloats;
315        delete myInts;
316        delete myShorts;
317        delete myLongs;
318
319        // exec commands
320        std::cout << "TestC2: trying some exec calls" << std::endl;
321        p->exec("import java.awt.BorderLayout");
322        p->exec("import javax.swing.JButton");
323        p->exec("import javax.swing.JFrame");
324        p->exec("import javax.swing.JPanel");
325        p->exec("frame = new JFrame(\"My Java Frame\")");
326        p->exec("pane = new JPanel()");
327        p->exec("frame.setContentPane(pane)");
328        p->exec("layout = new BorderLayout()");
329        p->exec("pane.setLayout(layout)");
330        p->exec("button = new JButton(\"Hello world!\")");
331        p->exec("pane.add(button, BorderLayout.CENTER)");
332        p->exec("frame.setBounds(100, 100, 500, 400)");
333        p->exec("frame.setVisible(true)");
334
335        // large Byte array
336        const int big = 10000000;
337        Byte* largeBytes = new Byte[big];
338        for (int i=0; i<big; i++) largeBytes[i] = randomByte();
339
340        p->setVar("largeBytes", largeBytes, big);
341        std::cout << "TestC2: setVar: largeBytes -> [";
342        printBytes(largeBytes, 0, 3);
343        std::cout << " ...";
344        printBytes(largeBytes, big / 2 - 1, 3);
345        std::cout << " ...";
346        printBytes(largeBytes, big - 3, 3);
347        std::cout << " ]" << std::endl;
348        JVMLinkObject* jvmLargeBytes = p->getVar("largeBytes");
349        std::cout << "TestC2: getVar: largeBytes == [";
350        Byte* largeBytes2 = jvmLargeBytes->getDataAsByteArray();
351        printBytes(largeBytes2, 0, 3);
352        std::cout << " ...";
353        printBytes(largeBytes2, big / 2 - 1, 3);
354        std::cout << " ...";
355        printBytes(largeBytes2, big - 3, 3);
356        std::cout << " ]" << std::endl;
357
358        delete largeBytes;
359
360        fprintf(stdout, "\n\nPress enter to shut down the server and exit...\n");
361        _fgetchar();
362
363        // free Java resources
364        p->exec("frame.dispose()");
365
366        // order the server to shut down
367        p->shutJava();
368
369        // close our connection to the server
370        p->closeConnection();
371
372        // free local resources
373        delete(p);
374
375        return 0;
376}
Note: See TracBrowser for help on using the repository browser.