You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by ro...@locus.apache.org on 2000/01/12 01:17:49 UTC

cvs commit: xml-xerces/c/tests/UtilTests CoreTests_Transcoders.cpp CoreTests_URL.cpp

roddey      00/01/11 16:17:48

  Modified:    c/tests/UtilTests CoreTests_Transcoders.cpp
                        CoreTests_URL.cpp
  Log:
  Removed validator tests temporarily, since they have changed and the tests need
  to be rewritten. Added new tests for the new URL class.
  
  Revision  Changes    Path
  1.4       +6 -209    xml-xerces/c/tests/UtilTests/CoreTests_Transcoders.cpp
  
  Index: CoreTests_Transcoders.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/tests/UtilTests/CoreTests_Transcoders.cpp,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- CoreTests_Transcoders.cpp	1999/12/15 19:59:12	1.3
  +++ CoreTests_Transcoders.cpp	2000/01/12 00:17:48	1.4
  @@ -56,6 +56,10 @@
   
   /**
    * $Log: CoreTests_Transcoders.cpp,v $
  + * Revision 1.4  2000/01/12 00:17:48  roddey
  + * Removed validator tests temporarily, since they have changed and the tests need
  + * to be rewritten. Added new tests for the new URL class.
  + *
    * Revision 1.3  1999/12/15 19:59:12  roddey
    * Added new tests and updated tests for new split transcoder architecture.
    *
  @@ -86,181 +90,11 @@
   // ---------------------------------------------------------------------------
   //  Local test methods
   // ---------------------------------------------------------------------------
  -static bool testOneTranscoder(          XMLTranscoder&  toTest
  -                                , const char* const     nativeStr
  -                                , const unsigned int    nativeBytes
  -                                , const XMLCh* const    unicodeStr
  -                                , const unsigned int    unicodeBytes)
  -{
  -    // Ask it to do a basic transcoding of a string round trip
  -    {
  -        // Do the first pass and compare against the expected result
  -        XMLCh* firstPass = toTest.transcode(nativeStr);
  -        if (XMLString::compareString(firstPass, unicodeStr))
  -        {
  -            outStrm << "Xcode from native to Unicode failed"
  -                    << EndLn;
  -            return false;
  -        }
  -
  -        // Now transcode that back to native again
  -        char* secondPass = toTest.transcode(firstPass);
  -        if (XMLString::compareString(secondPass, nativeStr))
  -        {
  -            outStrm << "Xcode from Unicode to native failed"
  -                    << EndLn;
  -            return false;
  -        }
  -    }
  -
  -    // Check the methods that calculate required storage
  -    {
  -        if (toTest.calcRequiredSize(nativeStr) != unicodeBytes)
  -        {
  -            outStrm << "Calculated size to xcode char string was wrong"
  -                    << EndLn;
  -            return false;
  -        }
  -
  -        if (toTest.calcRequiredSize(unicodeStr) != nativeBytes)
  -        {
  -            outStrm << "Calculated size to xcode Unicode string was wrong"
  -                    << EndLn;
  -            return false;
  -        }
  -    }
  -
  -    return true;
  -}
   
  -//
  -//  This method tests the basic services of the currently loaded transcoding
  -//  service. This is the stuff that is independent of the source XML
  -//  encoding, i.e. it just works mostly on XMLCh content.
  -//
  -static bool basicTransServiceTests()
  -{
  -    static const char* const   testStr1 = "The test string";
  -    static const XMLCh         testStr2[] = 
  -    {
  -            chLatin_T, chLatin_h, chLatin_e, chSpace, chLatin_t, chLatin_e
  -        ,   chLatin_s, chLatin_t, chSpace, chLatin_s, chLatin_t, chLatin_r
  -        ,   chLatin_i, chLatin_n, chLatin_g, chNull
  -    };
  -    static const XMLCh         testStr3[] = 
  -    {
  -            chLatin_T, chLatin_H, chLatin_E, chSpace, chLatin_T, chLatin_E
  -        ,   chLatin_S, chLatin_T, chSpace, chLatin_S, chLatin_T, chLatin_R
  -        ,   chLatin_I, chLatin_N, chLatin_G, chNull
  -    };
  -    static const XMLCh testWS[] = { chSpace, chHTab, chLF, chCR, chNull };
  -    static const XMLCh testNWS[] = { chDigit_0, chLatin_A, chPound, chNull };
  -
  -    const XMLCh* pszTmp;
  -
  -    // Test the case insensitive comparison
  -    if (XMLPlatformUtils::fgTransService->compareIString(testStr2, testStr3))
  -    {
  -        outStrm << "Case sensitive compare failed" << EndLn;
  -        return false;
  -    }
  -
  -    //
  -    //  Test the case sensitive leading substring compare. Loop through and
  -    //  test it for each length possible. This will probe boundary conditions
  -    //  hopefully.
  -    //
  -    const unsigned int testLen = XMLString::stringLen(testStr2);
  -    for (unsigned int testInd = 0; testInd < testLen; testInd++)
  -    {
  -        if (XMLPlatformUtils::fgTransService->compareNIString(testStr2, testStr3, testInd))
  -        {
  -            outStrm << "Case sensitive leading compare failed" << EndLn;
  -            return false;
  -        }
  -    }
  -
  -    //  Check the isSpace API. This is the only generalized character type
  -    //  check that we need (all others are XML specific and done via XML's
  -    //  character type tables.)
  -    //
  -    pszTmp = testWS;
  -    while (*pszTmp)
  -    {
  -        if (!XMLPlatformUtils::fgTransService->isSpace(*pszTmp))
  -        {
  -            outStrm << "isSpace() failed on code point: "
  -                    << (unsigned int)*pszTmp << EndLn;
  -            return false;
  -        }
  -        pszTmp++;
  -    }
  -
  -    pszTmp = testNWS;
  -    while (*pszTmp)
  -    {
  -        if (XMLPlatformUtils::fgTransService->isSpace(*pszTmp))
  -        {
  -            outStrm << "isSpace() failed on code point: "
  -                    << (unsigned int)*pszTmp << EndLn;
  -            return false;
  -        }
  -        pszTmp++;
  -    }
  -
  -    return true;
  -}
  +// The transcoding system was changed, and there is no time at the moment
  +// to update the tests, so they were temporarily removed.
   
   
  -//
  -//  This tests some of the individual transcoders. These transcode between
  -//  some native encoding and the internal Unicode format.
  -//
  -//  We test the transcoders for the intrinsic transcoders here, the ones
  -//  that are implemented directly in the parser system. We can't test any
  -//  others because there is no guarantee that any others are supported by
  -//  any particular plugged in transcoding service.
  -//
  -static bool basicTranscoderTests()
  -{
  -    static const XMLCh         testStr2[] = 
  -    {
  -            chLatin_T, chLatin_h, chLatin_e, chSpace, chLatin_t, chLatin_e
  -        ,   chLatin_s, chLatin_t, chSpace, chLatin_s, chLatin_t, chLatin_r
  -        ,   chLatin_i, chLatin_n, chLatin_g, chNull
  -    };
  -    bool result;
  -
  -    // Test the intrinsic ASCII transcoder
  -    {
  -        const char* const testStr1 = "The test string";
  -        XMLASCIITranscoder toTest;
  -        result = testOneTranscoder
  -        (
  -            toTest
  -            , testStr1
  -            , XMLString::stringLen(testStr1)
  -            , testStr2
  -            , XMLString::stringLen(testStr2)
  -        );
  -
  -        if (!result)
  -            return false;
  -    }
  -
  -    // Test the intrinsic UTF-16 transcoder, in little endian
  -    {
  -    }
  -
  -    // Test the intrinsic UTF-16 transcoder, in big endian
  -    {
  -    }
  -
  -
  -    return true;
  -}
  -
  -
   // ---------------------------------------------------------------------------
   //  Test entry point
   // ---------------------------------------------------------------------------
  @@ -269,42 +103,6 @@
       outStrm << "----------------------------------\n"
               << "Testing transcoder classes\n"
               << "----------------------------------" << EndLn;
  -
  -    bool retVal = true;
   
  -    try
  -    {
  -        // Call other local methods to do specific tests
  -        outStrm << "Testing basic trans service functions" << EndLn;
  -        if (!basicTransServiceTests())
  -        {
  -            outStrm << "TransService basic tests failed" << EndLn;
  -            retVal = false;
  -        }
  -         else
  -        {
  -            outStrm << "TransService basic tests passed" << EndLn;
  -        }
  -        outStrm << EndLn;
  -
  -        outStrm << "Testing basic transcoder functions" << EndLn;
  -        if (!basicTranscoderTests())
  -        {
  -            outStrm << "Transcoder basic tests failed" << EndLn;
  -            retVal = false;
  -        }
  -         else
  -        {
  -            outStrm << "Transcoder basic tests passed" << EndLn;
  -        }
  -        outStrm << EndLn;
  -    }
  -
  -    catch(const XMLException& toCatch)
  -    {
  -        outStrm << "  ERROR: Unexpected exception!\n   Msg: "
  -                << toCatch.getMessage() << EndLn;
  -        return false;
  -    }
  -    return retVal;
  +    return true;
   }
  
  
  
  1.3       +187 -162  xml-xerces/c/tests/UtilTests/CoreTests_URL.cpp
  
  Index: CoreTests_URL.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/tests/UtilTests/CoreTests_URL.cpp,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- CoreTests_URL.cpp	1999/12/07 23:11:01	1.2
  +++ CoreTests_URL.cpp	2000/01/12 00:17:48	1.3
  @@ -56,6 +56,10 @@
   
   /**
    * $Log: CoreTests_URL.cpp,v $
  + * Revision 1.3  2000/01/12 00:17:48  roddey
  + * Removed validator tests temporarily, since they have changed and the tests need
  + * to be rewritten. Added new tests for the new URL class.
  + *
    * Revision 1.2  1999/12/07 23:11:01  roddey
    * Add in some new tests for transcoders and update the URL tests
    * a bit.
  @@ -76,194 +80,216 @@
   #include "CoreTests.hpp"
   
   
  +
   // ---------------------------------------------------------------------------
  -//  Local test methods
  +//  Local testing functions
   // ---------------------------------------------------------------------------
  -static bool parseTests()
  +
  +//
  +//  This test just sets up a list of variations on URLs and parses them. The
  +//  URL list includes the expected text for each of the parts that should be
  +//  parsed out of the URL.
  +//
  +struct BasicTestEntry
   {
  -    URL testURL;
  +    const XMLCh*    orgURL;
  +    const XMLCh*    fullText;
  +    URL::Protocols  Protocol;
  +    const XMLCh*    Fragment;
  +    const XMLCh*    Host;
  +    const XMLCh*    Path;
  +    const XMLCh*    Password;
  +    const XMLCh*    Query;
  +    const XMLCh*    User;
  +};
   
  -    //
  -    //  First lets set some invalid URL's and make sure that we get the
  -    //  expected malformed URL exceptions. Use an outer generic catch to
  -    //  handle anything unexpected and report it.
  -    //
  -    try
  -    {
  -        static const char* badURLS[] = 
  -        {
  -            "myfile.txt"
  -            , "bubba:///myfile.txt"
  -            , "file://myfile.txt"
  -            , 0
  -        };
  -        unsigned int index = 0;
  -
  -        while (badURLS[index])
  -        {
  -            bool gotIt = false;
  -            try
  -            {
  -                testURL.setURL(badURLS[index]);
  -            }
  -
  -            catch(const MalformedURLException&)
  -            {
  -                gotIt = true;
  -            }
  -
  -            if (!gotIt)
  -            {
  -                outStrm << "Failed to get bad URL exception for: "
  -                        << badURLS[index] << EndLn;
  -                return false;
  -            }
  -            index++;
  -        }
  -    }
  +static bool checkAField(const XMLCh* const test, const XMLCh* const expected)
  +{
  +    if (!test && !expected)
  +        return true;
   
  -    catch(const XMLException& toCatch)
  +    if ((!test || !expected) || XMLString::compareString(test, expected))
       {
  -        outStrm << "Got an unexpected exception.\n  Type:"
  -                << toCatch.getType() << ", Message:" << toCatch.getMessage()
  -                << EndLn;
  +        outStrm << "Expected: " << expected << ", but got: " << test << EndLn;
           return false;
       }
  +    return true;
  +}
   
  -    catch(...)
  -    {
  -        outStrm << "Got an unexpected system exception." << EndLn;
  +static bool checkBasicResult(const  URL&            testURL
  +                            , const BasicTestEntry& testInfo)
  +{
  +    //
  +    //  Check each part to insure that its what its supposed to be. Since
  +    //  any of them can be a null pointer, we have a little helper function
  +    //  that spits out the actual testing code for each one.
  +    //
  +    if (!checkAField(testURL.getURLText(), testInfo.fullText))
           return false;
  -    }
   
  +    if (!checkAField(testURL.getFragment(), testInfo.Fragment))
  +        return false;
  +
  +    if (!checkAField(testURL.getHost(), testInfo.Host))
  +        return false;
  +
  +    if (!checkAField(testURL.getPath(), testInfo.Path))
  +        return false;
  +
  +    if (!checkAField(testURL.getPassword(), testInfo.Password))
  +        return false;
  +
  +    if (!checkAField(testURL.getQuery(), testInfo.Query))
  +        return false;
  +
  +    if (!checkAField(testURL.getUser(), testInfo.User))
  +        return false;
  +
  +    return true;
  +}
  +
  +static bool basicURLTest()
  +{
  +    static BasicTestEntry testList[] =
  +    {
  +        {
  +            L"file://host@user:password/path1/path2/file.txt?query#fragment"
  +            , L"file://host@user:password/path1/path2/file.txt?query#fragment"
  +            , URL::File
  +            , L"fragment"
  +            , L"host"
  +            , L"/path1/path2/file.txt"
  +            , L"password"
  +            , L"query"
  +            , L"user"
  +        }
  +      , {
  +            L"file:///path2/file.txt?query#fragment"
  +            , L"file:///path2/file.txt?query#fragment"
  +            , URL::File
  +            , L"fragment"
  +            , 0
  +            , L"/path2/file.txt"
  +            , 0
  +            , L"query"
  +            , 0
  +        }
  +      , {
  +            L"#fragment"
  +            , L"#fragment"
  +            , URL::Unknown
  +            , L"fragment"
  +            , 0
  +            , 0
  +            , 0
  +            , 0
  +            , 0
  +        }
  +      , {
  +            L"file://host@user/path1/path2/file.txt#fragment"
  +            , L"file://host@user/path1/path2/file.txt#fragment"
  +            , URL::File
  +            , L"fragment"
  +            , L"host"
  +            , L"/path1/path2/file.txt"
  +            , 0
  +            , 0
  +            , L"user"
  +        }
  +    };
  +    const unsigned int testCount = sizeof(testList) / sizeof(testList[0]);
  +
  +    bool retVal = true;
   
       //
  -    //  Next lets test that we get runtime exceptions for unsupported
  -    //  protocols.
  +    //  Do a run where we construct the URL over and over for each
  +    //  test.
       //
  -    try
  +    for (unsigned int index = 0; index < testCount; index++)
       {
  -        static const char* unsupportedURLS[] = 
  +        // Force full destruction each time
           {
  -            "http:///xyz"
  -            , "gopher:///myfile.txt"
  -            , "wais:///myfile.txt"
  -            , "ftp://host/filename.txt"
  -            , "mailto://goober.74/snobby"
  -            , 0
  -        };
  -
  -        unsigned int index = 0;
  -        while (unsupportedURLS[index])
  -        {
  -            bool gotIt = false;
  -            try
  -            {
  -                testURL.setURL(unsupportedURLS[index]);
  -            }
  -
  -            catch(const MalformedURLException&)
  -            {
  -                gotIt = true;
  -            }
  -
  -            if (!gotIt)
  -            {
  -                outStrm << "Failed to get runtime exception for: "
  -                        << unsupportedURLS[index] << EndLn;
  -                return false;
  -            }
  -            index++;
  +            URL testURL(testList[index].orgURL);
  +
  +            // Call the comparison function
  +            if (!checkBasicResult(testURL, testList[index]))
  +                retVal = false;
           }
       }
   
  -    catch(const XMLException& toCatch)
  +    //
  +    //  Do a run where we use a single URL object and just reset it over
  +    //  and over again.
  +    //
  +    URL testURL;
  +    for (unsigned int index = 0; index < testCount; index++)
       {
  -        outStrm << "Got an unexpected exception.\n  Type:"
  -                << toCatch.getType() << ", Message:" << toCatch.getMessage()
  -                << EndLn;
  -        return false;
  -    }
  +        testURL.setURL(testList[index].orgURL);
   
  -    catch(...)
  -    {
  -        outStrm << "Got an unexpected system exception." << EndLn;
  -        return false;
  +        // Call the comparison function
  +        if (!checkBasicResult(testURL, testList[index]))
  +            retVal = false;
       }
   
  -    return true;
  +    return retVal;
   }
   
   
  -static bool basicTests()
  +//
  +//  This test makes sure that parsing one URL relative to another works
  +//  correctly. The tests used here come from one of the internet RFCs on
  +//  generic URI syntax. A single base URL is created, then a number of
  +//  relative URLs are parsed against it and the results compared to the
  +//  expected result.
  +//
  +static bool relativeURLTest()
   {
  -    //
  -    //  Set up a list of URLs and what we expect to get out of them for
  -    //  the various components.
  -    //
  -    struct TestInfo
  +    static struct TestEntry
       {
  -        const char*     urlText;
  -        const char*     hostComp;
  -        const char*     pathComp;
  -        const char*     protocol;
  -    };
  -
  -    static const TestInfo testList[] =
  +        const XMLCh*    relative;
  +        const XMLCh*    result;
  +    } testList[] =
       {
  -            { "file:///A:\\abc.txt"         , ""            , "A:\\abc.txt"     , "file://" }
  -        ,   { "file://localhost/A:\\abc.txt", "localhost"   , "A:\\abc.txt"     , "file://" }
  -        ,   { "file:///abc.txt"             , ""            , "/abc.txt"        , "file://" }
  -        ,   { "file:///A:\\a%20c.txt"       , ""            , "A:\\a c.txt"     , "file://" }
  -        ,   { 0, 0, 0, 0 }
  +        { L"g"      , L"http://a/b/c/g" }
  +      , { L"./g"    , L"http://a/b/c/g" }
  +      , { L"g/"     , L"http://a/b/c/g/" }
  +      , { L"/g"     , L"http://a/g" }
  +      , { L"?y"     , L"http://a/b/c/?y" }
  +      , { L"g?y"    , L"http://a/b/c/g?y" }
  +      , { L"#s"     , L"http://a/b/c/d;p#s" }
  +      , { L"g#s"    , L"http://a/b/c/g#s" }
  +      , { L"g?y#s"  , L"http://a/b/c/g?y#s" }
  +      , { L";x"     , L"http://a/b/c/;x" }
  +      , { L"g;x"    , L"http://a/b/c/g;x" }
  +      , { L"g;x?y#s", L"http://a/b/c/g;x?y#s" }
  +      , { L"."      , L"http://a/b/c/" }
  +      , { L"./"     , L"http://a/b/c/" }
  +      , { L".."     , L"http://a/b/" }
  +      , { L"../"    , L"http://a/b/" }
  +      , { L"../g"   , L"http://a/b/g" }
  +      , { L"../.."  , L"http://a/" }
  +      , { L"../../" , L"http://a/" }
  +      , { L"../../g", L"http://a/g" }
       };
  -
  -    bool result = true;
  -    unsigned int index = 0;
  -    while (true)
  -    {
  -        // Break out at the end
  -        if (!testList[index].urlText)
  -            break;
  -
  -        // Parse the next URL in the list
  -        URL testURL;
  -        testURL.setURL(testList[index].urlText);
  +    const unsigned int testCount = sizeof(testList) / sizeof(testList[0]);
   
  -        //
  -        //  And test the various components. We have to transcode them in order
  -        //  to do the the comparison.
  -        //
  -        XMLCh* tmpStr = XMLString::transcode(testList[index].hostComp);
  -        if (XMLString::compareString(testURL.getHost(), tmpStr))
  -        {
  -            outStrm << "Host incorrect on URL: " << testList[index].urlText << EndLn;
  -            result = false;
  -        }
  -        delete [] tmpStr;
  +    // This is the base URL against which the tests are run
  +    URL baseURL(L"http://a/b/c/d;p?q");
   
  -        tmpStr = XMLString::transcode(testList[index].protocol);
  -        if (XMLString::compareString(testURL.getProtocol(), tmpStr))
  -        {
  -            outStrm << "Protocol incorrect on URL: " << testList[index].urlText << EndLn;
  -            result = false;
  -        }
  -        delete [] tmpStr;
  +    bool retVal = true;
  +    for (unsigned int index = 0; index < testCount; index++)
  +    {
  +        URL testURL(baseURL, testList[index].relative);
   
  -        tmpStr = XMLString::transcode(testList[index].pathComp);
  -        if (XMLString::compareString(testURL.getPath(), tmpStr))
  +        if (XMLString::compareString(testURL.getURLText(), testList[index].result))
           {
  -            outStrm << "Path incorrect on URL: " << testList[index].urlText << EndLn;
  -            result = false;
  +            outStrm << "Expected URL: " << testList[index].result
  +                    << " but got: " << testURL.getURLText() << EndLn;
  +            retVal = false;
           }
  -        delete [] tmpStr;
  -
  -        // Move up to the next test
  -        index++;
       }
  -    return result;
  -}
  -
  +    return retVal;
  +};
   
   
   // ---------------------------------------------------------------------------
  @@ -279,29 +305,28 @@
       bool retVal = true;
       try
       {
  -        // Test the URL parsing code
  -        outStrm << "Testing URL Parsing" << EndLn;
  -        if (!parseTests())
  +        // Call other local methods to do specific tests
  +        outStrm << "Testing basic URL parsing" << EndLn;
  +        if (!basicURLTest())
           {
  -            outStrm << "URL parsing tests failed\n";
  +            outStrm << "Basic URL parsing tests failed" << EndLn;
               retVal = false;
           }
            else
           {
  -            outStrm << "URL parsing tests passed\n";
  +            outStrm << "Basic URL parsing tests passed" << EndLn;
           }
           outStrm << EndLn;
   
  -        // Now test basic functionality
  -        outStrm << "Testing URL Basics" << EndLn;
  -        if (!basicTests())
  +        outStrm << "Testing relative URL parsing" << EndLn;
  +        if (!relativeURLTest())
           {
  -            outStrm << "URL basic tests failed\n";
  +            outStrm << "Relative URL parsing tests failed" << EndLn;
               retVal = false;
           }
            else
           {
  -            outStrm << "URL basic tests passed\n";
  +            outStrm << "Relative URL parsing tests passed" << EndLn;
           }
           outStrm << EndLn;
       }