1//------------------------------------------------------------------------------
2//	MessageItemTest.h
3//
4//------------------------------------------------------------------------------
5
6#ifndef MESSAGEITEMTEST_H
7#define MESSAGEITEMTEST_H
8
9// A sad attempt to get rid of the horrible and pathetic vector<bool> specialization
10#define __SGI_STL_INTERNAL_BVECTOR_H
11
12// Standard Includes -----------------------------------------------------------
13#include <iostream>
14#include <stdio.h>
15#include <typeinfo>
16#include <posix/string.h>
17
18// System Includes -------------------------------------------------------------
19#include <Message.h>
20
21// Project Includes ------------------------------------------------------------
22
23// Local Includes --------------------------------------------------------------
24#include "../common.h"
25
26// Local Defines ---------------------------------------------------------------
27#define TEMPLATE_TEST_PARAMS <Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>
28#define ADD_TEMPLATE_TEST(classbeingtested, suitename, classname, funcname)				\
29	(suitename)->addTest(new TestCaller<classname>(((string(#classbeingtested) + "::" + #funcname + "::" + typeid(Type).name()).c_str() ),	\
30						 &classname::funcname));
31
32// Globals ---------------------------------------------------------------------
33template
34<
35	class Type,				// int32
36	type_code TypeCode,		// B_INT32_TYPE
37	class FuncPolicy,		// status_t Add(BMessage&, const char*, Type&)
38							// status_t Find(BMessage&, const char*, int32, Type*)
39							// Type QuickFind(BMessage&, const char*, int32)
40							// bool Has(BMessage&, const char*, int32)
41							// status_t Replace(BMessage&, const char*, int32, Type)
42	class InitPolicy,		// Type Zero()
43							// Type Test1()
44							// Type Test2()
45							// size_t SizeOf(const Type&)
46							// ArrayType Array()
47							// typedef XXX ArrayType
48	class AssertPolicy,		// Type Zero()
49							// Type Invalid()
50	class ComparePolicy		// bool Compare(const Type& lhs, const Type& rhs)
51>
52class TMessageItemTest;
53
54
55//------------------------------------------------------------------------------
56template<class T>
57struct ArrayTypeBase
58{
59	typedef vector<T> ArrayType;
60	typedef typename ArrayType::size_type SizeType;
61	static SizeType Size(ArrayType& array) { return array.size(); }
62};
63//------------------------------------------------------------------------------
64template<class Type>
65struct TypePolicy
66{
67	enum { FixedSize = true };
68	inline Type& Dereference(Type* p)
69	{
70		return *p;
71	}
72	inline Type* AddressOf(Type& t) { return &t; }
73};
74//------------------------------------------------------------------------------
75template
76<
77	typename Type,
78	status_t (BMessage::*AddFunc)(const char*, Type),
79	status_t (BMessage::*FindFunc)(const char*, int32, Type*) const,
80	status_t (BMessage::*ShortFindFunc)(const char*, Type*) const,
81	Type (BMessage::*QuickFindFunc)(const char*, int32) const,
82	bool (BMessage::*HasFunc)(const char*, int32) const,
83	status_t (BMessage::*ReplaceFunc)(const char*, int32, Type),
84	status_t (BMessage::*AddDataFunc)(const char*, type_code, const void*,
85									  ssize_t, bool, int32) = &BMessage::AddData,
86	status_t (BMessage::*FindDataFunc)(const char*, type_code, int32,
87									   const void**, ssize_t*) const = &BMessage::FindData
88>
89struct TMessageItemFuncPolicy : public TypePolicy<Type>
90{
91	static status_t Add(BMessage& msg, const char* name, Type& val)
92	{
93		return (msg.*AddFunc)(name, val);
94	}
95	static status_t AddData(BMessage& msg, const char* name, type_code type,
96		Type* val, ssize_t size, bool fixedSize = true)
97	{
98		return (msg.*AddDataFunc)(name, type, (const void*)val, size, fixedSize, 1);
99	}
100	static status_t Find(BMessage& msg, const char* name, int32 index, Type* val)
101	{
102		return (msg.*FindFunc)(name, index, val);
103	}
104	static status_t ShortFind(BMessage& msg, const char* name, Type* val)
105	{
106		return (msg.*ShortFindFunc)(name, val);
107	}
108	static Type QuickFind(BMessage& msg, const char* name, int32 index)
109	{
110		return (msg.*QuickFindFunc)(name, index);
111	}
112	static bool Has(BMessage& msg, const char* name, int32 index)
113	{
114		return (msg.*HasFunc)(name, index);
115	}
116	static status_t Replace(BMessage& msg, const char* name, int32 index, Type& val)
117	{
118		return (msg.*ReplaceFunc)(name, index, val);
119	}
120	static status_t FindData(BMessage& msg, const char* name, type_code type,
121							 int32 index, const void** data, ssize_t* size)
122	{
123		return (msg.*FindDataFunc)(name, type, index, data, size);
124	}
125};
126//------------------------------------------------------------------------------
127template<class T, T zero = T(), T invalid = T()>
128struct TMessageItemAssertPolicy
129{
130	inline static T Zero()		{ return zero; }
131	inline static T Invalid()	{ return invalid; }
132	inline static bool Size(size_t size, T& t)
133		{ return size == sizeof (t); }
134};
135//------------------------------------------------------------------------------
136template<class T>
137struct TMessageItemComparePolicy
138{
139	inline static bool Compare(const T& lhs, const T& rhs);
140//		{ return lhs == rhs; }
141};
142template<class T>
143bool
144TMessageItemComparePolicy<T>::Compare(const T &lhs, const T &rhs)
145{
146	 return lhs == rhs;
147}
148//------------------------------------------------------------------------------
149template
150<
151	class Type,				// int32
152	type_code TypeCode,		// B_INT32_TYPE
153	class FuncPolicy,		// status_t Add(BMessage&, const char*, Type&)
154							// status_t Find(BMessage&, const char*, int32, Type*)
155							// Type QuickFind(BMessage&, const char*, int32)
156							// bool Has(BMessage&, const char*, int32)
157							// status_t Replace(BMessage&, const char*, int32, Type)
158							// status_t FindData(BMessage&, const char*, type_code, int32, const void**, ssize_t*)
159	class InitPolicy,		// Type Zero()
160							// Type Test1()
161							// Type Test2()
162							// size_t SizeOf(const Type&)
163							// ArrayType Array()
164							// typedef XXX ArrayType
165	class AssertPolicy,		// Type Zero()
166							// Type Invalid()
167							// bool Size(size_t, T&)
168	class ComparePolicy		// bool Compare(const Type& lhs, const Type& rhs)
169		= TMessageItemComparePolicy<Type>
170>
171class TMessageItemTest : public TestCase, public TypePolicy<Type>
172{
173	public:
174		TMessageItemTest() {;}
175		TMessageItemTest(std::string name) : TestCase(name) {;}
176
177		void MessageItemTest1();
178		void MessageItemTest2();
179		void MessageItemTest3();
180		void MessageItemTest4();
181		void MessageItemTest5();
182		void MessageItemTest6();
183		void MessageItemTest7();
184		void MessageItemTest8();
185		void MessageItemTest9();
186		void MessageItemTest10();
187		void MessageItemTest11();
188		void MessageItemTest12();
189
190		static TestSuite* Suite();
191
192	typedef typename InitPolicy::ArrayType ArrayType;
193};
194
195
196//------------------------------------------------------------------------------
197template
198<
199	class Type,
200	type_code TypeCode,
201	class FuncPolicy,
202	class InitPolicy,
203	class AssertPolicy,
204	class ComparePolicy
205>
206void
207TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
208MessageItemTest1()
209{
210	BMessage msg;
211	Type out = InitPolicy::Zero();
212	CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, "item", &out) == B_NAME_NOT_FOUND);
213	CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", 0, &out) == B_NAME_NOT_FOUND);
214	CPPUNIT_ASSERT(ComparePolicy::Compare(out, AssertPolicy::Invalid()));
215	CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", 0),
216										  AssertPolicy::Invalid()));
217	CPPUNIT_ASSERT(!FuncPolicy::Has(msg, "item", 0));
218	const void* ptr = &out;
219	ssize_t size;
220	CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, 0, &ptr, &size) ==
221				   B_NAME_NOT_FOUND);
222	CPPUNIT_ASSERT(ptr == NULL);
223}
224//------------------------------------------------------------------------------
225template
226<
227	class Type,
228	type_code TypeCode,
229	class FuncPolicy,
230	class InitPolicy,
231	class AssertPolicy,
232	class ComparePolicy
233>
234void
235TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
236MessageItemTest2()
237{
238	BMessage msg;
239	Type in = InitPolicy::Test1();
240	Type out = InitPolicy::Zero();
241	CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in) == B_OK);
242	CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", 0));
243	CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", 0), in));
244	CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, "item", &out) == B_OK);
245	CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", 0, &out) == B_OK);
246	CPPUNIT_ASSERT(ComparePolicy::Compare(out, in));
247	Type* pout = NULL;
248	ssize_t size;
249	status_t err = FuncPolicy::FindData(msg, "item", TypeCode, 0,
250										(const void**)&pout, &size);
251	CPPUNIT_ASSERT(err == B_OK);
252	CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in));
253	CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout)));
254}
255//------------------------------------------------------------------------------
256template
257<
258	class Type,
259	type_code TypeCode,
260	class FuncPolicy,
261	class InitPolicy,
262	class AssertPolicy,
263	class ComparePolicy
264>
265void
266TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
267MessageItemTest3()
268{
269	BMessage msg;
270	Type in = InitPolicy::Test1();
271	Type in2 = InitPolicy::Test2();
272	Type out = InitPolicy::Zero();
273	CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in) == B_OK);
274	CPPUNIT_ASSERT(FuncPolicy::Replace(msg, "item", 0, in2) == B_OK);
275	CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", 0));
276	CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", 0), in2));
277	CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, "item", &out) == B_OK);
278	CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", 0, &out) == B_OK);
279	CPPUNIT_ASSERT(ComparePolicy::Compare(out, in2));
280	out = InitPolicy::Zero();
281	Type* pout;
282	ssize_t size;
283	CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, 0,
284										(const void**)&pout, &size) == B_OK);
285	CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in2));
286	CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout)));
287}
288//------------------------------------------------------------------------------
289template
290<
291	class Type,
292	type_code TypeCode,
293	class FuncPolicy,
294	class InitPolicy,
295	class AssertPolicy,
296	class ComparePolicy
297>
298void
299TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
300MessageItemTest4()
301{
302	BMessage msg;
303	Type out = InitPolicy::Zero();
304	CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", 1, &out) == B_NAME_NOT_FOUND);
305	CPPUNIT_ASSERT(ComparePolicy::Compare(out, AssertPolicy::Invalid()));
306	CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", 1),
307										  AssertPolicy::Invalid()));
308	CPPUNIT_ASSERT(!FuncPolicy::Has(msg, "item", 1));
309	const void* ptr = &out;
310	ssize_t size;
311	CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, 1, &ptr, &size) ==
312				   B_NAME_NOT_FOUND);
313	CPPUNIT_ASSERT(ptr == NULL);
314}
315//------------------------------------------------------------------------------
316template
317<
318	class Type,
319	type_code TypeCode,
320	class FuncPolicy,
321	class InitPolicy,
322	class AssertPolicy,
323	class ComparePolicy
324>
325void
326TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
327MessageItemTest5()
328{
329	BMessage msg;
330	ArrayType in = InitPolicy::Array();
331	Type out = InitPolicy::Zero();
332	Type* pout;
333	ssize_t size;
334
335	for (uint32 ii = 0; ii < InitPolicy::Size(in); ++ii)
336	{
337		CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in[ii]) == B_OK);
338	}
339
340	for (uint32 i = 0; i < InitPolicy::Size(in); ++i)
341	{
342		CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", i));
343		CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", i),
344											  in[i]));
345		CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", i, &out) == B_OK);
346		CPPUNIT_ASSERT(ComparePolicy::Compare(out, in[i]));
347		CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, i,
348											(const void**)&pout, &size) == B_OK);
349		CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in[i]));
350		CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout)));
351	}
352}
353//------------------------------------------------------------------------------
354template
355<
356	class Type,
357	type_code TypeCode,
358	class FuncPolicy,
359	class InitPolicy,
360	class AssertPolicy,
361	class ComparePolicy
362>
363void
364TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
365MessageItemTest6()
366{
367	BMessage msg;
368	ArrayType in = InitPolicy::Array();
369	Type in2 = InitPolicy::Test2();
370	Type out = InitPolicy::Zero();
371	const int rIndex = 2;
372
373	for (uint32 i = 0; i < InitPolicy::Size(in); ++i)
374	{
375		CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in[i]) == B_OK);
376	}
377
378	CPPUNIT_ASSERT(FuncPolicy::Replace(msg, "item", rIndex, in2) == B_OK);
379	CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", rIndex));
380	CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", rIndex),
381										  in2));
382	CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", rIndex, &out) == B_OK);
383	CPPUNIT_ASSERT(ComparePolicy::Compare(out, in2));
384	out = InitPolicy::Zero();
385	Type* pout;
386	ssize_t size;
387	CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, rIndex,
388										(const void**)&pout, &size) == B_OK);
389	CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in2));
390	CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout)));
391}
392//------------------------------------------------------------------------------
393template
394<
395	class Type,
396	type_code TypeCode,
397	class FuncPolicy,
398	class InitPolicy,
399	class AssertPolicy,
400	class ComparePolicy
401>
402void
403TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
404MessageItemTest7()
405{
406	BMessage msg;
407	Type in = InitPolicy::Test1();
408	Type out = InitPolicy::Zero();
409	CPPUNIT_ASSERT(FuncPolicy::AddData(msg, "item", TypeCode, AddressOf(in),
410									   InitPolicy::SizeOf(in),
411									   TypePolicy<Type>::FixedSize) == B_OK);
412	CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", 0));
413	CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", 0),
414										  in));
415	CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, "item", &out) == B_OK);
416	CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", 0, &out) == B_OK);
417	CPPUNIT_ASSERT(ComparePolicy::Compare(out, in));
418	Type* pout = NULL;
419	ssize_t size;
420	CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, 0,
421										(const void**)&pout, &size) == B_OK);
422	CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in));
423	CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout)));
424}
425//------------------------------------------------------------------------------
426#include <stdio.h>
427template
428<
429	class Type,
430	type_code TypeCode,
431	class FuncPolicy,
432	class InitPolicy,
433	class AssertPolicy,
434	class ComparePolicy
435>
436void
437TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
438MessageItemTest8()
439{
440	BMessage msg;
441	ArrayType in = InitPolicy::Array();
442	Type out = InitPolicy::Zero();
443	Type* pout;
444	ssize_t size;
445	for (uint32 i = 0; i < InitPolicy::Size(in); ++i)
446	{
447		CPPUNIT_ASSERT(FuncPolicy::AddData(msg, "item", TypeCode,
448					   AddressOf(in[i]), InitPolicy::SizeOf(in[i]),
449					   TypePolicy<Type>::FixedSize) == B_OK);
450	}
451
452	for (uint32 i = 0; i < InitPolicy::Size(in); ++i)
453	{
454		CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", i));
455		CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", i),
456											  in[i]));
457		CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", i, &out) == B_OK);
458		CPPUNIT_ASSERT(ComparePolicy::Compare(out, in[i]));
459		CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, i,
460											(const void**)&pout, &size) == B_OK);
461		CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in[i]));
462		CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout)));
463	}
464}
465//------------------------------------------------------------------------------
466template
467<
468	class Type,
469	type_code TypeCode,
470	class FuncPolicy,
471	class InitPolicy,
472	class AssertPolicy,
473	class ComparePolicy
474>
475void
476TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
477MessageItemTest9()
478{
479	BMessage msg;
480	Type in = InitPolicy::Test1();
481	CPPUNIT_ASSERT(FuncPolicy::Add(msg, NULL, in) == B_BAD_VALUE);
482}
483//------------------------------------------------------------------------------
484template
485<
486	class Type,
487	type_code TypeCode,
488	class FuncPolicy,
489	class InitPolicy,
490	class AssertPolicy,
491	class ComparePolicy
492>
493void
494TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
495MessageItemTest10()
496{
497	BMessage msg;
498	Type in = InitPolicy::Test1();
499	Type out = InitPolicy::Zero();
500	CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in) == B_OK);
501	CPPUNIT_ASSERT(FuncPolicy::Has(msg, NULL, 0) == false);
502	CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, NULL, 0),
503										  AssertPolicy::Invalid()));
504	CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, NULL, &out) == B_BAD_VALUE);
505	CPPUNIT_ASSERT(FuncPolicy::Find(msg, NULL, 0, &out) == B_BAD_VALUE);
506	Type* pout = NULL;
507	ssize_t size;
508	status_t err = FuncPolicy::FindData(msg, NULL, TypeCode, 0,
509										(const void**)&pout, &size);
510	CPPUNIT_ASSERT(err == B_BAD_VALUE);
511}
512//------------------------------------------------------------------------------
513template
514<
515	class Type,
516	type_code TypeCode,
517	class FuncPolicy,
518	class InitPolicy,
519	class AssertPolicy,
520	class ComparePolicy
521>
522void
523TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
524MessageItemTest11()
525{
526	BMessage msg;
527	Type in = InitPolicy::Test1();
528	CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in) == B_OK);
529
530	ssize_t flatSize = msg.FlattenedSize();
531	char* buf = new char[flatSize];
532	CPPUNIT_ASSERT(buf);
533
534	CPPUNIT_ASSERT(msg.Flatten(buf, flatSize) == B_OK);
535
536	BMessage msg2;
537	Type out = InitPolicy::Zero();
538	CPPUNIT_ASSERT(msg2.Unflatten(buf) == B_OK);
539	CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, "item", &out) == B_OK);
540	CPPUNIT_ASSERT(ComparePolicy::Compare(in, out));
541
542	delete[] buf;
543}
544//------------------------------------------------------------------------------
545template
546<
547	class Type,
548	type_code TypeCode,
549	class FuncPolicy,
550	class InitPolicy,
551	class AssertPolicy,
552	class ComparePolicy
553>
554void
555TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
556MessageItemTest12()
557{
558	BMessage msg;
559	ArrayType in = InitPolicy::Array();
560
561	for (uint32 ii = 0; ii < InitPolicy::Size(in); ++ii)
562	{
563		CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in[ii]) == B_OK);
564	}
565
566	ssize_t flatSize = msg.FlattenedSize();
567	char* buf = new char[flatSize];
568	CPPUNIT_ASSERT(buf);
569
570	CPPUNIT_ASSERT(msg.Flatten(buf, flatSize) == B_OK);
571
572	BMessage msg2;
573	Type out = InitPolicy::Zero();
574	Type* pout;
575	ssize_t size;
576	CPPUNIT_ASSERT(msg2.Unflatten(buf) == B_OK);
577
578	for (uint32 i = 0; i < InitPolicy::Size(in); ++i)
579	{
580		CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", i));
581		CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", i),
582											  in[i]));
583		CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", i, &out) == B_OK);
584		CPPUNIT_ASSERT(ComparePolicy::Compare(out, in[i]));
585		CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, i,
586											(const void**)&pout, &size) == B_OK);
587		CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in[i]));
588		CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout)));
589	}
590
591	delete[] buf;
592}
593//------------------------------------------------------------------------------
594template
595<
596	class Type,
597	type_code TypeCode,
598	class FuncPolicy,
599	class InitPolicy,
600	class AssertPolicy,
601	class ComparePolicy
602>
603TestSuite*
604TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>::
605Suite()
606{
607	TestSuite* suite = new TestSuite("BMessage::Add/Find/Replace/HasRect()");
608
609	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest1);
610	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest2);
611	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest3);
612	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest4);
613	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest5);
614	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest6);
615	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest7);
616	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest8);
617#ifndef TEST_R5
618	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest9);
619	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest10);
620#endif
621	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest11);
622	ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest12);
623
624	return suite;
625}
626//------------------------------------------------------------------------------
627
628#endif	// MESSAGEITEMTEST_H
629
630/*
631 * $Log $
632 *
633 * $Id  $
634 *
635
636 */
637