• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

TestOutputNode.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


#include "../include/TestOutputNode.h"
#include "../../include/PCMFileSystemManager.h"

namespace ParCompMarkTest
{

  void TestOutputNode::setUp()
  {
        std::string currentLogFile = "logs/TestOutputNode.log";

        if(Logger::getInstance() && Logger::getInstance()->getLogFileName() != currentLogFile)
         Logger::destroyInstance();

        if(!FileSystemManager::getInstance())
        {
         FileSystemManager::createInstance();
         FileSystemManager::getInstance()->setAppDirectory("./");
         FileSystemManager::getInstance()->initialize();
        }

        if(!Logger::getInstance())
        {
         Logger::createInstance();
         Logger::getInstance()->setLogFileName(currentLogFile);
         Logger::getInstance()->initialize();
        }
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::tearDown()
  {
  }

 /*----------------------------------------------------------------------*/

  //
  // Constructor & destructor tests
  //

  void TestOutputNode::test_constructor_cstd__string_cNodeType()
  {

        /*
         * You have to verify the following:
         * 
         * Creates output node.
         */

        // Creation with C style pointer (not textual node)
        OutputNode *node1 = 0;

        CPPUNIT_ASSERT_NO_THROW(node1 = new OutputNode("name", OutputNode::DEFINITION));
        CPPUNIT_ASSERT(node1->mName == "name");
        CPPUNIT_ASSERT(node1->mType == OutputNode::DEFINITION);
        CPPUNIT_ASSERT(node1->mText == "");
        CPPUNIT_ASSERT_NO_THROW(delete node1);

        // Smart pointer reference
        OutputNode::Pointer node2;

        CPPUNIT_ASSERT_NO_THROW(node2 = new OutputNode("name", OutputNode::DEFINITION));
        CPPUNIT_ASSERT(node2->mName == "name");
        CPPUNIT_ASSERT(node2->mType == OutputNode::DEFINITION);
        CPPUNIT_ASSERT(node2->mText == "");
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_constructor_cstd__string()
  {

        /*
         * You have to verify the following:
         * 
         * Creates text field.
         */

        // Creation with C style pointer (textual node)
        OutputNode *node1 = 0;

        CPPUNIT_ASSERT_NO_THROW(node1 = new OutputNode("This is the text."));
        CPPUNIT_ASSERT(node1->mName == OutputNode::TEXTNODENAME);
        CPPUNIT_ASSERT(node1->mType == OutputNode::TEXT);
        CPPUNIT_ASSERT(node1->mText == "This is the text.");
        CPPUNIT_ASSERT_NO_THROW(delete node1);

        // Smart pointer reference
        OutputNode::Pointer node2;

        CPPUNIT_ASSERT_NO_THROW(node2 = new OutputNode("This is the text."));
        CPPUNIT_ASSERT(node2->mName == OutputNode::TEXTNODENAME);
        CPPUNIT_ASSERT(node2->mType == OutputNode::TEXT);
        CPPUNIT_ASSERT(node2->mText == "This is the text.");
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_destructor()
  {
        // Already tested above
  }

 /*----------------------------------------------------------------------*/

  //
  // Class method tests
  //

  void TestOutputNode::test_parseFromXML_std__string()
  {

        /*
         * You have to verify the following:
         * 
         * Parse XML document and construct its OutputNode equivalent.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test__testXMLName_cstd__string()
  {

        /*
         * You have to verify the following:
         * 
         * Test name if its a correct xml name.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test__convertSpecialChars_cstd__string()
  {

        /*
         * You have to verify the following:
         * 
         * Convert special characters to XML entites.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

 /*----------------------------------------------------------------------*/

  //
  // Method tests
  //

  void TestOutputNode::test_createChildNode_cstd__string_cNodeType()
  {

        /*
         * You have to verify the following:
         * 
         * Create nontextual child node.
         */

        OutputNode::Pointer parent, child;

        // Create nontextual parent node
        CPPUNIT_ASSERT_NO_THROW(parent = new OutputNode("parent", OutputNode::DEFINITION));
        CPPUNIT_ASSERT_NO_THROW(child = parent->createChildNode("child", OutputNode::INFORMATION));
        CPPUNIT_ASSERT(child->mName == "child");
        CPPUNIT_ASSERT(child->mType == OutputNode::INFORMATION);
        CPPUNIT_ASSERT(child->mText == "");

        // Create another child with another name
        CPPUNIT_ASSERT_NO_THROW(parent->createChildNode("child2", OutputNode::INFORMATION));

        // Create textual parent node (no child is allowed)
        CPPUNIT_ASSERT_NO_THROW(parent = new OutputNode("This is a text."));
        CPPUNIT_ASSERT_THROW(parent->createChildNode("child", OutputNode::INFORMATION), ParCompMark::Exception);
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_createChildNode_cstd__string()
  {

        /*
         * You have to verify the following:
         * 
         * Create textual child node.
         */

        OutputNode::Pointer parent, child;

        // Create nontextual parent node
        CPPUNIT_ASSERT_NO_THROW(parent = new OutputNode("parent", OutputNode::DEFINITION));
        CPPUNIT_ASSERT_NO_THROW(child = parent->createChildNode("This is a text."));
        CPPUNIT_ASSERT(child->mName == OutputNode::TEXTNODENAME);
        CPPUNIT_ASSERT(child->mType == OutputNode::TEXT);
        CPPUNIT_ASSERT(child->mText == "This is a text.");

        // Create textual parent node (no child is allowed)
        CPPUNIT_ASSERT_NO_THROW(parent = new OutputNode("This is a text."));
        CPPUNIT_ASSERT_THROW(parent->createChildNode("This is a text."), ParCompMark::Exception);
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_addChildNode_OutputNode__Pointer()
  {

        /*
         * You have to verify the following:
         * 
         * Add child node.
         */

        OutputNode::Pointer parent, child1, child2;

        // Create nontextual child node
        CPPUNIT_ASSERT_NO_THROW(child1 = new OutputNode("child", OutputNode::INFORMATION));

        // Create textual child node
        CPPUNIT_ASSERT_NO_THROW(child2 = new OutputNode("This is a text."));

        // Create nontextual parent node
        CPPUNIT_ASSERT_NO_THROW(parent = new OutputNode("parent", OutputNode::DEFINITION));

        // Correct work
        CPPUNIT_ASSERT_NO_THROW(parent->addChildNode(child1));
        CPPUNIT_ASSERT_NO_THROW(parent->addChildNode(child2));

        // Cannot add itself as a child
        CPPUNIT_ASSERT_THROW(parent->addChildNode(parent), ParCompMark::Exception);

        // Create textual parent node (no child is allowed)
        CPPUNIT_ASSERT_NO_THROW(parent = new OutputNode("This is a text."));
        CPPUNIT_ASSERT_THROW(parent->addChildNode(child1), ParCompMark::Exception);
        CPPUNIT_ASSERT_THROW(parent->addChildNode(child2), ParCompMark::Exception);
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_getChildCount()
  {

        /*
         * You have to verify the following:
         * 
         * Return the number of child nodes.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_getFirstChildNode()
  {

        /*
         * You have to verify the following:
         * 
         * Return first child node.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_hasAttribute_cstd__string()
  {

        /*
         * You have to verify the following:
         * 
         * Return true if the node has attribute with the specified name.
         */

        // Create nontextual node
        OutputNode::Pointer node;

        CPPUNIT_ASSERT_NO_THROW(node = new OutputNode("node", OutputNode::DEFINITION));
        CPPUNIT_ASSERT(!node->hasAttribute("attribute"));

        // Create textual node
        CPPUNIT_ASSERT_NO_THROW(node = new OutputNode("This is a text."));
        CPPUNIT_ASSERT_THROW(node->hasAttribute("attribute"), ParCompMark::Exception);

        // Correct working tested in setAttribute method
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_getAttribute_cstd__string()
  {

        /*
         * You have to verify the following:
         * 
         * Get an attribute by name.
         */

        // Create nontextual node
        OutputNode::Pointer node;

        CPPUNIT_ASSERT_NO_THROW(node = new OutputNode("node", OutputNode::DEFINITION));
        CPPUNIT_ASSERT_THROW(node->getAttribute("attribute"), ParCompMark::Exception);

        // Create textual node
        CPPUNIT_ASSERT_NO_THROW(node = new OutputNode("This is a text."));
        CPPUNIT_ASSERT_THROW(node->getAttribute("attribute"), ParCompMark::Exception);

        // Correct working tested in setAttribute method
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_setAttribute_cstd__string_cstd__string()
  {

        /*
         * You have to verify the following:
         * 
         * Set attribute, also create if does not exists, overwrite otherwise.
         */

        // Create nontextual node
        OutputNode::Pointer node;

        CPPUNIT_ASSERT_NO_THROW(node = new OutputNode("node", OutputNode::DEFINITION));
        CPPUNIT_ASSERT(!node->hasAttribute("attribute"));
        CPPUNIT_ASSERT_NO_THROW(node->setAttribute("attribute", "value"));
        CPPUNIT_ASSERT(node->hasAttribute("attribute"));
        CPPUNIT_ASSERT(node->getAttribute("attribute") == "value");
        CPPUNIT_ASSERT_NO_THROW(node->setAttribute("attribute", "another value"));
        CPPUNIT_ASSERT(node->hasAttribute("attribute"));
        CPPUNIT_ASSERT(node->getAttribute("attribute") == "another value");
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_serialize2XML_std__ostringstream()
  {

        /*
         * You have to verify the following:
         * 
         * Serialize the node to XML (this is a recursive method, calls the same methods of the children too).
         */

        OutputNode::Pointer node, child;
        std::ostringstream osstr1, osstr2;
        osstr1 << "testing ";

        // Create textual node
        CPPUNIT_ASSERT_NO_THROW(node = new OutputNode("This is a text."));
        CPPUNIT_ASSERT(node->serialize2XML(osstr1).str() == "testing This is a text.");
        CPPUNIT_ASSERT(node->serialize2XML(osstr1).str() == "testing This is a text.This is a text.");

        // Create nontextual node with attributes and children
        CPPUNIT_ASSERT_NO_THROW(node = new OutputNode("parent", OutputNode::DEFINITION));
        CPPUNIT_ASSERT_NO_THROW(node->setAttribute("attribute1", "value1"));
        CPPUNIT_ASSERT_NO_THROW(node->setAttribute("attribute2", "value2"));
        CPPUNIT_ASSERT_NO_THROW(child = node->createChildNode("child1", OutputNode::INFORMATION));
        CPPUNIT_ASSERT_NO_THROW(child = node->createChildNode("child2", OutputNode::STATISTICS));
        CPPUNIT_ASSERT_NO_THROW(child->setAttribute("attribute3", "value3"));
        CPPUNIT_ASSERT(node->serialize2XML(osstr2).str() ==
                   "<def:parent attribute1=\"value1\" attribute2=\"value2\"><info:child1/><stat:child2 attribute3=\"value3\"/></def:parent>");

  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_serialize2XML()
  {

        /*
         * You have to verify the following:
         * 
         * Serialize the node to XML (this is a recursive method, calls the same methods of the children too). Use the other version of this method with parameter std::ostringstream if it is possible for memory saving.
         */

        // Tested above
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_refreshData()
  {

        /*
         * You have to verify the following:
         * 
         * Refresh datas.
         */

        // No need to test
  }

 /*----------------------------------------------------------------------*/

  void TestOutputNode::test_clean()
  {

        /*
         * You have to verify the following:
         * 
         * Clean outputnode.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

 /*----------------------------------------------------------------------*/

  // To register the suite we add:
  CPPUNIT_TEST_SUITE_REGISTRATION(TestOutputNode);
}

© Copyright - 2006 (IT)² ParCompMark Dev. Team