1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 package com.sun.star.uno;
25 
26 import com.sun.star.lang.XTypeProvider;
27 
28 import org.junit.Test;
29 import static org.junit.Assert.*;
30 
31 public final class AnyConverter_Test {
32     Any anyBool; //
33     Any anyChar; //
34     Any anyByte; //
35     Any anyShort; //
36     Any anyInt; //
37     Any anyLong; //
38     Any anyFloat; //
39     Any anyDouble; //
40     Any anyStr; //
41     Any anyType; //
42     Any anyArByte; //
43     Any anyVoid;   //
44     Any anyXTypeProvider;
45 
46     Boolean aBool= new Boolean(true);
47     Character aChar= new Character('A');
48     Byte aByte= new Byte((byte) 111);
49     Short aShort= new Short((short) 11111);
50     Integer aInt= new Integer( 1111111);
51     Long aLong= new Long( 0xffffffff);
52     Float aFloat= new Float( 3.14);
53     Double aDouble= new Double( 3.145);
54     Object aObj= new ATypeProvider();
55     String aStr= new String("I am a string");
56     Type aType= new Type(String.class);
57     byte[] arByte= new byte[] {1,2,3};
58 
AnyConverter_Test()59     public AnyConverter_Test() {
60         anyVoid= new Any(new Type(void.class), null);
61         anyBool= new Any(new Type(Boolean.TYPE), aBool);
62         anyChar= new Any(new Type(Character.TYPE), aChar);
63         anyByte= new Any(new Type(Byte.TYPE), aByte);
64         anyShort= new Any(new Type(Short.TYPE), aShort);
65         anyInt= new Any(new Type(Integer.TYPE), aInt);
66         anyLong= new Any(new Type(Long.TYPE), aLong);
67         anyFloat= new Any(new Type(Float.TYPE), aFloat);
68         anyDouble= new Any(new Type(Double.TYPE), aDouble);
69         anyStr= new Any(new Type(String.class), aStr);
70         anyType= new Any(new Type(Type.class), aType);
71         anyArByte= new Any(new Type(byte[].class), arByte);
72         anyXTypeProvider= new Any(new Type(XTypeProvider.class), aObj);
73     }
74 
75     @Test
test_toBoolean()76     public void test_toBoolean()
77         throws com.sun.star.lang.IllegalArgumentException
78     {
79         // must work
80         boolean b= AnyConverter.toBoolean(aBool);
81         assertTrue("", b == aBool.booleanValue());
82         b= AnyConverter.toBoolean(anyBool);
83         assertTrue("", b == ((Boolean)anyBool.getObject()).booleanValue());
84 
85         // must fail
86         try { AnyConverter.toBoolean(aChar); fail("");
87         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
88         try { AnyConverter.toBoolean(anyChar); fail("");
89         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
90         try { AnyConverter.toBoolean(aByte); fail("");
91         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
92         try { AnyConverter.toBoolean(anyByte); fail("");
93         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
94         try { AnyConverter.toBoolean(aShort); fail("");
95         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
96         try { AnyConverter.toBoolean(anyShort); fail("");
97         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
98         try { AnyConverter.toBoolean(aInt); fail("");
99         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
100         try { AnyConverter.toBoolean(anyInt); fail("");
101         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
102         try { AnyConverter.toBoolean(aLong); fail("");
103         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
104         try { AnyConverter.toBoolean(anyLong); fail("");
105         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
106         try { AnyConverter.toBoolean(aFloat); fail("");
107         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
108         try { AnyConverter.toBoolean(anyFloat); fail("");
109         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
110         try { AnyConverter.toBoolean(aDouble); fail("");
111         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
112         try { AnyConverter.toBoolean(anyDouble); fail("");
113         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
114         try { AnyConverter.toBoolean(aObj); fail("");
115         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
116         try { AnyConverter.toBoolean(aStr); fail("");
117         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
118         try { AnyConverter.toBoolean(anyStr); fail("");
119         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
120         try { AnyConverter.toBoolean(aType); fail("");
121         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
122         try { AnyConverter.toBoolean(anyType); fail("");
123         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
124         try { AnyConverter.toBoolean(anyVoid); fail("");
125         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
126         try { AnyConverter.toBoolean(arByte); fail("");
127         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
128         try { AnyConverter.toBoolean(anyArByte); fail("");
129         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
130     }
131 
132     @Test
test_toChar()133     public void test_toChar()
134         throws com.sun.star.lang.IllegalArgumentException
135     {
136         // must work
137         char b= AnyConverter.toChar(aChar);
138         assertTrue("", b == aChar.charValue());
139         b= AnyConverter.toChar(anyChar);
140         assertTrue("", b == ((Character)anyChar.getObject()).charValue());
141 
142         // must fail
143         try { AnyConverter.toChar(aBool); fail("");
144         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
145         try { AnyConverter.toChar(anyBool); fail("");
146         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
147         try { AnyConverter.toChar(aByte); fail("");
148         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
149         try { AnyConverter.toChar(anyByte); fail("");
150         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
151         try { AnyConverter.toChar(aShort); fail("");
152         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
153         try { AnyConverter.toChar(anyShort); fail("");
154         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
155         try { AnyConverter.toChar(aInt); fail("");
156         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
157         try { AnyConverter.toChar(anyInt); fail("");
158         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
159         try { AnyConverter.toChar(aLong); fail("");
160         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
161         try { AnyConverter.toChar(anyLong); fail("");
162         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
163         try { AnyConverter.toChar(aFloat); fail("");
164         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
165         try { AnyConverter.toChar(anyFloat); fail("");
166         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
167         try { AnyConverter.toChar(aDouble); fail("");
168         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
169         try { AnyConverter.toChar(anyDouble); fail("");
170         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
171         try { AnyConverter.toChar(aObj); fail("");
172         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
173         try { AnyConverter.toChar(aStr); fail("");
174         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
175         try { AnyConverter.toChar(anyStr); fail("");
176         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
177         try { AnyConverter.toChar(aType); fail("");
178         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
179         try { AnyConverter.toChar(anyType); fail("");
180         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
181         try { AnyConverter.toChar(anyVoid); fail("");
182         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
183         try { AnyConverter.toChar(arByte); fail("");
184         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
185         try { AnyConverter.toChar(anyArByte); fail("");
186         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
187     }
188 
189     @Test
test_toByte()190     public void test_toByte()
191         throws com.sun.star.lang.IllegalArgumentException
192     {
193         // must work
194         byte val= AnyConverter.toByte(aByte);
195         assertTrue("", val == aByte.byteValue());
196         val= AnyConverter.toByte(anyByte);
197         assertTrue("", val == ((Byte)anyByte.getObject()).byteValue());
198 
199         // must fail
200         try { AnyConverter.toByte(aChar); fail("");
201         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
202         try { AnyConverter.toByte(anyChar); fail("");
203         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
204         try { AnyConverter.toByte(aShort); fail("");
205         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
206         try { AnyConverter.toByte(anyShort); fail("");
207         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
208         try { AnyConverter.toByte(aInt); fail("");
209         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
210         try { AnyConverter.toByte(anyInt); fail("");
211         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
212         try { AnyConverter.toByte(aLong); fail("");
213         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
214         try { AnyConverter.toByte(anyLong); fail("");
215         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
216         try { AnyConverter.toByte(aFloat); fail("");
217         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
218         try { AnyConverter.toByte(anyFloat); fail("");
219         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
220         try { AnyConverter.toByte(aDouble); fail("");
221         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
222         try { AnyConverter.toByte(anyDouble); fail("");
223         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
224         try { AnyConverter.toByte(aObj); fail("");
225         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
226         try { AnyConverter.toByte(aStr); fail("");
227         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
228         try { AnyConverter.toByte(anyStr); fail("");
229         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
230         try { AnyConverter.toByte(aType); fail("");
231         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
232         try { AnyConverter.toByte(anyType); fail("");
233         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
234         try { AnyConverter.toByte(anyVoid); fail("");
235         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
236         try { AnyConverter.toByte(arByte); fail("");
237         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
238         try { AnyConverter.toByte(anyArByte); fail("");
239         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
240     }
241 
242     @Test
test_toShort()243     public void test_toShort()
244         throws com.sun.star.lang.IllegalArgumentException
245     {
246         // must work
247         short sh= AnyConverter.toShort(aByte);
248         assertTrue("", sh == aByte.byteValue());
249         sh= AnyConverter.toShort(aShort);
250         assertTrue("", sh == aShort.shortValue());
251         sh= AnyConverter.toShort(anyByte);
252         assertTrue("", sh == ((Byte)anyByte.getObject()).byteValue());
253         sh= AnyConverter.toShort(anyShort);
254         assertTrue("", sh == ((Short) anyShort.getObject()).shortValue());
255         Any a = new Any( Type.UNSIGNED_SHORT, new Short((short)5) );
256         assertTrue("", 5 == AnyConverter.toUnsignedShort( a ));
257 
258         // must fail
259         try { AnyConverter.toShort(a); fail("");
260         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
261         try { AnyConverter.toUnsignedShort(anyShort); fail("");
262         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
263         try { AnyConverter.toChar(aBool); fail("");
264         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
265         try { AnyConverter.toChar(anyBool); fail("");
266         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
267         try { AnyConverter.toShort(aChar); fail("");
268         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
269         try { AnyConverter.toShort(anyChar); fail("");
270         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
271         try { AnyConverter.toShort(aBool); fail("");
272         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
273         try { AnyConverter.toShort(anyBool); fail("");
274         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
275         try { AnyConverter.toShort(aInt); fail("");
276         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
277         try { AnyConverter.toShort(anyInt); fail("");
278         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
279         try { AnyConverter.toShort(aLong); fail("");
280         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
281         try { AnyConverter.toShort(anyLong); fail("");
282         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
283         try { AnyConverter.toShort(aFloat); fail("");
284         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
285         try { AnyConverter.toShort(anyFloat); fail("");
286         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
287         try { AnyConverter.toShort(aDouble); fail("");
288         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
289         try { AnyConverter.toShort(anyDouble); fail("");
290         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
291         try { AnyConverter.toShort(aObj); fail("");
292         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
293         try { AnyConverter.toShort(aStr); fail("");
294         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
295         try { AnyConverter.toShort(anyStr); fail("");
296         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
297         try { AnyConverter.toShort(aType); fail("");
298         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
299         try { AnyConverter.toShort(anyType); fail("");
300         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
301         try { AnyConverter.toShort(anyVoid); fail("");
302         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
303         try { AnyConverter.toShort(arByte); fail("");
304         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
305         try { AnyConverter.toShort(anyArByte); fail("");
306         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
307     }
308 
309     @Test
test_toInt()310     public void test_toInt()
311         throws com.sun.star.lang.IllegalArgumentException
312     {
313         // must work
314         int val= AnyConverter.toInt(aByte);
315         assertTrue("", val == aByte.byteValue());
316         val= AnyConverter.toInt(aShort);
317         assertTrue("", val == aShort.shortValue());
318         val= AnyConverter.toInt(aInt);
319         assertTrue("", val == aInt.intValue());
320         val= AnyConverter.toInt(anyByte);
321         assertTrue("", val == ((Byte)anyByte.getObject()).byteValue());
322         val= AnyConverter.toInt(anyShort);
323         assertTrue("", val == ((Short) anyShort.getObject()).shortValue());
324         val= AnyConverter.toInt(anyInt);
325         assertTrue("", val == ((Integer) anyInt.getObject()).intValue());
326         Any a = new Any( Type.UNSIGNED_SHORT, new Short((short)5) );
327         assertTrue("", 5 == AnyConverter.toInt(a));
328         assertTrue("", 5 == AnyConverter.toUnsignedInt(a));
329         a = new Any( Type.UNSIGNED_LONG, new Integer(5) );
330         assertTrue("", 5 == AnyConverter.toUnsignedInt(a));
331 
332         // must fail
333         try { AnyConverter.toUnsignedInt(anyInt); fail("");
334         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
335         try { AnyConverter.toInt(a); fail("");
336         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
337         try { AnyConverter.toUnsignedInt(anyShort); fail("");
338         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
339         try { AnyConverter.toInt(aChar); fail("");
340         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
341         try { AnyConverter.toInt(anyChar); fail("");
342         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
343         try { AnyConverter.toInt(aBool); fail("");
344         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
345         try { AnyConverter.toInt(anyBool); fail("");
346         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
347         try { AnyConverter.toInt(aLong); fail("");
348         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
349         try { AnyConverter.toInt(anyLong); fail("");
350         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
351         try { AnyConverter.toInt(aFloat); fail("");
352         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
353         try { AnyConverter.toInt(anyFloat); fail("");
354         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
355         try { AnyConverter.toInt(aDouble); fail("");
356         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
357         try { AnyConverter.toInt(anyDouble); fail("");
358         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
359         try { AnyConverter.toInt(aObj); fail("");
360         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
361         try { AnyConverter.toInt(aStr); fail("");
362         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
363         try { AnyConverter.toInt(anyStr); fail("");
364         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
365         try { AnyConverter.toInt(aType); fail("");
366         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
367         try { AnyConverter.toInt(anyType); fail("");
368         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
369         try { AnyConverter.toInt(anyVoid); fail("");
370         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
371         try { AnyConverter.toInt(arByte); fail("");
372         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
373         try { AnyConverter.toInt(anyArByte); fail("");
374         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
375     }
376 
377     @Test
test_toLong()378     public void test_toLong()
379         throws com.sun.star.lang.IllegalArgumentException
380     {
381         // must work
382         long val= AnyConverter.toLong(aByte);
383         assertTrue("", val == aByte.byteValue());
384         val= AnyConverter.toLong(aShort);
385         assertTrue("", val == aShort.shortValue());
386         val= AnyConverter.toLong(aInt);
387         assertTrue("", val == aInt.intValue());
388         val= AnyConverter.toLong(aLong);
389         assertTrue("", val == aLong.longValue());
390         val= AnyConverter.toLong(anyByte);
391         assertTrue("", val == ((Byte)anyByte.getObject()).byteValue());
392         val= AnyConverter.toLong(anyShort);
393         assertTrue("", val == ((Short) anyShort.getObject()).shortValue());
394         val= AnyConverter.toLong(anyInt);
395         assertTrue("", val == ((Integer) anyInt.getObject()).intValue());
396         val= AnyConverter.toLong(anyLong);
397         assertTrue("", val == ((Long) anyLong.getObject()).longValue());
398         Any a = new Any( Type.UNSIGNED_SHORT, new Short((short)5) );
399         assertTrue("", 5 == AnyConverter.toLong(a));
400         assertTrue("", 5 == AnyConverter.toUnsignedLong(a));
401         a = new Any( Type.UNSIGNED_LONG, new Integer(5) );
402         assertTrue("", 5 == AnyConverter.toUnsignedLong(a));
403         assertTrue("", 5 == AnyConverter.toLong(a));
404         a = new Any( Type.UNSIGNED_HYPER, new Long(5) );
405         assertTrue("", 5 == AnyConverter.toUnsignedLong(a));
406 
407         // must fail
408         try { AnyConverter.toUnsignedLong(anyShort); fail("");
409         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
410         try { AnyConverter.toUnsignedLong(anyInt); fail("");
411         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
412         try { AnyConverter.toLong(a); fail("");
413         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
414         try { AnyConverter.toUnsignedLong(anyLong); fail("");
415         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
416         try { AnyConverter.toLong(aChar); fail("");
417         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
418         try { AnyConverter.toLong(anyChar); fail("");
419         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
420         try { AnyConverter.toLong(aBool); fail("");
421         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
422         try { AnyConverter.toLong(anyBool); fail("");
423         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
424         try { AnyConverter.toLong(aFloat); fail("");
425         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
426         try { AnyConverter.toLong(anyFloat); fail("");
427         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
428         try { AnyConverter.toLong(aDouble); fail("");
429         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
430         try { AnyConverter.toLong(anyDouble); fail("");
431         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
432         try { AnyConverter.toLong(aObj); fail("");
433         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
434         try { AnyConverter.toLong(aStr); fail("");
435         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
436         try { AnyConverter.toLong(anyStr); fail("");
437         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
438         try { AnyConverter.toLong(aType); fail("");
439         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
440         try { AnyConverter.toLong(anyType); fail("");
441         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
442         try { AnyConverter.toLong(anyVoid); fail("");
443         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
444         try { AnyConverter.toLong(arByte); fail("");
445         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
446         try { AnyConverter.toLong(anyArByte); fail("");
447         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
448     }
449 
450     @Test
test_toFloat()451     public void test_toFloat()
452         throws com.sun.star.lang.IllegalArgumentException
453     {
454         // must work
455         float val= AnyConverter.toFloat(aByte);
456         assertTrue("", val == aByte.byteValue()); // 111 = 111.0
457         val= AnyConverter.toFloat(anyByte);
458         assertTrue("", val == ((Byte)anyByte.getObject()).byteValue());
459         val= AnyConverter.toFloat(aShort);
460         assertTrue("", val == aShort.shortValue()); //11111 = 11111.0
461         val= AnyConverter.toFloat(anyShort);
462         assertTrue("", val == ((Short) anyShort.getObject()).shortValue());
463         val= AnyConverter.toFloat(aFloat);
464         assertTrue("", val == aFloat.floatValue());
465         val= AnyConverter.toFloat(anyFloat);
466         assertTrue("", val == ((Float) anyFloat.getObject()).floatValue());
467 
468         // must fail
469         try { AnyConverter.toFloat(aChar); fail("");
470         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
471         try { AnyConverter.toFloat(anyChar); fail("");
472         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
473         try { AnyConverter.toFloat(aBool); fail("");
474         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
475         try { AnyConverter.toFloat(anyBool); fail("");
476         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
477         try { AnyConverter.toFloat(aInt); fail("");
478         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
479         try { AnyConverter.toFloat(anyInt); fail("");
480         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
481         try { AnyConverter.toFloat(aLong); fail("");
482         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
483         try { AnyConverter.toFloat(anyLong); fail("");
484         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
485         try { AnyConverter.toFloat(aDouble); fail("");
486         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
487         try { AnyConverter.toFloat(anyDouble); fail("");
488         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
489         try { AnyConverter.toFloat(aObj); fail("");
490         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
491         try { AnyConverter.toFloat(aStr); fail("");
492         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
493         try { AnyConverter.toFloat(anyStr); fail("");
494         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
495         try { AnyConverter.toFloat(aType); fail("");
496         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
497         try { AnyConverter.toFloat(anyType); fail("");
498         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
499         try { AnyConverter.toFloat(anyVoid); fail("");
500         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
501         try { AnyConverter.toFloat(arByte); fail("");
502         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
503         try { AnyConverter.toFloat(anyArByte); fail("");
504         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
505     }
506 
507     @Test
test_toDouble()508     public void test_toDouble()
509         throws com.sun.star.lang.IllegalArgumentException
510     {
511         // must work
512         double val= AnyConverter.toDouble(aByte);
513         assertTrue("", val == aByte.byteValue()); // 111 = 111.0
514         val= AnyConverter.toDouble(anyByte);
515         assertTrue("", val == ((Byte)anyByte.getObject()).byteValue());
516         val= AnyConverter.toDouble(aShort);
517         assertTrue("", val == aShort.shortValue()); //11111 = 11111.0
518         val= AnyConverter.toDouble(anyShort);
519         assertTrue("", val == ((Short) anyShort.getObject()).shortValue());
520         val= AnyConverter.toDouble(aInt);
521         assertTrue("", val == aInt.intValue());
522         val= AnyConverter.toDouble(anyInt);
523         assertTrue("", val == ((Integer) anyInt.getObject()).intValue());
524         val= AnyConverter.toDouble(aFloat);
525         assertTrue("", val == aFloat.floatValue());
526         val= AnyConverter.toDouble(anyFloat);
527         float float1= ((Float) anyFloat.getObject()).floatValue();
528         assertTrue("", val <= (float1 + 0.1) || val >= (float1 - 0.1));
529         val= AnyConverter.toDouble(aDouble);
530         assertTrue("", val == aDouble.doubleValue());
531         val= AnyConverter.toDouble(anyDouble);
532         assertTrue("", val == ((Double) anyDouble.getObject()).doubleValue());
533 
534         // must fail
535         try { AnyConverter.toDouble(aChar); fail("");
536         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
537         try { AnyConverter.toDouble(anyChar); fail("");
538         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
539         try { AnyConverter.toDouble(aBool); fail("");
540         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
541         try { AnyConverter.toDouble(anyBool); fail("");
542         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
543         try { AnyConverter.toDouble(aLong); fail("");
544         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
545         try { AnyConverter.toDouble(anyLong); fail("");
546         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
547         try { AnyConverter.toDouble(aObj); fail("");
548         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
549         try { AnyConverter.toDouble(aStr); fail("");
550         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
551         try { AnyConverter.toDouble(anyStr); fail("");
552         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
553         try { AnyConverter.toDouble(aType); fail("");
554         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
555         try { AnyConverter.toDouble(anyType); fail("");
556         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
557         try { AnyConverter.toDouble(anyVoid); fail("");
558         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
559         try { AnyConverter.toDouble(arByte); fail("");
560         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
561         try { AnyConverter.toDouble(anyArByte); fail("");
562         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
563     }
564 
565     @Test
test_toObject()566     public void test_toObject()
567         throws com.sun.star.lang.IllegalArgumentException
568     {
569         // must work
570         Type _type= new Type(XTypeProvider.class);
571         Object val= AnyConverter.toObject(_type, aObj);
572         assertTrue("", UnoRuntime.areSame(val, aObj));
573         val= AnyConverter.toObject(
574             _type, new Any( new Type(XTypeProvider.class), null));
575         assertTrue("", val == null);
576 
577         // structs, exceptions
578         com.sun.star.lang.IllegalArgumentException exc =
579             new com.sun.star.lang.IllegalArgumentException();
580         Any any_exc = new Any(
581             new Type("com.sun.star.lang.IllegalArgumentException",
582                      TypeClass.EXCEPTION), exc);
583         assertTrue("",
584                AnyConverter.toObject(
585                    new Type(com.sun.star.lang.IllegalArgumentException.class),
586                    any_exc).equals(exc));
587         assertTrue("",
588                AnyConverter.toObject(
589                    new Type(com.sun.star.uno.Exception.class), any_exc).equals(
590                        exc));
591         try {
592             AnyConverter.toObject(
593                 new Type(com.sun.star.uno.RuntimeException.class), any_exc);
594             fail("");
595         } catch (com.sun.star.lang.IllegalArgumentException ie) {};
596         any_exc = new Any(com.sun.star.lang.IllegalArgumentException.class,
597                           exc);
598         assertTrue("",
599                AnyConverter.toObject(
600                    new Type(com.sun.star.lang.IllegalArgumentException.class),
601                    any_exc).equals(exc));
602         assertTrue("",
603                AnyConverter.toObject(new Type(com.sun.star.uno.Exception.class),
604                                      any_exc).equals(exc));
605         try {
606             AnyConverter.toObject(
607                 new Type(com.sun.star.uno.RuntimeException.class), any_exc);
608             fail("");
609         } catch (com.sun.star.lang.IllegalArgumentException ie) {};
610 
611         // must fail
612         try { AnyConverter.toObject(_type, aType); fail("");
613         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
614         try { AnyConverter.toObject(_type, anyType); fail("");
615         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
616         try { AnyConverter.toObject(_type, anyVoid); fail("");
617         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
618         try { AnyConverter.toObject(_type, new Object()); fail("");
619         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
620     }
621 
622     @Test
test_toString()623     public void test_toString()
624         throws com.sun.star.lang.IllegalArgumentException
625     {
626         // must work
627         String val= AnyConverter.toString(aStr);
628         assertTrue("", aStr.equals(val));
629         val= AnyConverter.toString(anyStr);
630         assertTrue("", ((String)anyStr.getObject()).equals(val));
631 
632         // must fail
633         try { AnyConverter.toString(aBool); fail("");
634         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
635         try { AnyConverter.toString(anyBool); fail("");
636         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
637         try { AnyConverter.toString(aChar); fail("");
638         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
639         try { AnyConverter.toString(anyChar); fail("");
640         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
641         try { AnyConverter.toString(aByte); fail("");
642         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
643         try { AnyConverter.toString(anyByte); fail("");
644         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
645         try { AnyConverter.toString(aShort); fail("");
646         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
647         try { AnyConverter.toString(anyShort); fail("");
648         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
649         try { AnyConverter.toString(aInt); fail("");
650         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
651         try { AnyConverter.toString(anyInt); fail("");
652         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
653         try { AnyConverter.toString(aLong); fail("");
654         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
655         try { AnyConverter.toString(anyLong); fail("");
656         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
657         try { AnyConverter.toString(aFloat); fail("");
658         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
659         try { AnyConverter.toString(anyFloat); fail("");
660         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
661         try { AnyConverter.toString(aDouble); fail("");
662         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
663         try { AnyConverter.toString(anyDouble); fail("");
664         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
665         try { AnyConverter.toString(aObj); fail("");
666         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
667         try { AnyConverter.toString(aType); fail("");
668         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
669         try { AnyConverter.toString(anyType); fail("");
670         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
671         try { AnyConverter.toString(anyVoid); fail("");
672         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
673         try { AnyConverter.toString(arByte); fail("");
674         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
675         try { AnyConverter.toString(anyArByte); fail("");
676         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
677     }
678 
679     @Test
test_toType()680     public void test_toType()
681         throws com.sun.star.lang.IllegalArgumentException
682     {
683         // must work
684         Type val= AnyConverter.toType(aType);
685         assertTrue("", val == aType);
686         val= AnyConverter.toType(anyType);
687         assertTrue("", val == anyType.getObject());
688 
689         // must fail
690         try { AnyConverter.toType(aBool); fail("");
691         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
692         try { AnyConverter.toType(anyBool); fail("");
693         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
694         try { AnyConverter.toType(aChar); fail("");
695         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
696         try { AnyConverter.toType(anyChar); fail("");
697         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
698         try { AnyConverter.toType(aByte); fail("");
699         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
700         try { AnyConverter.toType(anyByte); fail("");
701         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
702         try { AnyConverter.toType(aShort); fail("");
703         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
704         try { AnyConverter.toType(anyShort); fail("");
705         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
706         try { AnyConverter.toType(aInt); fail("");
707         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
708         try { AnyConverter.toType(anyInt); fail("");
709         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
710         try { AnyConverter.toType(aLong); fail("");
711         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
712         try { AnyConverter.toType(anyLong); fail("");
713         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
714         try { AnyConverter.toType(aFloat); fail("");
715         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
716         try { AnyConverter.toType(anyFloat); fail("");
717         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
718         try { AnyConverter.toType(aDouble); fail("");
719         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
720         try { AnyConverter.toType(anyDouble); fail("");
721         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
722         try { AnyConverter.toType(aObj); fail("");
723         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
724         try { AnyConverter.toType(aStr); fail("");
725         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
726         try { AnyConverter.toType(anyStr); fail("");
727         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
728         try { AnyConverter.toType(anyVoid); fail("");
729         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
730         try { AnyConverter.toType(arByte); fail("");
731         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
732         try { AnyConverter.toType(anyArByte); fail("");
733         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
734     }
735 
736     @Test
test_toArray()737     public void test_toArray()
738         throws com.sun.star.lang.IllegalArgumentException
739     {
740         // must work
741         Object val= AnyConverter.toArray(arByte);
742         assertTrue("", val == arByte);
743         val= AnyConverter.toArray(anyArByte);
744         assertTrue("", val == anyArByte.getObject());
745 
746         // must fail
747         try { AnyConverter.toType(aBool); fail("");
748         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
749         try { AnyConverter.toType(anyBool); fail("");
750         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
751         try { AnyConverter.toType(aChar); fail("");
752         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
753         try { AnyConverter.toType(anyChar); fail("");
754         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
755         try { AnyConverter.toType(aByte); fail("");
756         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
757         try { AnyConverter.toType(anyByte); fail("");
758         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
759         try { AnyConverter.toType(aShort); fail("");
760         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
761         try { AnyConverter.toType(anyShort); fail("");
762         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
763         try { AnyConverter.toType(aInt); fail("");
764         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
765         try { AnyConverter.toType(anyInt); fail("");
766         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
767         try { AnyConverter.toType(aLong); fail("");
768         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
769         try { AnyConverter.toType(anyLong); fail("");
770         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
771         try { AnyConverter.toType(aFloat); fail("");
772         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
773         try { AnyConverter.toType(anyFloat); fail("");
774         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
775         try { AnyConverter.toType(aDouble); fail("");
776         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
777         try { AnyConverter.toType(anyDouble); fail("");
778         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
779         try { AnyConverter.toType(aObj); fail("");
780         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
781         try { AnyConverter.toType(aStr); fail("");
782         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
783         try { AnyConverter.toType(anyStr); fail("");
784         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
785         try { AnyConverter.toType(anyVoid); fail("");
786         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
787         try { AnyConverter.toType(arByte); fail("");
788         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
789         try { AnyConverter.toType(anyArByte); fail("");
790         } catch (com.sun.star.lang.IllegalArgumentException ie) {}
791     }
792 
793     @Test
test_isBoolean()794     public void test_isBoolean() {
795         assertTrue("", AnyConverter.isBoolean(aBool));
796         assertTrue("", AnyConverter.isBoolean(anyBool));
797         assertTrue("", !AnyConverter.isBoolean(aChar));
798     }
799 
800     @Test
test_isChar()801     public void test_isChar() {
802         assertTrue("", AnyConverter.isChar(aChar));
803         assertTrue("", AnyConverter.isChar(anyChar));
804         assertTrue("", !AnyConverter.isChar(aBool));
805     }
806 
807     @Test
test_isByte()808     public void test_isByte() {
809         assertTrue("", AnyConverter.isByte(aByte));
810         assertTrue("", AnyConverter.isByte(anyByte));
811         assertTrue("", !AnyConverter.isByte(aBool));
812     }
813 
814     @Test
test_isShort()815     public void test_isShort() {
816         assertTrue("", AnyConverter.isShort(aShort));
817         assertTrue("", AnyConverter.isShort(anyShort));
818         assertTrue("", Type.SHORT.equals(AnyConverter.getType(anyShort)));
819         Any a = new Any( Type.UNSIGNED_SHORT, new Short((short)5) );
820         assertTrue("", Type.UNSIGNED_SHORT.equals(AnyConverter.getType(a)));
821         assertTrue("", !AnyConverter.isShort(a));
822         assertTrue("", !Type.SHORT.equals(AnyConverter.getType(a)));
823         assertTrue("", !AnyConverter.isShort(aBool));
824     }
825 
826     @Test
test_isInt()827     public void test_isInt() {
828         assertTrue("", AnyConverter.isInt(aInt));
829         assertTrue("", AnyConverter.isInt(anyInt));
830         assertTrue("", Type.LONG.equals(AnyConverter.getType(anyInt)));
831         Any a = new Any(Type.UNSIGNED_LONG, new Integer(5));
832         assertTrue("", Type.UNSIGNED_LONG.equals(AnyConverter.getType(a)));
833         assertTrue("", !AnyConverter.isInt(a));
834         assertTrue("", !Type.LONG.equals(AnyConverter.getType(a)));
835         assertTrue("", !AnyConverter.isInt(aBool));
836     }
837 
838     @Test
test_isLong()839     public void test_isLong() {
840         assertTrue("", AnyConverter.isLong(aLong));
841         assertTrue("", AnyConverter.isLong(anyLong));
842         assertTrue("", Type.HYPER.equals(AnyConverter.getType(anyLong)));
843         Any a = new Any( Type.UNSIGNED_HYPER, new Long(5) );
844         assertTrue("", Type.UNSIGNED_HYPER.equals( AnyConverter.getType(a) ));
845         assertTrue("", !AnyConverter.isLong(a));
846         assertTrue("", !Type.HYPER.equals( AnyConverter.getType(a) ));
847         assertTrue("", !AnyConverter.isLong(aBool));
848     }
849 
850     @Test
test_isFloat()851     public void test_isFloat() {
852         assertTrue("", AnyConverter.isFloat(aFloat));
853         assertTrue("", AnyConverter.isFloat(anyFloat));
854         assertTrue("", !AnyConverter.isFloat(aDouble));
855     }
856 
857     @Test
test_isDouble()858     public void test_isDouble() {
859         assertTrue("", AnyConverter.isDouble(aDouble));
860         assertTrue("", AnyConverter.isDouble(anyDouble));
861         assertTrue("", !AnyConverter.isDouble(aFloat));
862     }
863 
864     @Test
test_isObject()865     public void test_isObject() {
866         assertTrue("", AnyConverter.isObject(aObj));
867         assertTrue("", AnyConverter.isObject( new Any( XInterface.class, null)));
868         assertTrue("", !AnyConverter.isObject(new Object()));
869     }
870 
871     @Test
test_isString()872     public void test_isString() {
873         assertTrue("", AnyConverter.isString(aStr));
874         assertTrue("", AnyConverter.isString(anyStr));
875         assertTrue("", !AnyConverter.isString(new Object()));
876     }
877 
878     @Test
test_isType()879     public void test_isType() {
880         assertTrue("", AnyConverter.isType(aType));
881         assertTrue("", AnyConverter.isType(anyType));
882         assertTrue("", !AnyConverter.isType(new Object()));
883     }
884 
885     @Test
test_isArray()886     public void test_isArray() {
887         assertTrue("", AnyConverter.isArray(arByte));
888         assertTrue("", AnyConverter.isArray(anyArByte));
889         assertTrue("", !AnyConverter.isArray(new Object()));
890     }
891 
892     @Test
test_isVoid()893     public void test_isVoid() {
894         assertTrue("", AnyConverter.isVoid(anyVoid));
895         assertTrue("", !AnyConverter.isVoid(new Object()));
896     }
897 }
898 
899 
900 class ATypeProvider implements com.sun.star.lang.XTypeProvider
901 {
902 
getImplementationId()903     public byte[] getImplementationId()
904     {
905         return new byte[]{1,2,3};
906     }
907 
getTypes()908     public com.sun.star.uno.Type[] getTypes()
909     {
910         return new Type[]{new Type(XTypeProvider.class)};
911     }
912 
913 }
914