Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/test/util/MultiTypeTest.cc @ 11535

Last change on this file since 11535 was 11071, checked in by landauf, 10 years ago

merged branch cpp11_v3 back to trunk
  • Property svn:eol-style set to native
File size: 30.2 KB
Line 
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, ValueSomepointer)       { int* value = new int;                             MultiType mt(value);    EXPECT_TRUE(mt.isType<void*>());                EXPECT_EQ(value, mt.get<int*>()); delete value; }
63    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>()); }
64    TEST(MultiType, ValueVector2)           { Vector2 value = Vector2(11, 22);                  MultiType mt(value);    EXPECT_TRUE(mt.isType<Vector2>());              EXPECT_EQ(Vector2(11, 22), mt.get<Vector2>()); }
65    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>()); }
66    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>()); }
67    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>()); }
68    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>()); }
69    TEST(MultiType, ValueRadian)            { Radian value = Radian(0.123);                     MultiType mt(value);    EXPECT_TRUE(mt.isType<Radian>());               EXPECT_EQ(Radian(0.123), mt.get<Radian>()); }
70    TEST(MultiType, ValueDegree)            { Degree value = Degree(123);                       MultiType mt(value);    EXPECT_TRUE(mt.isType<Degree>());               EXPECT_EQ(Degree(123), mt.get<Degree>()); }
71    TEST(MultiType, ValueMbool)             { mbool value = mbool(true);                        MultiType mt(value);    EXPECT_TRUE(mt.isType<bool>());                 EXPECT_EQ(mbool(true), mt.get<bool>()); }
72    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>()); }
73
74    //////////////////////
75    // Copy-Constructor //
76    //////////////////////
77    TEST(MultiType, CopyConstructorEmpty)
78    {
79        MultiType mt1;
80        MultiType mt2(mt1);
81
82        EXPECT_TRUE(mt2.null());
83    }
84
85    TEST(MultiType, CopyConstructorFloat)
86    {
87        MultiType mt1(0.1234f);
88        MultiType mt2(mt1);
89
90        EXPECT_TRUE(mt2.isType<float>());
91        EXPECT_EQ(0.1234f, mt2.get<float>());
92    }
93
94    //////////////////////
95    // Assignment Value //
96    //////////////////////
97    TEST(MultiType, AssignmentIntToEmpty)
98    {
99        MultiType mt;
100
101        EXPECT_TRUE(mt.null());
102
103        mt = 55;
104
105        EXPECT_FALSE(mt.null());
106        EXPECT_TRUE(mt.isType<int>());
107        EXPECT_EQ(55, mt.get<int>());
108    }
109
110    TEST(MultiType, AssignmentFloatToInt)
111    {
112        MultiType mt(66);
113
114        EXPECT_TRUE(mt.isType<int>());
115        EXPECT_EQ(66, mt.get<int>());
116
117        mt = 77.7f; // will be converted to int
118
119        EXPECT_TRUE(mt.isType<int>());
120        EXPECT_EQ(77, mt.get<int>());
121        EXPECT_EQ(77.0f, mt.get<float>());
122    }
123
124    TEST(MultiType, AssignmentFloatToFloat)
125    {
126        MultiType mt(66.6f);
127
128        EXPECT_TRUE(mt.isType<float>());
129        EXPECT_EQ(66, mt.get<int>());
130        EXPECT_EQ(66.6f, mt.get<float>());
131
132        mt = 77.7f;
133
134        EXPECT_TRUE(mt.isType<float>());
135        EXPECT_EQ(77, mt.get<int>());
136        EXPECT_EQ(77.7f, mt.get<float>());
137    }
138
139    TEST(MultiType, AssignmentFloatToVector3)
140    {
141        MultiType mt(Vector3(1, 2, 3));
142
143        EXPECT_TRUE(mt.isType<Vector3>());
144        EXPECT_EQ(Vector3(1, 2, 3), mt.get<Vector3>());
145        EXPECT_TRUE(mt.lastConversionSuccessful());
146
147        mt = 77.7f;
148
149        EXPECT_TRUE(mt.isType<Vector3>());
150        EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
151        EXPECT_FALSE(mt.lastConversionSuccessful());
152    }
153
154    //////////////////////
155    // Assignment Other //
156    //////////////////////
157    TEST(MultiType, AssignmentOther)
158    {
159        MultiType mt1(33);
160        MultiType mt2(44.4f);
161
162        EXPECT_TRUE(mt1.isType<int>());
163        EXPECT_TRUE(mt2.isType<float>());
164
165        EXPECT_EQ(33, mt1.get<int>());
166        EXPECT_EQ(33.0f, mt1.get<float>());
167        EXPECT_EQ(44.4f, mt2.get<float>());
168
169        mt1 = mt2;
170
171        EXPECT_TRUE(mt1.isType<int>());
172        EXPECT_TRUE(mt2.isType<float>());
173
174        EXPECT_EQ(44, mt1.get<int>());
175        EXPECT_EQ(44.0f, mt1.get<float>());
176        EXPECT_EQ(44.4f, mt2.get<float>());
177    }
178
179    ////////////////
180    // set(value) //
181    ////////////////
182    TEST(MultiType, SetValueBoolToEmpty)
183    {
184        MultiType mt;
185
186        mt.set(true);
187
188        EXPECT_TRUE(mt.isType<bool>());
189        EXPECT_EQ(true, mt.get<bool>());
190    }
191
192    TEST(MultiType, SetValueIntToString)
193    {
194        MultiType mt("Hello");
195
196        EXPECT_TRUE(mt.isType<std::string>());
197        EXPECT_EQ("Hello", mt.get<std::string>());
198
199        mt.set(1234);
200
201        EXPECT_TRUE(mt.isType<std::string>());
202        EXPECT_EQ("1234", mt.get<std::string>());
203    }
204
205    //////////////////////
206    // force<type>(value) //
207    //////////////////////
208    TEST(MultiType, SetValueWithTypeIntToString)
209    {
210        MultiType mt("Hello");
211
212        EXPECT_TRUE(mt.isType<std::string>());
213        EXPECT_EQ("Hello", mt.get<std::string>());
214
215        mt.force<int>(1234);
216
217        EXPECT_TRUE(mt.isType<int>());
218        EXPECT_EQ(1234, mt.get<int>());
219    }
220
221    TEST(MultiType, SetValueWithTypeIntAsStringToString)
222    {
223        MultiType mt("Hello");
224
225        EXPECT_TRUE(mt.isType<std::string>());
226        EXPECT_EQ("Hello", mt.get<std::string>());
227
228        mt.force<int>("1234");
229
230        EXPECT_TRUE(mt.isType<int>());
231        EXPECT_EQ(1234, mt.get<int>());
232    }
233
234    TEST(MultiType, SetValueWithTypeIntToInt)
235    {
236        MultiType mt(4321);
237
238        EXPECT_TRUE(mt.isType<int>());
239        EXPECT_EQ(4321, mt.get<int>());
240
241        mt.force<int>(1234);
242
243        EXPECT_TRUE(mt.isType<int>());
244        EXPECT_EQ(1234, mt.get<int>());
245    }
246
247    /////////////////////
248    // convert<type>() //
249    /////////////////////
250    TEST(MultiType, ConvertEmptyToInt)
251    {
252        MultiType mt;
253        mt.convert<int>();
254
255        EXPECT_TRUE(mt.isType<int>());
256        EXPECT_EQ(0, mt.get<int>());
257    }
258
259    TEST(MultiType, ConvertFloatToInt)
260    {
261        MultiType mt(1.234f);
262
263        EXPECT_TRUE(mt.isType<float>());
264        EXPECT_EQ(1.234f, mt.get<float>());
265        EXPECT_EQ(1, mt.get<int>());
266
267        mt.convert<int>();
268
269        EXPECT_TRUE(mt.isType<int>());
270        EXPECT_EQ(1.0f, mt.get<float>());
271        EXPECT_EQ(1, mt.get<int>());
272    }
273
274    TEST(MultiType, ConvertFloatToVector3)
275    {
276        MultiType mt(1.234f);
277
278        EXPECT_TRUE(mt.isType<float>());
279        EXPECT_EQ(1.234f, mt.get<float>());
280        EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
281
282        mt.convert<Vector3>();
283
284        EXPECT_TRUE(mt.isType<Vector3>());
285        EXPECT_EQ(0.0f, mt.get<float>());
286        EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
287
288        EXPECT_FALSE(mt.lastConversionSuccessful());
289    }
290
291    ///////////
292    // reset //
293    ///////////
294    TEST(MultiType, Reset)
295    {
296        MultiType mt(10);
297
298        EXPECT_TRUE(mt.isType<int>());
299        EXPECT_FALSE(mt.isType<void>());
300        EXPECT_FALSE(mt.null());
301        EXPECT_EQ(10, mt.get<int>());
302
303        mt.reset();
304
305        EXPECT_FALSE(mt.isType<int>());
306        EXPECT_TRUE(mt.isType<void>());
307        EXPECT_TRUE(mt.null());
308        EXPECT_EQ(0, mt.get<int>());
309    }
310
311    ///////////////////
312    // reset<type>() //
313    ///////////////////
314    TEST(MultiType, SetType)
315    {
316        MultiType mt(10);
317
318        EXPECT_TRUE(mt.isType<int>());
319        EXPECT_FALSE(mt.isType<float>());
320        EXPECT_EQ(10, mt.get<int>());
321
322        mt.reset<float>();
323
324        EXPECT_FALSE(mt.isType<int>());
325        EXPECT_TRUE(mt.isType<float>());
326        EXPECT_EQ(0, mt.get<int>());
327    }
328
329    ////////////////
330    // resetValue //
331    ////////////////
332    TEST(MultiType, resetValue)
333    {
334        MultiType mt(10);
335
336        EXPECT_TRUE(mt.isType<int>());
337        EXPECT_EQ(10, mt.get<int>());
338
339        mt.resetValue();
340
341        EXPECT_TRUE(mt.isType<int>());
342        EXPECT_EQ(0, mt.get<int>());
343    }
344
345    /////////////////////
346    // type operator() //
347    /////////////////////
348    TEST(MultiType, ConversionOperatorFloatToFloat)
349    {
350        MultiType mt(12.34f);
351        float value = mt;
352        EXPECT_EQ(12.34f, value);
353    }
354
355    TEST(MultiType, ConversionOperatorFloatToInt)
356    {
357        MultiType mt(12.34f);
358        int value = mt;
359        EXPECT_EQ(12, value);
360    }
361
362    TEST(MultiType, ConversionOperatorIntToFloat)
363    {
364        MultiType mt(123);
365        float value = mt;
366        EXPECT_EQ(123, value);
367    }
368
369    TEST(MultiType, ConversionOperatorIntToString)
370    {
371        MultiType mt(123);
372        std::string value = mt;
373        EXPECT_EQ("123", value);
374    }
375
376    TEST(MultiType, ConversionOperatorStringToInt)
377    {
378        MultiType mt("321");
379        int value = mt;
380        EXPECT_EQ(321, value);
381    }
382
383    namespace
384    {
385        void helper_function(const std::string& a, float b, int c)
386        {
387            EXPECT_EQ("555.555", a);
388            EXPECT_EQ(555.555f, b);
389            EXPECT_EQ(555, c);
390        }
391    }
392
393    TEST(MultiType, ConversionOperatorPassToFunction)
394    {
395        MultiType mt("555.555");
396
397        helper_function(mt, mt, mt);
398    }
399
400    ///////////////////////
401    // getValue(pointer) //
402    ///////////////////////
403    TEST(MultiType, GetValueIntToInt)
404    {
405        MultiType mt(33);
406
407        int value = 0;
408        EXPECT_TRUE(mt.getValue(&value));
409        EXPECT_EQ(33, value);
410    }
411
412    TEST(MultiType, GetValueIntToFloat)
413    {
414        MultiType mt(33);
415
416        float value = 0;
417        EXPECT_TRUE(mt.getValue(&value));
418        EXPECT_EQ(33.0f, value);
419    }
420
421    TEST(MultiType, GetValueIntToVector3)
422    {
423        MultiType mt(33);
424
425        Vector3 value = Vector3::ZERO;
426        EXPECT_FALSE(mt.getValue(&value));
427        EXPECT_EQ(Vector3::ZERO, value);
428    }
429
430    //////////////
431    // get<type>() //
432    //////////////
433    TEST(MultiType, GetValueFromInt)
434    {
435        MultiType mt(256);
436
437        EXPECT_EQ(0, mt.get<char>());
438        EXPECT_EQ(0u, mt.get<unsigned char>());
439        EXPECT_EQ(256, mt.get<short>());
440        EXPECT_EQ(256u, mt.get<unsigned short>());
441        EXPECT_EQ(256, mt.get<int>());
442        EXPECT_EQ(256u, mt.get<unsigned int>());
443        EXPECT_EQ(256, mt.get<long>());
444        EXPECT_EQ(256u, mt.get<unsigned long>());
445        EXPECT_EQ(256, mt.get<long long>());
446        EXPECT_EQ(256u, mt.get<unsigned long long>());
447        EXPECT_EQ(256.0f, mt.get<float>());
448        EXPECT_EQ(256.0, mt.get<double>());
449        EXPECT_EQ(256.0, mt.get<long double>());
450        EXPECT_TRUE(mt.get<bool>());
451        EXPECT_EQ("256", mt.get<std::string>());
452    }
453
454    TEST(MultiType, GetValueFromFloat)
455    {
456        MultiType mt(128.821);
457
458        EXPECT_EQ(-128, mt.get<char>());
459        EXPECT_EQ(128u, mt.get<unsigned char>());
460        EXPECT_EQ(128, mt.get<short>());
461        EXPECT_EQ(128u, mt.get<unsigned short>());
462        EXPECT_EQ(128, mt.get<int>());
463        EXPECT_EQ(128u, mt.get<unsigned int>());
464        EXPECT_EQ(128, mt.get<long>());
465        EXPECT_EQ(128u, mt.get<unsigned long>());
466        EXPECT_EQ(128, mt.get<long long>());
467        EXPECT_EQ(128u, mt.get<unsigned long long>());
468        EXPECT_EQ(128.821f, mt.get<float>());
469        EXPECT_EQ(128.821, mt.get<double>());
470        EXPECT_EQ(128.821, mt.get<long double>());
471        EXPECT_TRUE(mt.get<bool>());
472        EXPECT_EQ("128.821", mt.get<std::string>());
473    }
474
475    TEST(MultiType, GetValueFromString)
476    {
477        MultiType mt("0.123");
478
479        EXPECT_EQ('0', mt.get<char>());
480        EXPECT_EQ('0', mt.get<unsigned char>());
481        EXPECT_EQ(0, mt.get<short>());
482        EXPECT_EQ(0u, mt.get<unsigned short>());
483        EXPECT_EQ(0, mt.get<int>());
484        EXPECT_EQ(0u, mt.get<unsigned int>());
485        EXPECT_EQ(0, mt.get<long>());
486        EXPECT_EQ(0u, mt.get<unsigned long>());
487        EXPECT_EQ(0, mt.get<long long>());
488        EXPECT_EQ(0u, mt.get<unsigned long long>());
489        EXPECT_EQ(0.123f, mt.get<float>());
490        EXPECT_EQ(0.123, mt.get<double>());
491        EXPECT_DOUBLE_EQ(0.123, mt.get<long double>());
492        EXPECT_FALSE(mt.get<bool>());
493        EXPECT_EQ("0.123", mt.get<std::string>());
494    }
495
496    ////////////////////
497    // isType<type>() //
498    ////////////////////
499    TEST(MultiType, IsTypeInt)
500    {
501        MultiType mt(1);
502
503        EXPECT_FALSE(mt.isType<void>());
504        EXPECT_FALSE(mt.isType<char>());
505        EXPECT_FALSE(mt.isType<unsigned char>());
506        EXPECT_FALSE(mt.isType<short>());
507        EXPECT_FALSE(mt.isType<unsigned short>());
508        EXPECT_TRUE(mt.isType<int>());
509        EXPECT_FALSE(mt.isType<unsigned int>());
510        EXPECT_FALSE(mt.isType<long>());
511        EXPECT_FALSE(mt.isType<unsigned long>());
512        EXPECT_FALSE(mt.isType<long long>());
513        EXPECT_FALSE(mt.isType<unsigned long long>());
514        EXPECT_FALSE(mt.isType<float>());
515        EXPECT_FALSE(mt.isType<double>());
516        EXPECT_FALSE(mt.isType<long double>());
517        EXPECT_FALSE(mt.isType<bool>());
518        EXPECT_FALSE(mt.isType<void*>());
519        EXPECT_FALSE(mt.isType<std::string>());
520        EXPECT_FALSE(mt.isType<orxonox::Vector2>());
521        EXPECT_FALSE(mt.isType<orxonox::Vector3>());
522        EXPECT_FALSE(mt.isType<orxonox::Vector4>());
523        EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
524        EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
525        EXPECT_FALSE(mt.isType<orxonox::Radian>());
526        EXPECT_FALSE(mt.isType<orxonox::Degree>());
527    }
528
529    TEST(MultiType, IsTypeUnsignedInt)
530    {
531        MultiType mt(1u);
532
533        EXPECT_FALSE(mt.isType<void>());
534        EXPECT_FALSE(mt.isType<char>());
535        EXPECT_FALSE(mt.isType<unsigned char>());
536        EXPECT_FALSE(mt.isType<short>());
537        EXPECT_FALSE(mt.isType<unsigned short>());
538        EXPECT_FALSE(mt.isType<int>());
539        EXPECT_TRUE(mt.isType<unsigned int>());
540        EXPECT_FALSE(mt.isType<long>());
541        EXPECT_FALSE(mt.isType<unsigned long>());
542        EXPECT_FALSE(mt.isType<long long>());
543        EXPECT_FALSE(mt.isType<unsigned long long>());
544        EXPECT_FALSE(mt.isType<float>());
545        EXPECT_FALSE(mt.isType<double>());
546        EXPECT_FALSE(mt.isType<long double>());
547        EXPECT_FALSE(mt.isType<bool>());
548        EXPECT_FALSE(mt.isType<void*>());
549        EXPECT_FALSE(mt.isType<std::string>());
550        EXPECT_FALSE(mt.isType<orxonox::Vector2>());
551        EXPECT_FALSE(mt.isType<orxonox::Vector3>());
552        EXPECT_FALSE(mt.isType<orxonox::Vector4>());
553        EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
554        EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
555        EXPECT_FALSE(mt.isType<orxonox::Radian>());
556        EXPECT_FALSE(mt.isType<orxonox::Degree>());
557    }
558
559    TEST(MultiType, IsTypeDouble)
560    {
561        MultiType mt(1.0);
562
563        EXPECT_FALSE(mt.isType<void>());
564        EXPECT_FALSE(mt.isType<char>());
565        EXPECT_FALSE(mt.isType<unsigned char>());
566        EXPECT_FALSE(mt.isType<short>());
567        EXPECT_FALSE(mt.isType<unsigned short>());
568        EXPECT_FALSE(mt.isType<int>());
569        EXPECT_FALSE(mt.isType<unsigned int>());
570        EXPECT_FALSE(mt.isType<long>());
571        EXPECT_FALSE(mt.isType<unsigned long>());
572        EXPECT_FALSE(mt.isType<long long>());
573        EXPECT_FALSE(mt.isType<unsigned long long>());
574        EXPECT_FALSE(mt.isType<float>());
575        EXPECT_TRUE(mt.isType<double>());
576        EXPECT_FALSE(mt.isType<long double>());
577        EXPECT_FALSE(mt.isType<bool>());
578        EXPECT_FALSE(mt.isType<void*>());
579        EXPECT_FALSE(mt.isType<std::string>());
580        EXPECT_FALSE(mt.isType<orxonox::Vector2>());
581        EXPECT_FALSE(mt.isType<orxonox::Vector3>());
582        EXPECT_FALSE(mt.isType<orxonox::Vector4>());
583        EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
584        EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
585        EXPECT_FALSE(mt.isType<orxonox::Radian>());
586        EXPECT_FALSE(mt.isType<orxonox::Degree>());
587    }
588
589    TEST(MultiType, IsTypeString)
590    {
591        MultiType mt("1");
592
593        EXPECT_FALSE(mt.isType<void>());
594        EXPECT_FALSE(mt.isType<char>());
595        EXPECT_FALSE(mt.isType<unsigned char>());
596        EXPECT_FALSE(mt.isType<short>());
597        EXPECT_FALSE(mt.isType<unsigned short>());
598        EXPECT_FALSE(mt.isType<int>());
599        EXPECT_FALSE(mt.isType<unsigned int>());
600        EXPECT_FALSE(mt.isType<long>());
601        EXPECT_FALSE(mt.isType<unsigned long>());
602        EXPECT_FALSE(mt.isType<long long>());
603        EXPECT_FALSE(mt.isType<unsigned long long>());
604        EXPECT_FALSE(mt.isType<float>());
605        EXPECT_FALSE(mt.isType<double>());
606        EXPECT_FALSE(mt.isType<long double>());
607        EXPECT_FALSE(mt.isType<bool>());
608        EXPECT_FALSE(mt.isType<void*>());
609        EXPECT_TRUE(mt.isType<std::string>());
610        EXPECT_FALSE(mt.isType<orxonox::Vector2>());
611        EXPECT_FALSE(mt.isType<orxonox::Vector3>());
612        EXPECT_FALSE(mt.isType<orxonox::Vector4>());
613        EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
614        EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
615        EXPECT_FALSE(mt.isType<orxonox::Radian>());
616        EXPECT_FALSE(mt.isType<orxonox::Degree>());
617    }
618
619    TEST(MultiType, IsTypeDegree)
620    {
621        MultiType mt(Degree(1));
622
623        EXPECT_FALSE(mt.isType<void>());
624        EXPECT_FALSE(mt.isType<char>());
625        EXPECT_FALSE(mt.isType<unsigned char>());
626        EXPECT_FALSE(mt.isType<short>());
627        EXPECT_FALSE(mt.isType<unsigned short>());
628        EXPECT_FALSE(mt.isType<int>());
629        EXPECT_FALSE(mt.isType<unsigned int>());
630        EXPECT_FALSE(mt.isType<long>());
631        EXPECT_FALSE(mt.isType<unsigned long>());
632        EXPECT_FALSE(mt.isType<long long>());
633        EXPECT_FALSE(mt.isType<unsigned long long>());
634        EXPECT_FALSE(mt.isType<float>());
635        EXPECT_FALSE(mt.isType<double>());
636        EXPECT_FALSE(mt.isType<long double>());
637        EXPECT_FALSE(mt.isType<bool>());
638        EXPECT_FALSE(mt.isType<void*>());
639        EXPECT_FALSE(mt.isType<std::string>());
640        EXPECT_FALSE(mt.isType<orxonox::Vector2>());
641        EXPECT_FALSE(mt.isType<orxonox::Vector3>());
642        EXPECT_FALSE(mt.isType<orxonox::Vector4>());
643        EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
644        EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
645        EXPECT_FALSE(mt.isType<orxonox::Radian>());
646        EXPECT_TRUE(mt.isType<orxonox::Degree>());
647    }
648
649    ////////////////////////////////
650    // lastConversionSuccessful() //
651    ////////////////////////////////
652    TEST(MultiType, LastConversionSuccessful)
653    {
654        MultiType mt;
655
656        EXPECT_TRUE(mt.lastConversionSuccessful());
657
658        mt = 5.55;
659
660        EXPECT_TRUE(mt.lastConversionSuccessful());
661
662        mt.convert<int>();
663
664        EXPECT_TRUE(mt.lastConversionSuccessful());
665
666        mt.convert<Vector3>();
667
668        EXPECT_FALSE(mt.lastConversionSuccessful());
669
670        mt.convert<std::string>();
671
672        EXPECT_TRUE(mt.lastConversionSuccessful());
673    }
674
675    ////////////
676    // null() //
677    ////////////
678    TEST(MultiType, Null1)
679    {
680        MultiType mt;
681
682        EXPECT_TRUE(mt.null());
683
684        mt = 5;
685
686        EXPECT_FALSE(mt.null());
687    }
688
689    TEST(MultiType, Null2)
690    {
691        MultiType mt(5);
692
693        EXPECT_FALSE(mt.null());
694
695        mt.reset();
696
697        EXPECT_TRUE(mt.null());
698    }
699
700    ///////////////////////////////
701    // Strongly typed enum class //
702    ///////////////////////////////
703    enum class EnumWithChar : unsigned char
704    {
705        ValueA = 'A',
706        ValueB = 'B',
707        ValueC = 'C',
708    };
709    enum class EnumWithInt
710    {
711        Value1 = 50,
712        Value2 = 0,
713        Value3,
714    };
715
716    TEST(MultiType, Enum_Constructor)
717    {
718        // Constructor:
719        {
720            MultiType mt = EnumWithChar::ValueA;
721
722            EXPECT_TRUE(mt.isType<EnumWithChar>());
723            EXPECT_EQ(EnumWithChar::ValueA, mt.get<EnumWithChar>());
724        }
725        {
726            MultiType mt = MultiType(EnumWithInt::Value1);
727
728            EXPECT_TRUE(mt.isType<EnumWithInt>());
729            EXPECT_EQ(EnumWithInt::Value1, mt.get<EnumWithInt>());
730        }
731    }
732
733    TEST(MultiType, Enum_Assignment)
734    {
735        // operator=:
736        MultiType mt;
737        mt = EnumWithChar::ValueB;
738
739        EXPECT_TRUE(mt.isType<EnumWithChar>());
740        EXPECT_EQ(EnumWithChar::ValueB, mt.get<EnumWithChar>());
741    }
742
743    TEST(MultiType, Enum_Set)
744    {
745        // set(value):
746        {
747            MultiType mt;
748            mt.set(EnumWithInt::Value2); // assign enum to an empty MultiType
749
750            EXPECT_TRUE(mt.isType<EnumWithInt>());
751            EXPECT_EQ(EnumWithInt::Value2, mt.get<EnumWithInt>());
752        }
753        {
754            MultiType mt = "string";
755            mt.set(EnumWithChar::ValueC); // assign enum to a MultiType with type std::string
756
757            EXPECT_TRUE(mt.isType<std::string>());
758            EXPECT_EQ("C", mt.get<std::string>());
759        }
760        {
761            MultiType mt = EnumWithChar::ValueA;
762            mt.set(EnumWithChar::ValueB); // assign enum to a MultiType with type std::string
763
764            EXPECT_TRUE(mt.isType<EnumWithChar>());
765            EXPECT_EQ(EnumWithChar::ValueB, mt.get<EnumWithChar>());
766        }
767        {
768            MultiType mt = EnumWithInt::Value3;
769            mt.set("50"); // assign enum to a MultiType with type std::string
770
771            EXPECT_TRUE(mt.isType<EnumWithInt>());
772            EXPECT_EQ(EnumWithInt::Value1, mt.get<EnumWithInt>());
773        }
774    }
775
776    TEST(MultiType, Enum_Force)
777    {
778        // force(value):
779        {
780            MultiType mt = "string";
781            EXPECT_TRUE(mt.isType<std::string>());
782            EXPECT_EQ("string", mt.get<std::string>());
783
784            mt.force<EnumWithChar>("C");
785
786            EXPECT_TRUE(mt.isType<EnumWithChar>());
787            EXPECT_EQ(EnumWithChar::ValueC, mt.get<EnumWithChar>());
788        }
789        {
790            MultiType mt = EnumWithChar::ValueA;
791            EXPECT_TRUE(mt.isType<EnumWithChar>());
792            EXPECT_EQ(EnumWithChar::ValueA, mt.get<EnumWithChar>());
793
794            mt.force<std::string>(EnumWithChar::ValueB);
795
796            EXPECT_TRUE(mt.isType<std::string>());
797            EXPECT_EQ("B", mt.get<std::string>());
798        }
799    }
800
801    TEST(MultiType, Enum_Convert)
802    {
803        // convert():
804        {
805            MultiType mt = "C";
806            mt.convert<EnumWithChar>();
807
808            EXPECT_TRUE(mt.isType<EnumWithChar>());
809            EXPECT_EQ(EnumWithChar::ValueC, mt.get<EnumWithChar>());
810        }
811        {
812            MultiType mt = EnumWithChar::ValueA;
813            mt.convert<std::string>();
814
815            EXPECT_TRUE(mt.isType<std::string>());
816            EXPECT_EQ("A", mt.get<std::string>());
817        }
818    }
819
820    TEST(MultiType, Enum_Reset)
821    {
822        // reset():
823        {
824            MultiType mt = EnumWithChar::ValueA;
825            mt.reset<EnumWithChar>();
826
827            EXPECT_TRUE(mt.isType<EnumWithChar>());
828            EXPECT_TRUE(mt.isType<unsigned char>());
829            EXPECT_EQ('\0', mt.get<unsigned char>());
830        }
831        {
832            MultiType mt = "string";
833            mt.reset<EnumWithInt>();
834
835            EXPECT_TRUE(mt.isType<EnumWithInt>());
836            EXPECT_TRUE(mt.isType<int>());
837            EXPECT_EQ(0, mt.get<int>());
838        }
839    }
840
841    TEST(MultiType, Enum_IsType)
842    {
843        // isType():
844        {
845            MultiType mt = EnumWithChar::ValueB;
846            EXPECT_TRUE(mt.isType<EnumWithChar>());
847            EXPECT_TRUE(mt.isType<unsigned char>());
848            EXPECT_FALSE(mt.isType<char>());
849            EXPECT_FALSE(mt.isType<int>());
850            EXPECT_FALSE(mt.isType<bool>());
851            EXPECT_FALSE(mt.isType<std::string>());
852        }
853        {
854            MultiType mt = EnumWithInt::Value3;
855            EXPECT_TRUE(mt.isType<EnumWithInt>());
856            EXPECT_TRUE(mt.isType<int>());
857            EXPECT_FALSE(mt.isType<unsigned char>());
858            EXPECT_FALSE(mt.isType<char>());
859            EXPECT_FALSE(mt.isType<bool>());
860            EXPECT_FALSE(mt.isType<std::string>());
861        }
862    }
863
864    TEST(MultiType, Enum_ConversionOperator)
865    {
866        // conversion operator:
867        {
868            MultiType mt = EnumWithChar::ValueA;
869            EnumWithChar value = mt;
870            EXPECT_EQ(EnumWithChar::ValueA, value);
871        }
872        {
873            MultiType mt = 'B';
874            EnumWithChar value = mt;
875            EXPECT_EQ(EnumWithChar::ValueB, value);
876        }
877        {
878            MultiType mt = EnumWithInt::Value1;
879            std::string value = mt;
880            EXPECT_EQ("50", value);
881        }
882    }
883
884    TEST(MultiType, Enum_GetValue)
885    {
886        // getValue():
887        {
888            MultiType mt = EnumWithChar::ValueA;
889            EnumWithChar value;
890            mt.getValue(&value);
891            EXPECT_EQ(EnumWithChar::ValueA, value);
892        }
893        {
894            MultiType mt = 'B';
895            EnumWithChar value;
896            mt.getValue(&value);
897            EXPECT_EQ(EnumWithChar::ValueB, value);
898        }
899        {
900            MultiType mt = EnumWithInt::Value1;
901            std::string value;
902            mt.getValue(&value);
903            EXPECT_EQ("50", value);
904        }
905    }
906
907    TEST(MultiType, Enum_Get)
908    {
909        // get():
910        {
911            MultiType mt = EnumWithChar::ValueB;
912            EXPECT_EQ(EnumWithChar::ValueB, mt.get<EnumWithChar>());
913
914            EXPECT_EQ('B', mt.get<unsigned char>());
915            EXPECT_EQ("B", mt.get<std::string>());
916            EXPECT_EQ(66, mt.get<int>());
917            EXPECT_TRUE(mt.get<bool>());
918        }
919        {
920            MultiType mt = EnumWithInt::Value1;
921            EXPECT_EQ(EnumWithInt::Value1, mt.get<EnumWithInt>());
922
923            EXPECT_EQ('2', mt.get<unsigned char>());
924            EXPECT_EQ("50", mt.get<std::string>());
925            EXPECT_EQ(50, mt.get<int>());
926            EXPECT_TRUE(mt.get<bool>());
927        }
928        {
929            MultiType mt = EnumWithInt::Value2;
930            EXPECT_EQ(EnumWithInt::Value2, mt.get<EnumWithInt>());
931
932            EXPECT_EQ('\0', mt.get<unsigned char>());
933            EXPECT_EQ("0", mt.get<std::string>());
934            EXPECT_EQ(0, mt.get<int>());
935            EXPECT_FALSE(mt.get<bool>());
936        }
937    }
938}
Note: See TracBrowser for help on using the repository browser.