Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

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

Last change on this file since 10008 was 9545, checked in by landauf, 12 years ago
eol-style native
Property svn:eol-style set to `native`
File size: 23.3 KB

Line
1	#include <gtest/gtest.h>
2	#include "util/MultiType.h"
3
4	namespace 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.

Download in other formats: