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

Search this page:

TestGLXGLContext.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/TestGLXGLContext.h"
#include "../../include/PCMFileSystemManager.h"
#include "../../include/PCMStringConverter.h"
#include "../../include/PCMHost.h"
#include "../../include/PCMNode.h"
#include "../../include/PCMProcess.h"

namespace ParCompMarkTest
{

  void TestGLXGLContext::setUp()
  {
        std::string currentLogFile = "logs/TestGLXGLContext.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 TestGLXGLContext::tearDown()
  {
  }

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

  //
  // Constructor & destructor tests
  //

  void TestGLXGLContext::test_constructor_XDisplay__Pointer_GLXRenderWindow_p___XVisualInfo_p()
  {

        /*
         * You have to verify the following:
         * 
         * Create GLX context.
         */

        // Create display
        XDisplay::Pointer d(new XDisplay());

        // Null pointer error
        CPPUNIT_ASSERT_THROW(GLXGLContext::Pointer c(new GLXGLContext(d, 0, 0)), ParCompMark::Exception);

        // Create host (not use as singleton)
        Host *h = 0;

        CPPUNIT_ASSERT_NO_THROW(h = new Host("TestHost"));

        // Create node
        Node *n = 0;

        CPPUNIT_ASSERT_NO_THROW(n = new Node("TestNode", h));

        // Create process
        Process *p = 0;

        CPPUNIT_ASSERT_NO_THROW(p = new Process("TestProcess", n));

        // Create glx renderwindow
        GLXRenderWindow *win = 0;

        CPPUNIT_ASSERT_NO_THROW(win = new GLXRenderWindow(d, p, "Testwindow"));

        // Correct creation
        ::XVisualInfo visualInfo;
        CPPUNIT_ASSERT_NO_THROW(GLXGLContext::Pointer c(new GLXGLContext(d, win, &visualInfo)));

        // Do not delete object (we are not interested in destructors) 
  }

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

  void TestGLXGLContext::test_destructor()
  {
        // Tested at constructor
  }

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

  //
  // Method tests
  //

  void TestGLXGLContext::test_initialize()
  {

        /*
         * You have to verify the following:
         * 
         * Initialize the GL context.
         */

        XDisplay::Pointer d(new XDisplay());
        CPPUNIT_ASSERT_NO_THROW(d->initialize());
        Host *h = 0;
        Node *n = 0;
        Process *p = 0;
        GLXRenderWindow *win = 0;

        GLXGLContext::Pointer c;
        CPPUNIT_ASSERT_NO_THROW(h = new Host("TestHost"));
        CPPUNIT_ASSERT_NO_THROW(n = new Node("TestNode", h));
        CPPUNIT_ASSERT_NO_THROW(p = new Process("TestProcess", n));
        CPPUNIT_ASSERT_NO_THROW(win = new GLXRenderWindow(d, p, "Testwindow"));

        // Recreate, reinitialize properly
        XVisualInfo templ;
        int screen = DefaultScreen(d->getDisplay());
        int best_visual = d->findBestVisual(screen);

        templ.visualid = best_visual;
        int nmatch;
        XVisualInfo *visualInfo = 0;

        CPPUNIT_ASSERT_NO_THROW(visualInfo = XGetVisualInfo(d->getDisplay(), VisualIDMask, &templ, &nmatch));

        CPPUNIT_ASSERT_NO_THROW(c = new GLXGLContext(d, win, visualInfo));
        CPPUNIT_ASSERT_NO_THROW(c->initialize());

        // Test finalize after initialization
        CPPUNIT_ASSERT_NO_THROW(c->finalize());

        //
        // Test several contexts
        //
        const u32 testCount = 20;

        GLXGLContext::Pointer cs[testCount];

        // Create contexts
        for(u32 i = 0; i < testCount; i++)
        {
         CPPUNIT_ASSERT_NO_THROW(win = new GLXRenderWindow(d, p, "Testwindow #" + StringConverter::toString(i)));
         CPPUNIT_ASSERT_NO_THROW(cs[i] = new GLXGLContext(d, win, visualInfo));
        }

        // Initialize contexts
        for(u32 i = 0; i < testCount; i++)
        {
         CPPUNIT_ASSERT_NO_THROW(cs[i]->initialize());
        }

        // Finalize contexts
        for(u32 i = 0; i < testCount; i++)
        {
         CPPUNIT_ASSERT_NO_THROW(cs[i]->finalize());
        }
  }

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

  void TestGLXGLContext::test_finalize()
  {

        /*
         * You have to verify the following:
         * 
         * Finalize the GL context.
         */

        // Tested at initialize
  }

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

  void TestGLXGLContext::test_setCurrent()
  {

        /*
         * You have to verify the following:
         * 
         * Enable the context. All subsequent rendering commands will go here.
         */

        // Unable to test from here
  }

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

  void TestGLXGLContext::test_releaseCurrent()
  {

        /*
         * You have to verify the following:
         * 
         * Release the current context without assigning a new one.
         */

        // Unable to test from here
  }

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

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

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