/*
	$Id: PropertyConstructionTest.cpp 851 2002-08-22 03:15:35Z jrand $
	
	This file implements the construction test for the Haiku BPropertyInfo
	code.  This class tests the following usecases:
	  - Construction 1 to 4
	  - Destruction
	  - Properties
	  - Values
	  - Count Properties
	  - Count Values
	  - Unflatten
	
	*/


#include "PropertyConstructionTest.h"

#include <assert.h>


/*
 *  Method:  PropertyConstructionTest::PropertyConstructionTest()
 *   Descr:  This is the constructor for this class.
 */
		

	PropertyConstructionTest::PropertyConstructionTest(std::string name) :
		PropertyTestcase(name)
{
	}


/*
 *  Method:  PropertyConstructionTest::~PropertyConstructionTest()
 *   Descr:  This is the destructor for this class.
 */
 

	PropertyConstructionTest::~PropertyConstructionTest()
{
	}


/*
 *  Method:  PropertyConstructionTest::CompareProperties()
 *   Descr:  This member function checks that the two property_info structures
 *           passed in match.
 */	


	void PropertyConstructionTest::CompareProperties(
	    const property_info *prop1,
	    const property_info *prop2,
	    int prop_count)
{
	int i, j, k;

	if ((prop_count != 0) && (prop1 != prop2)) {
		assert(prop1 != NULL);
		assert(prop2 != NULL);
		for (i = 0; i < prop_count; i++) {
			assert(prop1[i].name != 0);
			assert(prop2[i].name != 0);
			assert(strcmp(prop1[i].name, prop2[i].name) == 0);
			
			for(j = 0; j < 10; j++) {
				assert(prop1[i].commands[j] == prop2[i].commands[j]);
				if (prop1[i].commands[j] == 0) {
					break;
				}
			}
			
			for(j = 0; j < 10; j++) {
				assert(prop1[i].specifiers[j] == prop2[i].specifiers[j]);
				if (prop1[i].specifiers[j] == 0) {
					break;
				}
			}
			
			if (prop1[i].usage != prop2[i].usage) {
				if (prop1[i].usage == NULL) {
					assert(prop2[i].usage == NULL);
				} else {
					assert(strcmp(prop1[i].usage, prop2[i].usage) == 0);
				}
			}
			
			assert(prop1[i].extra_data == prop2[i].extra_data);
			
			for(j = 0; j < 10; j++) {
				assert(prop1[i].types[j] == prop2[i].types[j]);
				if (prop1[i].types[j] == 0) {
					break;
				}
			}
			
			for(j = 0; j < 3; j++) {
				for(k = 0; k < 5; k++) {
					if (prop1[i].ctypes[j].pairs[k].name == 0) {
						assert(prop2[i].ctypes[j].pairs[k].name == 0);
						break;
					} else {
						assert(prop2[i].ctypes[j].pairs[k].name != 0);
						assert(strcmp(prop1[i].ctypes[j].pairs[k].name,
						              prop2[i].ctypes[j].pairs[k].name) == 0);
						assert(prop1[i].ctypes[j].pairs[k].type ==
						       prop2[i].ctypes[j].pairs[k].type);
					}
				}
				if (prop1[i].ctypes[j].pairs[0].name == 0) {
					break;
				}
			}
		}
	}
}


/*
 *  Method:  PropertyConstructionTest::CompareValues()
 *   Descr:  This member function checks that the two value_info structures
 *           passed in match.
 */	


	void PropertyConstructionTest::CompareValues(
	    const value_info *value1,
	    const value_info *value2,
	    int value_count)
{
	int i;
	if ((value_count != 0) && (value1 != value2)) {
		assert(value1 != NULL);
		assert(value2 != NULL);
		for (i = 0; i < value_count; i++) {
			assert(value1[i].name != 0);
			assert(value2[i].name != 0);
			assert(strcmp(value1[i].name, value2[i].name) == 0);
			
			assert(value1[i].value == value2[i].value);
			
			assert(value1[i].kind == value2[i].kind);
			
			if (value1[i].usage == 0) {
				assert(value2[i].usage == 0);
			} else {
				assert(value2[i].usage != 0);
				assert(strcmp(value1[i].usage, value2[i].usage) == 0);
			}
			
			assert(value1[i].extra_data == value2[i].extra_data);
		}
	}		
}


/*
 *  Method:  PropertyConstructionTest::TestProperty()
 *   Descr:  This member function performs this test.
 */	


	void PropertyConstructionTest::TestProperty(
		BPropertyInfo *propTest,
	    const property_info *prop_list,
	    const value_info *value_list,
	    int32 prop_count,
	    int32 value_count,
	    ssize_t flat_size,
	    const char *lflat_data,
	    const char *bflat_data)
{
	assert(propTest->CountProperties() == prop_count);
	assert(propTest->CountValues() == value_count);
	CompareProperties(propTest->Properties(), prop_list, prop_count);
	CompareValues(propTest->Values(), value_list, value_count);
	}
	

/*
 *  Method:  PropertyConstructionTest::suite()
 *   Descr:  This static member function returns a test caller for performing 
 *           all combinations of "PropertyConstructionTest".  The test
 *           is created as a ThreadedTestCase (typedef'd as
 *           PropertyConstructionTestCaller) with only one thread.
 */

 Test *PropertyConstructionTest::suite(void)
{	
	typedef CppUnit::TestCaller<PropertyConstructionTest>
		PropertyConstructionTestCaller;
		
	return(new PropertyConstructionTestCaller("BPropertyInfo::Construction Test", &PropertyConstructionTest::PerformTest));
	}