Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

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

Last change on this file since 9226 was 9226, checked in by landauf, 12 years ago
changed hasDefaultValue() to lastConversionSuccessful() (inverted meaning) and fixed two issues with this function
File size: 24.0 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: