include/Tests/ParserTests.hpp

Go to the documentation of this file.

#ifndef hpp_ParserTests_hpp
#define hpp_ParserTests_hpp

// We need parser declaration
#include "../HTMLParser/Parser.hpp"
// We need test vectors
#include "TestVectors.hpp"
// We need time
#include <time.h>

#ifndef DebugText
#define DebugText OutputDebugString
#endif 

namespace Tests
{
    struct ParserTest
    {
        bool testTagging()
        {
            for (int i = 0; i < sizeof(HTML::allowedElements)/sizeof(HTML::allowedElements[0]); i++)
            {
                if (HTML::Elements::fromTag(HTML::allowedElements[i].name, strlen(HTML::allowedElements[i].name)) != HTML::allowedElements[i].elementID)
                    return false;
            }

            if (HTML::Elements::fromTag("Z", 1) != HTML::GenericElement::Unknown) return false;
            if (HTML::Elements::fromTag("ZA", 2) != HTML::GenericElement::Unknown) return false;
            if (HTML::Elements::fromTag("ZAA", 3) != HTML::GenericElement::Unknown) return false;
            if (HTML::Elements::fromTag("ADDE", 4) != HTML::GenericElement::Unknown) return false;
            if (HTML::Elements::fromTag("ZACOP", 5) != HTML::GenericElement::Unknown) return false;
            if (HTML::Elements::fromTag("BUTTIN", 6) != HTML::GenericElement::Unknown) return false;
            if (HTML::Elements::fromTag("ADDREST", 7) != HTML::GenericElement::Unknown) return false;
            if (HTML::Elements::fromTag("CALGROUP", 8) != HTML::GenericElement::Unknown) return false;
            if (HTML::Elements::fromTag("RETEDFIEH", 9) != HTML::GenericElement::Unknown) return false;
            if (HTML::Elements::fromTag("BLOCKQUOTI", 10) != HTML::GenericElement::Unknown) return false;
            if (HTML::Elements::fromTag("ZEFEGZERERG", 11) != HTML::GenericElement::Unknown) return false;
            
            return true;
        }

        bool checkTaggingSpeed()
        {
            // First check tagging speed for classic search
            const char * arrayToFind[] = { "A", "BLOCKQUOTE", "PRE", "TEXT", "NOTHING", "AREA", "COLGROUP", "OPTION", "NOSCRIPT", "VAR" };

            int nbTurn = 100000;
            clock_t timeStart = clock();
            for (; nbTurn; nbTurn --)
                for (int i = 0; i < sizeof(arrayToFind) / sizeof(arrayToFind[0]); i++)
                {
                    for (int j = 0; j < sizeof(HTML::allowedElements)/sizeof(HTML::allowedElements[0]); j++)
                        if (strcmp(HTML::allowedElements[i].name, arrayToFind[i]) == 0) break;
                }
            clock_t timeElapsed1 = clock() - timeStart;

            // Redo the process with our code
            nbTurn = 100000;
            timeStart = clock();
            for (; nbTurn; nbTurn --)
                for (int i = 0; i < sizeof(arrayToFind) / sizeof(arrayToFind[0]); i++)
                {
                    HTML::GenericElement::ElementID el = HTML::Elements::fromTag(arrayToFind[i], strlen(arrayToFind[i]));
                }
            clock_t timeElapsed2 = clock() - timeStart;

            // On my computer, the new algorithm is 10x faster!
            return timeElapsed2 < timeElapsed1;
        }

        bool parseDocHTMLFile()
        {
            Stream::InputFileStream xFS("../../../testFiles/docs.htm");
            // Create an node allocator if not done yet (this can as simple as the "new" based allocator)
            HTML::Elements::Allocators::SimpleHeap xAllocator;
            // Create the parser now 
            HTML::Parser xParser(xFS, xAllocator, HTML::Parser::InstantParsing, HTML::LooseDTD);
            // Get the last error
            const HTML::Parser::ParsingError & xError = xParser.getLastParsingError();
            // Get the DOM tree
            HTML::DOMTree & tree = xParser.getDOMTree();
            // Dump it
            dumpDOM(tree);
            
            // Get a reference to the DOM tree now
//            HTML::DOMTree & xTree = xParser.getDOMTree();
            return !xError.isError();
        }

        bool dumpDOM(HTML::DOMTree & domTree)
        {
            HTML::DOMTree::Node * node = domTree.getRootNode();
            
            if (!node) return false;
            // Apply the dump method to the current node 
            dumpMethod(node->getData(), 0);
            node->applyOnChildrenDataLevel(*this, &ParserTest::dumpMethod, 1);
            return true;
        }

        int dumpMethod(const DOM::Node * node, int level)
        {
            // Should print element here
            if (!node) return 0;
            // We currently only support Element for now
            if (node->nodeType != DOM::Node::NodeType::Element) 
            {
                if (node->nodeType != DOM::Node::NodeType::Text) return 1;
                const DOM::Text * text = (const DOM::Text*)node;
                // Get the text
                Bstrlib::String result;
                while (level)
                {
                    result += "    ";
                    level --;
                }
                result += "{";
                result += Strings::convert(text->nodeValue());
                result += "}\r\n";
                DebugText(result);
                return 1;
            }
            HTML::Elements::Element * element = ((DOM::Element*)node)->getElement();
            if (!element) return 0;
            Bstrlib::String result;
            while (level)
            {
                result += "    ";
                level --;
            }
            
            result += element->tagName();

            const DOM::NamedNodeMap * attributes = ((DOM::Element*)node)->attributes();
            if (attributes && attributes->length())
            {
                result += " [";
                for (uint32 i = 0; i < attributes->length(); i++)
                {
                    const DOM::Attr * attr = (const DOM::Attr*)attributes->item(i);
                    if (attr)
                    {
                        result += Strings::convert(attr->name());
                        result += " = \"";
                        result += Strings::convert(attr->value());
                        result += "\", ";
                    }
                }
                result += "]";
            }

            //result += "\r\n";
            DebugText(result);
            return 1;
        }

    };

    void createParserTests(Test::Vector & xVector, Bstrlib::String & results)
    {
        typedef Bstrlib::String String; 
        xVector.addUnitToTest(Test::MakeLineDelimiter("Parser testing"));
        {
            ParserTest xPT;
            xVector.addUnitToTest(Test::MakeUnitTest(MakeTestName( "Testing tagging all defined and some undefined element in HTML4.01 standard" ), xPT, &ParserTest::testTagging));
            xVector.addUnitToTest(Test::MakeUnitTest(MakeTestName( "Testing tagging speed for the current algorithm" ), xPT, &ParserTest::checkTaggingSpeed));
            xVector.addUnitToTest(Test::MakeUnitTest(MakeTestName( "Testing parsing an example file" ), xPT, &ParserTest::parseDocHTMLFile));
/*
            xVector.addUnitToTest(Test::MakeUnitTest(MakeTestName( "Checking node accessibility" ), xTT, &NTreeTest::countNodes, byRef(xTT.xTree)));
            xVector.addUnitToTest(Test::MakeUnitTest(MakeTestName( "Checking node creation count" ), xTT, &NTreeTest::refCheck, byRef(xTT.xTree)));
            xVector.addUnitToTest(Test::MakeUnitTest(MakeTestName( "Checking Node's access methods" ), xTT, &NTreeTest::testMethod1, byRef(xTT.xTree)));
            xVector.addUnitToTest(Test::MakeUnitTest(MakeTestName( "Checking Node's find and apply methods" ), xTT, &NTreeTest::testMethod2, byRef(xTT.xTree)));
            xVector.addUnitToTest(Test::MakeUnitTest(MakeTestName( "Checking Node deletion methods" ), xTT, &NTreeTest::testMethod3, byRef(xTT.xTree)));
            */
            xVector.testLastInsertedVectors(results);
        }
    }

}

#endif

(C) An X-Ryl669 project 2007

This document describes Unlimited Zooming Interface source code. UZI stands for Unlimited Zooming Interface, and source code license is