/*
        $Id: PropertyFindMatchTest.cpp 851 2002-08-22 03:15:35Z jrand $
        
        This file implements the FindMatch test for the Haiku BPropertyInfo
        code.  This class tests the following usecases:
          - Find Match
        
        */


#include "PropertyFindMatchTest.h"

#include <assert.h>

#include <Message.h>


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

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


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

        PropertyFindMatchTest::~PropertyFindMatchTest()
{
        }
        

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


        void PropertyFindMatchTest::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)
{
        const uint32 *commands;
        const uint32 *specifiers;
        const property_info *theProps = propTest->Properties();
        int i, j, k;
        bool wildcardCommand, wildcardSpec;
        
        ExecFindMatch(propTest, uniquePropName, uniqueCommand, uniqueSpecifier, false, -1);
        ExecFindMatch(propTest, commonPropName, uniqueCommand, uniqueSpecifier, false, -1);
        ExecFindMatch(propTest, uniquePropName, commonCommand, uniqueSpecifier, false, -1);
        ExecFindMatch(propTest, uniquePropName, uniqueCommand, commonSpecifier, false, -1);
        
        for (i=0; i < prop_count; i++) {
                wildcardCommand = (theProps[i].commands[0] == 0);
                wildcardSpec = (theProps[i].specifiers[0] == 0);
                if (wildcardCommand) {
                        commands = wildcardCommandTests;
                } else {
                        commands = theProps[i].commands;
                        }
                if (wildcardSpec) {
                        specifiers = wildcardSpecifierTests;
                } else {
                        specifiers = theProps[i].specifiers;
                }
                for(j=0; j<10; j++) {
                        if (commands[j] == 0) {
                                break;
                        }
                        if (!wildcardSpec) {
                                ExecFindMatch(propTest, theProps[i].name, commands[j], uniqueSpecifier,
                                                          wildcardCommand, -1);
                        }
                        for(k=0; k<10; k++) {
                                if (specifiers[k] == 0) {
                                        break;
                                }
                                if (!wildcardCommand) {
                                        ExecFindMatch(propTest, theProps[i].name, uniqueCommand, specifiers[k],
                                                              wildcardCommand, -1);
                                }
                                ExecFindMatch(propTest, theProps[i].name, commands[j], specifiers[k],
                                                          wildcardCommand, i);
                        }
                }       
        }
}       


/*
 *  Method:  PropertyFindMatchTest::ExecFindMatch()
 *   Descr:  This member function executes the FindMatch() member on the
 *           BPropertyInfo instance and ensures that the result is what is
 *           expected.  It calls FindMatch() normally with a zero index
 *           (meaning to match wildcard and non-wildcard command instances)
 *           and with a non-NULL specifier message.  The extra_data member
 *           is checked to make sure it is what is expected if a match is
 *           returned.
 *
 *           The Be implementation takes a pointer to a BMessage specifier
 *           but it doesn't seem to need it.  So, the FindMatch() is called
 *           again with a NULL BMessage specifier and we expect the same
 *           result.
 *
 *           Finally, the result is checked with a non-zero index.  If index
 *           is non-zero, a match will only be found if the property uses
 *           a wildcard for the command.  Depending on whether we are testing
 *           a wildcard command (from the wildcardCommand flag), we check the
 *           result with and without a BMessage specifier.
 */     


        void PropertyFindMatchTest::ExecFindMatch(
                BPropertyInfo *propTest,
                const char *prop,
                uint32 comm,
                uint32 spec,
                bool wildcardCommand,
                int32 result
                )
{
        BMessage msg(comm);
        BMessage specMsg(spec);
        specMsg.AddString("property", prop);
        msg.AddSpecifier(&specMsg);
        uint32 extra_data;
        
        assert(propTest->FindMatch(&msg, 0, &specMsg, spec, prop, &extra_data) == result);
        if (result >= 0) {
                assert((propTest->Properties())[result].extra_data == extra_data);
        }
        assert(propTest->FindMatch(&msg, 0, NULL, spec, prop, &extra_data) == result);
        if (wildcardCommand) {
                assert(propTest->FindMatch(&msg, 1, &specMsg, spec, prop, &extra_data) == result);
                assert(propTest->FindMatch(&msg, 1, NULL, spec, prop, &extra_data) == result);
        } else {
                assert(propTest->FindMatch(&msg, 1, &specMsg, spec, prop, &extra_data) == -1);
                assert(propTest->FindMatch(&msg, 1, NULL, spec, prop, &extra_data) == -1);
        }
}


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

 Test *PropertyFindMatchTest::suite(void)
{       
        typedef CppUnit::TestCaller<PropertyFindMatchTest>
                PropertyFindMatchTestCaller;
                
        return(new PropertyFindMatchTestCaller("BPropertyInfo::FindMatch Test", &PropertyFindMatchTest::PerformTest));
        }