Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/testing/test/util/MultiTypeTest.cc @ 9545

Last change on this file since 9545 was 9545, checked in by landauf, 11 years ago

eol-style native
  • Property svn:eol-style set to native
File size: 23.3 KB
RevLine 
[9545]1#include <gtest/gtest.h>
2#include "util/MultiType.h"
3
4namespace orxonox
5{
6    // x constructor()
7    // x constructor(value)
8    // x constructor(other)
9
10    // x assignment(value)
11    // ? assignment(pointer)
12    // x assignment(other)
13
14    // x set(value)
15    // ? set(pointer)
16    // x force<type>(value)
17
18    // x convert<type>()
19    // x reset
20    // x reset<type>()
21    // x resetValue
22
23    // x isType<type>()
24
25    // x (type) conversion
26    // ? (pointer class) conversion
27    // x getValue(pointer)
28    // x get<type>()
29    // ? getPointer()
30
31    // x lastConversionSuccessful()
32    // x null()
33
34    /////////////////////////
35    // Default Constructor //
36    /////////////////////////
37    TEST(MultiType, DefaultConstructor)
38    {
39        MultiType mt;
40        EXPECT_TRUE(mt.null());
41        EXPECT_TRUE(mt.isType<void>());
42    }
43
44    /////////////////
45    // Constructor //
46    /////////////////
47    TEST(MultiType, ValueChar)              { char value = -100;                                MultiType mt(value);    EXPECT_TRUE(mt.isType<char>());                 EXPECT_EQ(-100, mt.get<char>()); }
48    TEST(MultiType, ValueUnsignedChar)      { unsigned char value = 255u;                       MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned char>());        EXPECT_EQ(255u, mt.get<unsigned char>()); }
49    TEST(MultiType, ValueShort)             { short value = -10000;                             MultiType mt(value);    EXPECT_TRUE(mt.isType<short>());                EXPECT_EQ(-10000, mt.get<short>()); }
50    TEST(MultiType, ValueUnsignedShort)     { unsigned short value = 65535u;                    MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned short>());       EXPECT_EQ(65535u, mt.get<unsigned short>()); }
51    TEST(MultiType, ValueInt)               { int value = -1000000000;                          MultiType mt(value);    EXPECT_TRUE(mt.isType<int>());                  EXPECT_EQ(-1000000000, mt.get<int>()); }
52    TEST(MultiType, ValueUnsignedInt)       { unsigned int value = 4000000000u;                 MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned int>());         EXPECT_EQ(4000000000u, mt.get<unsigned int>()); }
53    TEST(MultiType, ValueLong)              { long value = -1000000000;                         MultiType mt(value);    EXPECT_TRUE(mt.isType<long>());                 EXPECT_EQ(-1000000000, mt.get<long>()); }
54    TEST(MultiType, ValueUnsignedLong)      { unsigned long value = 4000000000u;                MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned long>());        EXPECT_EQ(4000000000u, mt.get<unsigned long>()); }
55    TEST(MultiType, ValueLongLong)          { long long value = -1000000000000000000L;          MultiType mt(value);    EXPECT_TRUE(mt.isType<long long>());            EXPECT_EQ(-1000000000000000000L, mt.get<long long>()); }
56    TEST(MultiType, ValueUnsignedLongLong)  { unsigned long long value = 4000000000000000000UL; MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned long long>());   EXPECT_EQ(4000000000000000000UL, mt.get<unsigned long long>()); }
57    TEST(MultiType, ValueFloat)             { float value = 0.123456f;                          MultiType mt(value);    EXPECT_TRUE(mt.isType<float>());                EXPECT_EQ(0.123456f, mt.get<float>()); }
58    TEST(MultiType, ValueDouble)            { double value = 0.123456789;                       MultiType mt(value);    EXPECT_TRUE(mt.isType<double>());               EXPECT_EQ(0.123456789, mt.get<double>()); }
59    TEST(MultiType, ValueLongDouble)        { long double value = 0.123456789123456789;         MultiType mt(value);    EXPECT_TRUE(mt.isType<long double>());          EXPECT_EQ(0.123456789123456789, mt.get<long double>()); }
60    TEST(MultiType, ValueBool)              { bool value = true;                                MultiType mt(value);    EXPECT_TRUE(mt.isType<bool>());                 EXPECT_EQ(true, mt.get<bool>()); }
61    TEST(MultiType, ValueVoidpointer)       { int* pointer = new int; void* value = pointer;    MultiType mt(value);    EXPECT_TRUE(mt.isType<void*>());                EXPECT_EQ(value, mt.get<void*>()); delete pointer; }
62    TEST(MultiType, ValueString)            { std::string value = "Hello World";                MultiType mt(value);    EXPECT_TRUE(mt.isType<std::string>());          EXPECT_EQ("Hello World", mt.get<std::string>()); }
63    TEST(MultiType, ValueVector2)           { Vector2 value = Vector2(11, 22);                  MultiType mt(value);    EXPECT_TRUE(mt.isType<Vector2>());              EXPECT_EQ(Vector2(11, 22), mt.get<Vector2>()); }
64    TEST(MultiType, ValueVector3)           { Vector3 value = Vector3(11, 22, 33);              MultiType mt(value);    EXPECT_TRUE(mt.isType<Vector3>());              EXPECT_EQ(Vector3(11, 22, 33), mt.get<Vector3>()); }
65    TEST(MultiType, ValueVector4)           { Vector4 value = Vector4(11, 22, 33, 44);          MultiType mt(value);    EXPECT_TRUE(mt.isType<Vector4>());              EXPECT_EQ(Vector4(11, 22, 33, 44), mt.get<Vector4>()); }
66    TEST(MultiType, ValueColourValue)       { ColourValue value = ColourValue(11, 22, 33, 44);  MultiType mt(value);    EXPECT_TRUE(mt.isType<ColourValue>());          EXPECT_EQ(ColourValue(11, 22, 33, 44), mt.get<ColourValue>()); }
67    TEST(MultiType, ValueQuaternion)        { Quaternion value = Quaternion(11, 22, 33, 44);    MultiType mt(value);    EXPECT_TRUE(mt.isType<Quaternion>());           EXPECT_EQ(Quaternion(11, 22, 33, 44), mt.get<Quaternion>()); }
68    TEST(MultiType, ValueRadian)            { Radian value = Radian(0.123);                     MultiType mt(value);    EXPECT_TRUE(mt.isType<Radian>());               EXPECT_EQ(Radian(0.123), mt.get<Radian>()); }
69    TEST(MultiType, ValueDegree)            { Degree value = Degree(123);                       MultiType mt(value);    EXPECT_TRUE(mt.isType<Degree>());               EXPECT_EQ(Degree(123), mt.get<Degree>()); }
70    TEST(MultiType, ValueMbool)             { mbool value = mbool(true);                        MultiType mt(value);    EXPECT_TRUE(mt.isType<bool>());                 EXPECT_EQ(mbool(true), mt.get<bool>()); }
71    TEST(MultiType, ValueCharPointer)       { const char* value = "Hello World";                MultiType mt(value);    EXPECT_TRUE(mt.isType<std::string>());          EXPECT_EQ("Hello World", mt.get<std::string>()); }
72
73    //////////////////////
74    // Copy-Constructor //
75    //////////////////////
76    TEST(MultiType, CopyConstructorEmpty)
77    {
78        MultiType mt1;
79        MultiType mt2(mt1);
80
81        EXPECT_TRUE(mt2.null());
82    }
83
84    TEST(MultiType, CopyConstructorFloat)
85    {
86        MultiType mt1(0.1234f);
87        MultiType mt2(mt1);
88
89        EXPECT_TRUE(mt2.isType<float>());
90        EXPECT_EQ(0.1234f, mt2.get<float>());
91    }
92
93    //////////////////////
94    // Assignment Value //
95    //////////////////////
96    TEST(MultiType, AssignmentIntToEmpty)
97    {
98        MultiType mt;
99
100        EXPECT_TRUE(mt.null());
101
102        mt = 55;
103
104        EXPECT_FALSE(mt.null());
105        EXPECT_TRUE(mt.isType<int>());
106        EXPECT_EQ(55, mt.get<int>());
107    }
108
109    TEST(MultiType, AssignmentFloatToInt)
110    {
111        MultiType mt(66);
112
113        EXPECT_TRUE(mt.isType<int>());
114        EXPECT_EQ(66, mt.get<int>());
115
116        mt = 77.7f; // will be converted to int
117
118        EXPECT_TRUE(mt.isType<int>());
119        EXPECT_EQ(77, mt.get<int>());
120        EXPECT_EQ(77.0f, mt.get<float>());
121    }
122
123    TEST(MultiType, AssignmentFloatToFloat)
124    {
125        MultiType mt(66.6f);
126
127        EXPECT_TRUE(mt.isType<float>());
128        EXPECT_EQ(66, mt.get<int>());
129        EXPECT_EQ(66.6f, mt.get<float>());
130
131        mt = 77.7f;
132
133        EXPECT_TRUE(mt.isType<float>());
134        EXPECT_EQ(77, mt.get<int>());
135        EXPECT_EQ(77.7f, mt.get<float>());
136    }
137
138    TEST(MultiType, AssignmentFloatToVector3)
139    {
140        MultiType mt(Vector3(1, 2, 3));
141
142        EXPECT_TRUE(mt.isType<Vector3>());
143        EXPECT_EQ(Vector3(1, 2, 3), mt.get<Vector3>());
144        EXPECT_TRUE(mt.lastConversionSuccessful());
145
146        mt = 77.7f;
147
148        EXPECT_TRUE(mt.isType<Vector3>());
149        EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
150        EXPECT_FALSE(mt.lastConversionSuccessful());
151    }
152
153    //////////////////////
154    // Assignment Other //
155    //////////////////////
156    TEST(MultiType, AssignmentOther)
157    {
158        MultiType mt1(33);
159        MultiType mt2(44.4f);
160
161        EXPECT_TRUE(mt1.isType<int>());
162        EXPECT_TRUE(mt2.isType<float>());
163
164        EXPECT_EQ(33, mt1.get<int>());
165        EXPECT_EQ(33.0f, mt1.get<float>());
166        EXPECT_EQ(44.4f, mt2.get<float>());
167
168        mt1 = mt2;
169
170        EXPECT_TRUE(mt1.isType<int>());
171        EXPECT_TRUE(mt2.isType<float>());
172
173        EXPECT_EQ(44, mt1.get<int>());
174        EXPECT_EQ(44.0f, mt1.get<float>());
175        EXPECT_EQ(44.4f, mt2.get<float>());
176    }
177
178    ////////////////
179    // set(value) //
180    ////////////////
181    TEST(MultiType, SetValueBoolToEmpty)
182    {
183        MultiType mt;
184
185        mt.set(true);
186
187        EXPECT_TRUE(mt.isType<bool>());
188        EXPECT_EQ(true, mt.get<bool>());
189    }
190
191    TEST(MultiType, SetValueIntToString)
192    {
193        MultiType mt("Hello");
194
195        EXPECT_TRUE(mt.isType<std::string>());
196        EXPECT_EQ("Hello", mt.get<std::string>());
197
198        mt.set(1234);
199
200        EXPECT_TRUE(mt.isType<std::string>());
201        EXPECT_EQ("1234", mt.get<std::string>());
202    }
203
204    //////////////////////
205    // force<type>(value) //
206    //////////////////////
207    TEST(MultiType, SetValueWithTypeIntToString)
208    {
209        MultiType mt("Hello");
210
211        EXPECT_TRUE(mt.isType<std::string>());
212        EXPECT_EQ("Hello", mt.get<std::string>());
213
214        mt.force<int>(1234);
215
216        EXPECT_TRUE(mt.isType<int>());
217        EXPECT_EQ(1234, mt.get<int>());
218    }
219
220    TEST(MultiType, SetValueWithTypeIntAsStringToString)
221    {
222        MultiType mt("Hello");
223
224        EXPECT_TRUE(mt.isType<std::string>());
225        EXPECT_EQ("Hello", mt.get<std::string>());
226
227        mt.force<int>("1234");
228
229        EXPECT_TRUE(mt.isType<int>());
230        EXPECT_EQ(1234, mt.get<int>());
231    }
232
233    TEST(MultiType, SetValueWithTypeIntToInt)
234    {
235        MultiType mt(4321);
236
237        EXPECT_TRUE(mt.isType<int>());
238        EXPECT_EQ(4321, mt.get<int>());
239
240        mt.force<int>(1234);
241
242        EXPECT_TRUE(mt.isType<int>());
243        EXPECT_EQ(1234, mt.get<int>());
244    }
245
246    /////////////////////
247    // convert<type>() //
248    /////////////////////
249    TEST(MultiType, ConvertEmptyToInt)
250    {
251        MultiType mt;
252        mt.convert<int>();
253
254        EXPECT_TRUE(mt.isType<int>());
255        EXPECT_EQ(0, mt.get<int>());
256    }
257
258    TEST(MultiType, ConvertFloatToInt)
259    {
260        MultiType mt(1.234f);
261
262        EXPECT_TRUE(mt.isType<float>());
263        EXPECT_EQ(1.234f, mt.get<float>());
264        EXPECT_EQ(1, mt.get<int>());
265
266        mt.convert<int>();
267
268        EXPECT_TRUE(mt.isType<int>());
269        EXPECT_EQ(1.0f, mt.get<float>());
270        EXPECT_EQ(1, mt.get<int>());
271    }
272
273    TEST(MultiType, ConvertFloatToVector3)
274    {
275        MultiType mt(1.234f);
276
277        EXPECT_TRUE(mt.isType<float>());
278        EXPECT_EQ(1.234f, mt.get<float>());
279        EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
280
281        mt.convert<Vector3>();
282
283        EXPECT_TRUE(mt.isType<Vector3>());
284        EXPECT_EQ(0.0f, mt.get<float>());
285        EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
286
287        EXPECT_FALSE(mt.lastConversionSuccessful());
288    }
289
290    ///////////
291    // reset //
292    ///////////
293    TEST(MultiType, Reset)
294    {
295        MultiType mt(10);
296
297        EXPECT_TRUE(mt.isType<int>());
298        EXPECT_FALSE(mt.isType<void>());
299        EXPECT_FALSE(mt.null());
300        EXPECT_EQ(10, mt.get<int>());
301
302        mt.reset();
303
304        EXPECT_FALSE(mt.isType<int>());
305        EXPECT_TRUE(mt.isType<void>());
306        EXPECT_TRUE(mt.null());
307        EXPECT_EQ(0, mt.get<int>());
308    }
309
310    ///////////////////
311    // reset<type>() //
312    ///////////////////
313    TEST(MultiType, SetType)
314    {
315        MultiType mt(10);
316
317        EXPECT_TRUE(mt.isType<int>());
318        EXPECT_FALSE(mt.isType<float>());
319        EXPECT_EQ(10, mt.get<int>());
320
321        mt.reset<float>();
322
323        EXPECT_FALSE(mt.isType<int>());
324        EXPECT_TRUE(mt.isType<float>());
325        EXPECT_EQ(0, mt.get<int>());
326    }
327
328    ////////////////
329    // resetValue //
330    ////////////////
331    TEST(MultiType, resetValue)
332    {
333        MultiType mt(10);
334
335        EXPECT_TRUE(mt.isType<int>());
336        EXPECT_EQ(10, mt.get<int>());
337
338        mt.resetValue();
339
340        EXPECT_TRUE(mt.isType<int>());
341        EXPECT_EQ(0, mt.get<int>());
342    }
343
344    /////////////////////
345    // type operator() //
346    /////////////////////
347    TEST(MultiType, ConversionOperatorFloatToFloat)
348    {
349        MultiType mt(12.34f);
350        float value = mt;
351        EXPECT_EQ(12.34f, value);
352    }
353
354    TEST(MultiType, ConversionOperatorFloatToInt)
355    {
356        MultiType mt(12.34f);
357        int value = mt;
358        EXPECT_EQ(12, value);
359    }
360
361    TEST(MultiType, ConversionOperatorIntToFloat)
362    {
363        MultiType mt(123);
364        float value = mt;
365        EXPECT_EQ(123, value);
366    }
367
368    TEST(MultiType, ConversionOperatorIntToString)
369    {
370        MultiType mt(123);
371        std::string value = mt;
372        EXPECT_EQ("123", value);
373    }
374
375    TEST(MultiType, ConversionOperatorStringToInt)
376    {
377        MultiType mt("321");
378        int value = mt;
379        EXPECT_EQ(321, value);
380    }
381
382    namespace
383    {
384        void helper_function(const std::string& a, float b, int c)
385        {
386            EXPECT_EQ("555.555", a);
387            EXPECT_EQ(555.555f, b);
388            EXPECT_EQ(555, c);
389        }
390    }
391
392    TEST(MultiType, ConversionOperatorPassToFunction)
393    {
394        MultiType mt("555.555");
395
396        helper_function(mt, mt, mt);
397    }
398
399    ///////////////////////
400    // getValue(pointer) //
401    ///////////////////////
402    TEST(MultiType, GetValueIntToInt)
403    {
404        MultiType mt(33);
405
406        int value = 0;
407        EXPECT_TRUE(mt.getValue(&value));
408        EXPECT_EQ(33, value);
409    }
410
411    TEST(MultiType, GetValueIntToFloat)
412    {
413        MultiType mt(33);
414
415        float value = 0;
416        EXPECT_TRUE(mt.getValue(&value));
417        EXPECT_EQ(33.0f, value);
418    }
419
420    TEST(MultiType, GetValueIntToVector3)
421    {
422        MultiType mt(33);
423
424        Vector3 value = Vector3::ZERO;
425        EXPECT_FALSE(mt.getValue(&value));
426        EXPECT_EQ(Vector3::ZERO, value);
427    }
428
429    //////////////
430    // get<type>() //
431    //////////////
432    TEST(MultiType, GetValueFromInt)
433    {
434        MultiType mt(256);
435
436        EXPECT_EQ(0, mt.get<char>());
437        EXPECT_EQ(0u, mt.get<unsigned char>());
438        EXPECT_EQ(256, mt.get<short>());
439        EXPECT_EQ(256u, mt.get<unsigned short>());
440        EXPECT_EQ(256, mt.get<int>());
441        EXPECT_EQ(256u, mt.get<unsigned int>());
442        EXPECT_EQ(256, mt.get<long>());
443        EXPECT_EQ(256u, mt.get<unsigned long>());
444        EXPECT_EQ(256, mt.get<long long>());
445        EXPECT_EQ(256u, mt.get<unsigned long long>());
446        EXPECT_EQ(256.0f, mt.get<float>());
447        EXPECT_EQ(256.0, mt.get<double>());
448        EXPECT_EQ(256.0, mt.get<long double>());
449        EXPECT_TRUE(mt.get<bool>());
450        EXPECT_EQ("256", mt.get<std::string>());
451    }
452
453    TEST(MultiType, GetValueFromFloat)
454    {
455        MultiType mt(128.821);
456
457        EXPECT_EQ(-128, mt.get<char>());
458        EXPECT_EQ(128u, mt.get<unsigned char>());
459        EXPECT_EQ(128, mt.get<short>());
460        EXPECT_EQ(128u, mt.get<unsigned short>());
461        EXPECT_EQ(128, mt.get<int>());
462        EXPECT_EQ(128u, mt.get<unsigned int>());
463        EXPECT_EQ(128, mt.get<long>());
464        EXPECT_EQ(128u, mt.get<unsigned long>());
465        EXPECT_EQ(128, mt.get<long long>());
466        EXPECT_EQ(128u, mt.get<unsigned long long>());
467        EXPECT_EQ(128.821f, mt.get<float>());
468        EXPECT_EQ(128.821, mt.get<double>());
469        EXPECT_EQ(128.821, mt.get<long double>());
470        EXPECT_TRUE(mt.get<bool>());
471        EXPECT_EQ("128.821", mt.get<std::string>());
472    }
473
474    TEST(MultiType, GetValueFromString)
475    {
476        MultiType mt("0.123");
477
478        EXPECT_EQ('0', mt.get<char>());
479        EXPECT_EQ('0', mt.get<unsigned char>());
480        EXPECT_EQ(0, mt.get<short>());
481        EXPECT_EQ(0u, mt.get<unsigned short>());
482        EXPECT_EQ(0, mt.get<int>());
483        EXPECT_EQ(0u, mt.get<unsigned int>());
484        EXPECT_EQ(0, mt.get<long>());
485        EXPECT_EQ(0u, mt.get<unsigned long>());
486        EXPECT_EQ(0, mt.get<long long>());
487        EXPECT_EQ(0u, mt.get<unsigned long long>());
488        EXPECT_EQ(0.123f, mt.get<float>());
489        EXPECT_EQ(0.123, mt.get<double>());
490        EXPECT_DOUBLE_EQ(0.123, mt.get<long double>());
491        EXPECT_FALSE(mt.get<bool>());
492        EXPECT_EQ("0.123", mt.get<std::string>());
493    }
494
495    ////////////////////
496    // isType<type>() //
497    ////////////////////
498    TEST(MultiType, IsTypeInt)
499    {
500        MultiType mt(1);
501
502        EXPECT_FALSE(mt.isType<void>());
503        EXPECT_FALSE(mt.isType<char>());
504        EXPECT_FALSE(mt.isType<unsigned char>());
505        EXPECT_FALSE(mt.isType<short>());
506        EXPECT_FALSE(mt.isType<unsigned short>());
507        EXPECT_TRUE(mt.isType<int>());
508        EXPECT_FALSE(mt.isType<unsigned int>());
509        EXPECT_FALSE(mt.isType<long>());
510        EXPECT_FALSE(mt.isType<unsigned long>());
511        EXPECT_FALSE(mt.isType<long long>());
512        EXPECT_FALSE(mt.isType<unsigned long long>());
513        EXPECT_FALSE(mt.isType<float>());
514        EXPECT_FALSE(mt.isType<double>());
515        EXPECT_FALSE(mt.isType<long double>());
516        EXPECT_FALSE(mt.isType<bool>());
517        EXPECT_FALSE(mt.isType<void*>());
518        EXPECT_FALSE(mt.isType<std::string>());
519        EXPECT_FALSE(mt.isType<orxonox::Vector2>());
520        EXPECT_FALSE(mt.isType<orxonox::Vector3>());
521        EXPECT_FALSE(mt.isType<orxonox::Vector4>());
522        EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
523        EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
524        EXPECT_FALSE(mt.isType<orxonox::Radian>());
525        EXPECT_FALSE(mt.isType<orxonox::Degree>());
526    }
527
528    TEST(MultiType, IsTypeUnsignedInt)
529    {
530        MultiType mt(1u);
531
532        EXPECT_FALSE(mt.isType<void>());
533        EXPECT_FALSE(mt.isType<char>());
534        EXPECT_FALSE(mt.isType<unsigned char>());
535        EXPECT_FALSE(mt.isType<short>());
536        EXPECT_FALSE(mt.isType<unsigned short>());
537        EXPECT_FALSE(mt.isType<int>());
538        EXPECT_TRUE(mt.isType<unsigned int>());
539        EXPECT_FALSE(mt.isType<long>());
540        EXPECT_FALSE(mt.isType<unsigned long>());
541        EXPECT_FALSE(mt.isType<long long>());
542        EXPECT_FALSE(mt.isType<unsigned long long>());
543        EXPECT_FALSE(mt.isType<float>());
544        EXPECT_FALSE(mt.isType<double>());
545        EXPECT_FALSE(mt.isType<long double>());
546        EXPECT_FALSE(mt.isType<bool>());
547        EXPECT_FALSE(mt.isType<void*>());
548        EXPECT_FALSE(mt.isType<std::string>());
549        EXPECT_FALSE(mt.isType<orxonox::Vector2>());
550        EXPECT_FALSE(mt.isType<orxonox::Vector3>());
551        EXPECT_FALSE(mt.isType<orxonox::Vector4>());
552        EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
553        EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
554        EXPECT_FALSE(mt.isType<orxonox::Radian>());
555        EXPECT_FALSE(mt.isType<orxonox::Degree>());
556    }
557
558    TEST(MultiType, IsTypeDouble)
559    {
560        MultiType mt(1.0);
561
562        EXPECT_FALSE(mt.isType<void>());
563        EXPECT_FALSE(mt.isType<char>());
564        EXPECT_FALSE(mt.isType<unsigned char>());
565        EXPECT_FALSE(mt.isType<short>());
566        EXPECT_FALSE(mt.isType<unsigned short>());
567        EXPECT_FALSE(mt.isType<int>());
568        EXPECT_FALSE(mt.isType<unsigned int>());
569        EXPECT_FALSE(mt.isType<long>());
570        EXPECT_FALSE(mt.isType<unsigned long>());
571        EXPECT_FALSE(mt.isType<long long>());
572        EXPECT_FALSE(mt.isType<unsigned long long>());
573        EXPECT_FALSE(mt.isType<float>());
574        EXPECT_TRUE(mt.isType<double>());
575        EXPECT_FALSE(mt.isType<long double>());
576        EXPECT_FALSE(mt.isType<bool>());
577        EXPECT_FALSE(mt.isType<void*>());
578        EXPECT_FALSE(mt.isType<std::string>());
579        EXPECT_FALSE(mt.isType<orxonox::Vector2>());
580        EXPECT_FALSE(mt.isType<orxonox::Vector3>());
581        EXPECT_FALSE(mt.isType<orxonox::Vector4>());
582        EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
583        EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
584        EXPECT_FALSE(mt.isType<orxonox::Radian>());
585        EXPECT_FALSE(mt.isType<orxonox::Degree>());
586    }
587
588    TEST(MultiType, IsTypeString)
589    {
590        MultiType mt("1");
591
592        EXPECT_FALSE(mt.isType<void>());
593        EXPECT_FALSE(mt.isType<char>());
594        EXPECT_FALSE(mt.isType<unsigned char>());
595        EXPECT_FALSE(mt.isType<short>());
596        EXPECT_FALSE(mt.isType<unsigned short>());
597        EXPECT_FALSE(mt.isType<int>());
598        EXPECT_FALSE(mt.isType<unsigned int>());
599        EXPECT_FALSE(mt.isType<long>());
600        EXPECT_FALSE(mt.isType<unsigned long>());
601        EXPECT_FALSE(mt.isType<long long>());
602        EXPECT_FALSE(mt.isType<unsigned long long>());
603        EXPECT_FALSE(mt.isType<float>());
604        EXPECT_FALSE(mt.isType<double>());
605        EXPECT_FALSE(mt.isType<long double>());
606        EXPECT_FALSE(mt.isType<bool>());
607        EXPECT_FALSE(mt.isType<void*>());
608        EXPECT_TRUE(mt.isType<std::string>());
609        EXPECT_FALSE(mt.isType<orxonox::Vector2>());
610        EXPECT_FALSE(mt.isType<orxonox::Vector3>());
611        EXPECT_FALSE(mt.isType<orxonox::Vector4>());
612        EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
613        EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
614        EXPECT_FALSE(mt.isType<orxonox::Radian>());
615        EXPECT_FALSE(mt.isType<orxonox::Degree>());
616    }
617
618    TEST(MultiType, IsTypeDegree)
619    {
620        MultiType mt(Degree(1));
621
622        EXPECT_FALSE(mt.isType<void>());
623        EXPECT_FALSE(mt.isType<char>());
624        EXPECT_FALSE(mt.isType<unsigned char>());
625        EXPECT_FALSE(mt.isType<short>());
626        EXPECT_FALSE(mt.isType<unsigned short>());
627        EXPECT_FALSE(mt.isType<int>());
628        EXPECT_FALSE(mt.isType<unsigned int>());
629        EXPECT_FALSE(mt.isType<long>());
630        EXPECT_FALSE(mt.isType<unsigned long>());
631        EXPECT_FALSE(mt.isType<long long>());
632        EXPECT_FALSE(mt.isType<unsigned long long>());
633        EXPECT_FALSE(mt.isType<float>());
634        EXPECT_FALSE(mt.isType<double>());
635        EXPECT_FALSE(mt.isType<long double>());
636        EXPECT_FALSE(mt.isType<bool>());
637        EXPECT_FALSE(mt.isType<void*>());
638        EXPECT_FALSE(mt.isType<std::string>());
639        EXPECT_FALSE(mt.isType<orxonox::Vector2>());
640        EXPECT_FALSE(mt.isType<orxonox::Vector3>());
641        EXPECT_FALSE(mt.isType<orxonox::Vector4>());
642        EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
643        EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
644        EXPECT_FALSE(mt.isType<orxonox::Radian>());
645        EXPECT_TRUE(mt.isType<orxonox::Degree>());
646    }
647
648    ////////////////////////////////
649    // lastConversionSuccessful() //
650    ////////////////////////////////
651    TEST(MultiType, LastConversionSuccessful)
652    {
653        MultiType mt;
654
655        EXPECT_TRUE(mt.lastConversionSuccessful());
656
657        mt = 5.55;
658
659        EXPECT_TRUE(mt.lastConversionSuccessful());
660
661        mt.convert<int>();
662
663        EXPECT_TRUE(mt.lastConversionSuccessful());
664
665        mt.convert<Vector3>();
666
667        EXPECT_FALSE(mt.lastConversionSuccessful());
668
669        mt.convert<std::string>();
670
671        EXPECT_TRUE(mt.lastConversionSuccessful());
672    }
673
674    ////////////
675    // null() //
676    ////////////
677    TEST(MultiType, Null1)
678    {
679        MultiType mt;
680
681        EXPECT_TRUE(mt.null());
682
683        mt = 5;
684
685        EXPECT_FALSE(mt.null());
686    }
687
688    TEST(MultiType, Null2)
689    {
690        MultiType mt(5);
691
692        EXPECT_FALSE(mt.null());
693
694        mt.reset();
695
696        EXPECT_TRUE(mt.null());
697    }
698}
Note: See TracBrowser for help on using the repository browser.