include/Tests/RendererTests.hpp

Go to the documentation of this file.

#ifndef hpp_RendererTests_hpp
#define hpp_RendererTests_hpp

// We need renderer declaration
#include "../HTMLRenderer/GenericRenderer.hpp"
// We need test vectors
#include "TestVectors.hpp"
// We need parser declaration
#include "../HTMLParser/Parser.hpp"


namespace Tests
{
    struct RendererTest
    {
        // Create an node allocator if not done yet (this can as simple as the "new" based allocator)
        HTML::Elements::Allocators::SimpleHeap xElementAllocator;
        HTML::Renderer::Allocators::SimpleHeap xBoxAllocator;
        Stream::InputFileStream xFS;
        // Create the parser now 
        HTML::Parser * xParser;

        HTML::Renderer::Mapper * xMapper;

        bool testParserCreation()
        {
            xParser = new HTML::Parser(xFS, xElementAllocator, HTML::Parser::InstantParsing, HTML::LooseDTD);
            if (!xParser) return false;
            // Get the last error
            const HTML::Parser::ParsingError & xError = xParser->getLastParsingError();
       
            return !xError.isError();
        }

        bool testRenderer()
        {
            if (!xParser) return false;
            // Get the DOM tree
            HTML::DOMTree & tree = xParser->getDOMTree();
            xMapper = new HTML::Renderer::Mapper(tree.getRootNode()->getData(), xBoxAllocator, 640, 480, 0);
            if (!xMapper) return false;

            // Generate the box hierarchy
            if (!xMapper->generateBoxHierarchy()) return false;
            // Check the box hierarchy
            const HTML::Renderer::BoxHierarchy * root = xMapper->getRootHierarchy();
            if (!root) return false;

            // Dump the hierarchy to the output console
            Bstrlib::String result;
            int level = 0;

            while (root)
            {
                for (int i = 0; i < level; i++)
                    result += "    ";

                result += HTML::allowedElements[(int)root->tagType - 1].name;
                result += " [";
                result += Strings::convert(root->ClassAttribute);
                result += "]";
                result += "\r\n";
                if (root->child)
                {
                    root = root->child;
                    level ++;
                }
                else if (root->next)
                    root = root->next;
                else 
                {
                    while (root)
                    {
                        level --;
                        if (root->parent && root->parent->next)
                        {    root = root->parent->next; break; }
                        root = root->parent;
                    }
                }
            }

            for (int i = 0; i < result.getLength(); i+=1023)
            {
                DebugText((const char*)result.midString(i, 1023));
                Sleep(40);
            }
            return true;
        }

        RendererTest() : xFS("../../../testFiles/docs.htm"), xParser(0), xMapper(0) {}
        ~RendererTest() { delete xMapper; delete xParser; }
    };

    void createRendererTests(Test::Vector & xVector, Bstrlib::String & results)
    {
        typedef Bstrlib::String String; 
        xVector.addUnitToTest(Test::MakeLineDelimiter("Renderer testing"));
        {
            RendererTest xRT;
            xVector.addUnitToTest(Test::MakeUnitTest(MakeTestName( "Creating parser" ), xRT, &RendererTest::testParserCreation));
            xVector.addUnitToTest(Test::MakeUnitTest(MakeTestName( "Creating renderer" ), xRT, &RendererTest::testRenderer));
            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