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

Search this page:

TestPointer.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/TestPointer.h"

namespace ParCompMarkTest
{

  void TestPointer::setUp()
  {
        // Pointer cannot log, beacuse the logger has a pointer attribute (mFp)
  }

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

  void TestPointer::tearDown()
  {
  }

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

  //
  // Constructor & destructor tests
  //

  void TestPointer::test_constructor()
  {

        /*
         * You have to verify the following:
         * 
         * Create a NULL pointer.
         */

        Pointer < int,
        DummyLock > p;

        CPPUNIT_ASSERT_MESSAGE("Null pointer initialization error", p.mMeta->ptr == 0);
        CPPUNIT_ASSERT_MESSAGE("Null pointer initialization error", p.mMeta->dead == true);
        CPPUNIT_ASSERT_MESSAGE("Null pointer initialization error", p.mMeta->usage == 1);
        CPPUNIT_ASSERT_MESSAGE("Null pointer initialization error", p.mMeta->ownMemory == false);
  }

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

  void TestPointer::test_constructor_cT_p_cbool()
  {

        /*
         * You have to verify the following:
         * 
         * Create smart pointer from a C style pointer.
         */

        // Take ownership
        int *_p = new int (1);
        Pointer < int,
        DummyLock > p(_p);

        CPPUNIT_ASSERT_MESSAGE("C style pointer initialization error", p.mMeta->ptr == _p);
        CPPUNIT_ASSERT_MESSAGE("C style pointer initialization error", p.mMeta->dead == false);
        CPPUNIT_ASSERT_MESSAGE("C style pointer initialization error", p.mMeta->usage == 1);
        CPPUNIT_ASSERT_MESSAGE("C style pointer initialization error", p.mMeta->ownMemory == true);

        // Do not take ownership
        Pointer < int,
        DummyLock > p2(_p, false);

        CPPUNIT_ASSERT_MESSAGE("C style pointer initialization error", p2.mMeta->ptr == _p);
        CPPUNIT_ASSERT_MESSAGE("C style pointer initialization error", p2.mMeta->dead == false);
        CPPUNIT_ASSERT_MESSAGE("C style pointer initialization error", p2.mMeta->usage == 1);
        CPPUNIT_ASSERT_MESSAGE("C style pointer initialization error", p2.mMeta->ownMemory == false);
  }

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

  void TestPointer::test_constructor_Pointer___T__Lock__()
  {

        /*
         * You have to verify the following:
         * 
         * Create smart pointer from an another smart pointer. (Copy constructor)
         */

        int *_p = new int (1);
        Pointer < int,
        DummyLock > p1(_p);
        Pointer < int,
        DummyLock > p2(p1);

        CPPUNIT_ASSERT_MESSAGE("Copy constructor initialization error", p1.mMeta == p2.mMeta);
        CPPUNIT_ASSERT_MESSAGE("Copy constructor initialization error", p1.mMeta->usage == 2);
  }

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

  void TestPointer::test_constructor_cPointer___T__Lock__()
  {

        /*
         * You have to verify the following:
         * 
         * Create smart pointer from an another const smart pointer. (Constantant copy constructor)
         */

        int *_p = new int (1);
        const Pointer < int,
        DummyLock > p1(_p);
        Pointer < int,
        DummyLock > p2(p1);

        CPPUNIT_ASSERT_MESSAGE("Copy constructor initialization error", p1.mMeta == p2.mMeta);
        CPPUNIT_ASSERT_MESSAGE("Copy constructor initialization error", p1.mMeta->usage == 2);
  }

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

  void TestPointer::test_destructor()
  {
        int *_p = new int (1);
        Pointer < int,
        DummyLock > p1(_p);

        do
        {
         Pointer < int,
          DummyLock > p2(p1);
        } while(false);
        CPPUNIT_ASSERT_MESSAGE("Copy constructor initialization error", p1.mMeta->usage == 1);
  }

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

  //
  // Operator tests
  //

  void TestPointer::test_operator_assignment_cT_p()
  {

        /*
         * You have to verify the following:
         * 
         * Assign a C style pointer.
         */

        int *_p1 = new int (1);
        Pointer < int,
        DummyLock > p(_p1);
        Pointer < int,
        DummyLock > p2(p);      // double reference

        // Assign self
        void *_meta = p.mMeta;

        CPPUNIT_ASSERT_NO_THROW(p = _p1);
        CPPUNIT_ASSERT_MESSAGE("C style pointer self assign error", p.mMeta->ptr == _p1);
        CPPUNIT_ASSERT_MESSAGE("C style pointer self assign error", p.mMeta->usage == 2);
        CPPUNIT_ASSERT_MESSAGE("C style pointer self assign error", p.mMeta == _meta);

        // Assign another
        int *_p2 = new int (2);

        CPPUNIT_ASSERT_NO_THROW(p = _p2);
        CPPUNIT_ASSERT_MESSAGE("C style pointer assign error", p.mMeta->ptr == _p2);
        CPPUNIT_ASSERT_MESSAGE("C style pointer assign error", p.mMeta->usage == 1);
  }

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

  void TestPointer::test_operator_assignment_Pointer___T__Lock__()
  {

        /*
         * You have to verify the following:
         * 
         * Assign another smart pointer.
         */

        typedef Pointer < int,
        DummyLock > MyPointer;

        int *_p = new int (1);
        MyPointer p1(_p);

        // Assign self
        void *_meta = p1.mMeta;

        CPPUNIT_ASSERT_NO_THROW(p1 = p1);
        CPPUNIT_ASSERT_MESSAGE("Self assign error", p1.mMeta->usage == 1);
        CPPUNIT_ASSERT_MESSAGE("Self assign error", p1.mMeta == _meta);

        // Assign another
        MyPointer p2;

        CPPUNIT_ASSERT_NO_THROW(p2 = p1);
        CPPUNIT_ASSERT_MESSAGE("Assign error", p1.mMeta == p2.mMeta);
        CPPUNIT_ASSERT_MESSAGE("Assign error", p1.mMeta->usage == 2);

        // Assing a just-in created smart pointer (null)
        CPPUNIT_ASSERT_NO_THROW(p2 = MyPointer());
        CPPUNIT_ASSERT_MESSAGE("Just-in created assign error", p2.mMeta->ptr == 0);
        CPPUNIT_ASSERT_MESSAGE("Just-in created assign error", p2.mMeta->dead == true);
        CPPUNIT_ASSERT_MESSAGE("Just-in created assign error", p2.mMeta->usage == 1);
        CPPUNIT_ASSERT_MESSAGE("Just-in created assign error", p2.mMeta->ownMemory == false);

        // Assing a just-in created smart pointer (not null)
        CPPUNIT_ASSERT_NO_THROW(p2 = MyPointer(new int (1234)));

        CPPUNIT_ASSERT_MESSAGE("Just-in created assign error", p2.mMeta->ptr != 0);
        CPPUNIT_ASSERT_MESSAGE("Just-in created assign error", *(p2.mMeta->ptr) == 1234);
        CPPUNIT_ASSERT_MESSAGE("Just-in created assign error", p2.mMeta->dead == false);
        CPPUNIT_ASSERT_MESSAGE("Just-in created assign error", p2.mMeta->usage == 1);
        CPPUNIT_ASSERT_MESSAGE("Just-in created assign error", p2.mMeta->ownMemory == true);
  }

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

  void TestPointer::test_operator_assignment_cPointer___T__Lock__()
  {

        /*
         * You have to verify the following:
         * 
         * Assign another smart pointer (const version).
         */

        // Testes in nonconst version
  }

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

  void TestPointer::test_operator_memberSelection()
  {

        /*
         * You have to verify the following:
         * 
         * Get referenced object.
         */

        int *_p = new int (1);
        Pointer < int,
        DummyLock > p(_p);

        CPPUNIT_ASSERT_MESSAGE("Member selection(->) error", p.operator->() == _p);
  }

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

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

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

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

  void TestPointer::test_operator_equality_cT_p()
  {

        /*
         * You have to verify the following:
         * 
         * Equality test operator on a C style pointer.
         */

        // ambiguous !
        // int *_p = new int (1);
        // Pointer < int, DummyLock > p(_p);
        // CPPUNIT_ASSERT(p == _p);
  }

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

  void TestPointer::test_operator_equality_Pointer___T__Lock__()
  {

        /*
         * You have to verify the following:
         * 
         * Equality test operator.
         */

        int *_p1 = new int (1);
        int *_p2 = new int (2);
        Pointer < int,
        DummyLock > p1(_p1);
        Pointer < int,
        DummyLock > p2(p1);
        Pointer < int,
        DummyLock > p3(_p2);

        CPPUNIT_ASSERT(p1 == p2);
        CPPUNIT_ASSERT(!(p1 == p3));
  }

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

  void TestPointer::test_operator_inequality_cT_p()
  {

        /*
         * You have to verify the following:
         * 
         * Equality test operator on a C style pointer.
         */

        // ambiguous !
        // int *_p = new int (1);
        // Pointer < int, DummyLock > p(_p);
        // CPPUNIT_ASSERT((p != _p));
  }

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

  void TestPointer::test_operator_inequality_Pointer___T__Lock__()
  {

        /*
         * You have to verify the following:
         * 
         * Equality test operator.
         */

        int *_p1 = new int (1);
        int *_p2 = new int (2);
        Pointer < int,
        DummyLock > p1(_p1);
        Pointer < int,
        DummyLock > p2(p1);
        Pointer < int,
        DummyLock > p3(_p2);

        CPPUNIT_ASSERT(!(p1 != p2));
        CPPUNIT_ASSERT(p1 != p3);
  }

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

  //
  // Method tests
  //

  void TestPointer::test_isNull()
  {

        /*
         * You have to verify the following:
         * 
         * Return true if the pointer does not reference anything.
         */

        Pointer < int,
        DummyLock > p1;

        int *_p = new int (1);
        Pointer < int,
        DummyLock > p2(_p);

        CPPUNIT_ASSERT(p1.isNull());
        CPPUNIT_ASSERT(!p2.isNull());
  }

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

  void TestPointer::test_isNotNull()
  {

        /*
         * You have to verify the following:
         * 
         * Return true if the pointer does reference something.
         */

        Pointer < int,
        DummyLock > p1;

        int *_p = new int (1);
        Pointer < int,
        DummyLock > p2(_p);

        CPPUNIT_ASSERT(!p1.isNotNull());
        CPPUNIT_ASSERT(p2.isNotNull());
  }

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

  void TestPointer::test_assignWithLock_Pointer___T__Lock__()
  {

        /*
         * You have to verify the following:
         * 
         * Assign another smart pointer with keeping it locked.
         */

        typedef Pointer < int,
        Mutex > MyPointer;

        int *_p = new int (1);
        MyPointer p1(_p);

        // Assign self
        void *_meta = p1.mMeta;

        CPPUNIT_ASSERT_NO_THROW(p1.assignWithLock(p1));
        CPPUNIT_ASSERT_MESSAGE("Self assign error", p1.mMeta->usage == 1);
        CPPUNIT_ASSERT_MESSAGE("Self assign error", p1.mMeta == _meta);
        // The pointed is still locked
        CPPUNIT_ASSERT_MESSAGE("Self assign error", p1.mMeta->lock.getLocked());
        p1.unlock();

        // Assign another
        MyPointer p2;

        CPPUNIT_ASSERT_NO_THROW(p2.assignWithLock(p1));
        CPPUNIT_ASSERT_MESSAGE("Assign error", p1.mMeta == p2.mMeta);
        CPPUNIT_ASSERT_MESSAGE("Assign error", p1.mMeta->usage == 2);
        // The pointed is still locked
        CPPUNIT_ASSERT_MESSAGE("Self assign error", p2.mMeta->lock.getLocked());
        p2.unlock();
  }

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

  void TestPointer::test_reference_cT_p()
  {

        /*
         * You have to verify the following:
         * 
         * Take reference from a C style pointer (does not delete referenced object when smart pointer dies).
         */

        int *_p1 = new int (1);
        Pointer < int,
        DummyLock > p(_p1);
        Pointer < int,
        DummyLock > p2(p);      // double reference

        // Assign self
        void *_meta = p.mMeta;

        CPPUNIT_ASSERT_NO_THROW(p = _p1);
        CPPUNIT_ASSERT_MESSAGE("C style pointer self assign error", p.mMeta->ptr == _p1);
        CPPUNIT_ASSERT_MESSAGE("C style pointer self assign error", p.mMeta->usage == 2);
        CPPUNIT_ASSERT_MESSAGE("C style pointer self assign error", p.mMeta == _meta);

        // Assign another
        int *_p2 = new int (2);

        CPPUNIT_ASSERT_NO_THROW(p = _p2);
        CPPUNIT_ASSERT_MESSAGE("C style pointer assign error", p.mMeta->ptr == _p2);
        CPPUNIT_ASSERT_MESSAGE("C style pointer assign error", p.mMeta->usage == 1);
  }

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

  void TestPointer::test_getPtr()
  {

        /*
         * You have to verify the following:
         * 
         * Return a C style pointer to the referenced object.
         */

        int *_p = new int (1);
        Pointer < int,
        DummyLock > p(_p);

        CPPUNIT_ASSERT_MESSAGE("C style pointer error", p.getPtr() == _p);
  }

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

  void TestPointer::test_kill_cbool()
  {

        /*
         * You have to verify the following:
         * 
         * Force deallocating referenced object.
         */

        // Nice kill
        int *_p = new int (1);
        Pointer < int,
        DummyLock > p1(_p);
        Pointer < int,
        DummyLock > p2(p1);

        CPPUNIT_ASSERT_NO_THROW(p2.kill());
        CPPUNIT_ASSERT_MESSAGE("Nice kill error", p1.isNotNull());

        // Force kill
        Pointer < int,
        DummyLock > p3(p1);

        CPPUNIT_ASSERT_NO_THROW(p3.kill(true));
        CPPUNIT_ASSERT_MESSAGE("Force kill error", p1.isNull());
  }

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

  void TestPointer::test_setNull_cbool()
  {

        /*
         * You have to verify the following:
         * 
         * Set the referenced object to null without trying to deallocate the actual object.
         * 
         * The typical usage of this method the external deallocating a pointer,
         * like fclose.
         * 
         */

        int *_p = new int (1);

        // Create a pointer referencing this object and set to null
        Pointer < int,
        DummyLock > p(_p);

        p.setNull();

        // Deallocate referenced object
        delete _p;

        // Destructor of will not crash
  }

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

  void TestPointer::test_lock()
  {

        /*
         * You have to verify the following:
         * 
         * Lock the referenced object.
         */

        // The functionality of this method is already tested
  }

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

  void TestPointer::test_trylock()
  {

        /*
         * You have to verify the following:
         * 
         * Try locking referenced object.
         */

        // The functionality of this method is already tested
  }

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

  void TestPointer::test_unlock()
  {

        /*
         * You have to verify the following:
         * 
         * Unlock the referenced object.
         */

        // The functionality of this method is already tested
  }

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

  void TestPointer::test_getLocked()
  {

        /*
         * You have to verify the following:
         * 
         * Return true, if the object is locked.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

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

  void TestPointer::test__deletePointer_cbool_cbool()
  {

        /*
         * You have to verify the following:
         * 
         * Delete the pointer. Decrease reference counter, relese lock, free memory if needed.
         */

        // The functionality of this method is already tested
  }

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

  void TestPointer::test__assignCPointer_cT_p_cbool()
  {

        /*
         * You have to verify the following:
         * 
         * Assign a C style pointer.
         */

        // The functionality of this method is already tested
  }

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

  void TestPointer::test__assignPointer_Pointer___T__Lock___cbool()
  {

        /*
         * You have to verify the following:
         * 
         * Assign another smart pointer.
         */

        // The functionality of this method is already tested
  }

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

  void TestPointer::test__switchPointer_Pointer___T__Lock___cbool()
  {

        /*
         * You have to verify the following:
         * 
         * Switch to another smart pointer. Helps changing reference under continous lock.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

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

  void TestPointer::test__equalsCPointer_cT_p()
  {

        /*
         * You have to verify the following:
         * 
         * Test indentity.
         */

        // The functionality of this method is already tested
  }

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

  void TestPointer::test__equalsPointer_Pointer___T__Lock__()
  {

        /*
         * You have to verify the following:
         * 
         * Test indentity.
         */

        // The functionality of this method is already tested
  }

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

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

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