Subversion Repositories openrisc

//==========================================================================
//
//      cdl2.cxx
//
//      Tests for the CdlHandle class.
//
//==========================================================================
// ####ECOSHOSTGPLCOPYRIGHTBEGIN####                                        
// -------------------------------------------                              
// This file is part of the eCos host tools.                                
// Copyright (C) 1999, 2000 Free Software Foundation, Inc.                  
//
// 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 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., 51 Franklin Street,                      
// Fifth Floor, Boston, MA  02110-1301, USA.                                
// -------------------------------------------                              
// ####ECOSHOSTGPLCOPYRIGHTEND####                                          
//==========================================================================
//#####DESCRIPTIONBEGIN####                                             
//
// Author(s):           bartv
// Contributors:        bartv
// Date:                1999-01-12
// Description:         Large parts of libcdl are implemented using a
//                      CdlHandle template and a CdlRefcountSupport class.
//                      This tests check that these both work as expected.
//
//####DESCRIPTIONEND####
//==========================================================================
 
#include <cstdio>
#include <cdlconfig.h>
#include <cdl.hxx>
#include <cyg/infra/cyg_ass.h>
#include <cyg/infra/cyg_trac.h>
#include <cyg/infra/testcase.h>
#include <cstdlib>
 
#ifndef CYGBLD_LIBCDL_USE_SMART_POINTERS
int
main(int argc, char** argv)
{
    CYG_TEST_FAIL_FINISH("Smart pointers not yet enabled - waiting for a working version of Visual C++");
    return EXIT_FAILURE;
}
#else // CYGBLD_LIBCDL_USE_SMART_POINTERS
// ----------------------------------------------------------------------------
// Miscellaneous statics.
 
// This routine controls the return value of a class1_body check_this()
// operation, allowing test code to make sure that using check_this()
// on a smart pointer works as expected.
static bool check_this_ok = true;
 
// ----------------------------------------------------------------------------
// This test case makes use of three implementation classes. It is necessary
// to have forward declarations of these, and then it is possible to define
// handle classes for each one.
class class01_body;
class class02_body;
class derived_body;
 
typedef CdlHandle<class01_body> class01;
typedef CdlHandle<class02_body> class02;
typedef CdlHandle<derived_body> derived;
 
// ----------------------------------------------------------------------------
// This test needs three additional classes which are reference-counted and
// which are accessed via CdlHandle smart pointers. It is necessary to start 
 
class class01_body : public CdlRefcountSupport {
 
    friend class CdlTest;
 
  public:
 
    static int class01_objects;
    class01_body() : CdlRefcountSupport() {
        class01_objects++;
        object_number = class01_objects;
        modifiable    = 0;
        class01_body_cookie = class01_body_magic;
    }
    ~class01_body() {
        class01_objects--;
        class01_body_cookie = class01_body_invalid;
    }
    int
    get_number(void) {
        return object_number;
    }
    void
    modify(void) {
        modifiable++;
    }
    bool check_this(cyg_assert_class_zeal zeal) const {
        CYG_UNUSED_PARAM(cyg_assert_class_zeal, zeal);
        if (class01_body_magic != class01_body_cookie) {
            return false;
        }
        return check_this_ok;
    }
 
  private:
    // Which object is this?
    int object_number;
    int modifiable;
 
    class01_body(const class01_body&);
    class01_body& operator=(const class01_body&);
    enum {
        class01_body_invalid     = 0,
        class01_body_magic       = 0x015b19d6
    } class01_body_cookie;
};
 
class class02_body : public CdlRefcountSupport {
 
    friend class CdlTest;
 
  public:
    static int class02_objects;
    class02_body() : CdlRefcountSupport() {
        class02_objects++;
        class02_body_cookie = class02_body_magic;
    }
    ~class02_body() {
        class02_objects--;
        class02_body_cookie = class02_body_invalid;
    }
 
    bool check_this(cyg_assert_class_zeal zeal) const {
        CYG_UNUSED_PARAM(cyg_assert_class_zeal, zeal);
        return class02_body_magic == class02_body_cookie;
    }
 
  private:
    class02_body(const class02_body&);
    class02_body& operator=(const class02_body&);
    enum {
        class02_body_invalid     = 0,
        class02_body_magic       = 0x3225c96c
    } class02_body_cookie;
};
 
class derived_body : public class01_body {
 
    friend class CdlTest;
 
  public:
    static int derived_objects;
    derived_body() : class01_body() {
        derived_objects++;
        derived_body_cookie = derived_body_magic;
    }
    ~derived_body() {
        derived_objects--;
        derived_body_cookie = derived_body_invalid;
    }
    bool check_this(cyg_assert_class_zeal zeal) const {
        if (derived_body_magic != derived_body_cookie) {
            return false;
        }
        return class01_body::check_this(zeal);
    }
 
  private:
    derived_body(const derived_body&);
    derived_body& operator=(const derived_body&);
    enum {
        derived_body_invalid    = 0,
        derived_body_magic      = 0x7ed15350
    } derived_body_cookie;
};
 
int class01_body::class01_objects   = 0;
int class02_body::class02_objects   = 0;
int derived_body::derived_objects   = 0;
 
// ----------------------------------------------------------------------------
// The actual test code.
 
bool
check_const_arg(const class01 const_ptr)
{
    // Make sure that read-only access is allowed and goes to the right
    // object
    if (!const_ptr->check_this(cyg_quick)) {
        CYG_TEST_FAIL("check_this() on a constant pointer should be fine");
        return false;
    }
    check_this_ok = false;
    if (const_ptr->check_this(cyg_quick)) {
        CYG_TEST_FAIL("check_this() on a constant pointer should be fine");
        check_this_ok = true;
        return false;
    }
    check_this_ok = true;
    return true;
}
 
int
main(int argc, char** argv)
{
    bool ok = true;
 
    // Make sure that smart pointers do not impose any kind of overhead.
    if ((sizeof(void *) != sizeof(class01)) ||
        (sizeof(void *) != sizeof(class02)) ||
        (sizeof(void *) != sizeof(derived))) {
 
        CYG_TEST_FAIL("smart pointers are not the same size as dumb pointers");
    } else {
        CYG_TEST_PASS("smart pointers are the same size as dumb pointers");
    }
 
    // Start by creating a number of objects to be manipulated.
    class01_body *      class01_obj1    = new class01_body;
    class01_body *      class01_obj2    = new class01_body;
    class02_body *      class02_obj1    = new class02_body;
    derived_body *      derived_obj1    = new derived_body;
 
    // Quick sanity check
    if ((1 != derived_body::derived_objects) ||
        (1 != class02_body::class02_objects) ||
        (3 != class01_body::class01_objects)) {
        CYG_TEST_FAIL("Testcase has created an invalid number of objects");
    }
 
    // Convert the basic objects to smart pointers. If this code compiles
    // then the test succeeds.
    class01     class01_ptr1    = class01(class01_obj1);
    class01     class01_ptr2    = class01(class01_obj2);
    class02     class02_ptr1    = class02(class02_obj1);
    derived     derived_ptr1    = derived(derived_obj1);
    CYG_TEST_PASS("conversion to smart pointers works");
 
    // Also create a couple of other smart pointers. These should be
    // initialised to 0.
    class01      class01_ptr3;
    class01      class01_ptr4     = 0;
    class01      class01_ptr5     = class01(0);
    CYG_TEST_PASS("smart pointers can have the value zero");
 
    // Try to dereference the smart pointers.
    if ((1 != class01_ptr1->get_number()) ||
        (2 != class01_ptr2->get_number()) ||
        (3 != derived_ptr1->get_number())) {
        CYG_TEST_FAIL("-> dereferencing operator broken");
    } else {
        CYG_TEST_PASS("-> dereferencing operator functional");
    }
    if ((1 != (*class01_ptr1).get_number()) ||
        (2 != (*class01_ptr2).get_number()) ||
        (3 != (*derived_ptr1).get_number())) {
        CYG_TEST_FAIL("* dereferencing operator broken");
    } else {
        CYG_TEST_PASS("* dereferencing operator functional");
    }
 
    // Also try to access the check_this() member functions
    if (!class01_ptr1->check_this(cyg_quick)) {
    }
 
    // Do a couple of if's. This checks that the !operator is
    // functional. Some of the checks are there to make sure that the
    // compiler does the right thing.
    ok = true;
    if (!class01_ptr1) {
        CYG_TEST_FAIL("!(assigned smart pointer) is true");
        ok = false;
    }
    if (0 == class01_ptr1) {
        CYG_TEST_FAIL("0 == assigned smart pointer");
        ok = false;
    }
    if (0 != class01_ptr3) {
        CYG_TEST_FAIL("0 != unassigned smart pointer");
        ok = false;
    }
    if (class01_ptr1 == 0) {
        CYG_TEST_FAIL("0 == assigned smart pointer");
        ok = false;
    }
    if (class01_ptr3 != 0) {
        CYG_TEST_FAIL("0 != unassigned smart pointer");
        ok = false;
    }
    if (class01_ptr1 == class01_ptr2) {
        CYG_TEST_FAIL("comparing two different smart pointers succeeds");
        ok = false;
    }
    if (class01_ptr1 != class01_ptr2) {
        // Do nothing
    } else {
        CYG_TEST_FAIL("comparing two different smart pointers succeeds");
        ok = false;
    }
#if 0
    // Comparing base and derived smart pointers directly does not work yet.
    if (class01_ptr1 == derived_ptr1) {
        CYG_TEST_FAIL("comparing different base and derived pointers succeeds");
    }
#endif
    if (ok) {
        CYG_TEST_PASS("smart pointer comparisons work");
    }
 
    // Try some  assignment operators.
    class01_ptr3 = class01_ptr1;
    class01_ptr4 = derived_ptr1;
    class01_ptr5 = class01_ptr2;
 
    // After doing all of these assignments there should be no change in
    // the number of underlying objects.
    ok = true;
    if ((1 != derived_body::derived_objects) ||
        (1 != class02_body::class02_objects)   ||
        (3 != class01_body::class01_objects)) {
        ok = false;
        CYG_TEST_FAIL("Assignment of smart pointers has changed the underlying number of objects");
    }
    if ((class01_ptr1 != class01_ptr3) ||
        (class01_ptr2 != class01_ptr5)) {
        ok = false;
        CYG_TEST_FAIL("Assignment of smart pointers has not worked");
    }
    if (class01_ptr4.get_dumb_pointer() != derived_ptr1.get_dumb_pointer()) {
        ok = false;
        CYG_TEST_FAIL("Assignment of derived to base smart pointer has not worked");
    }
    if ((2 != class01_ptr1->get_refcount()) ||
        (2 != class01_ptr2->get_refcount()) ||
        (2 != class01_ptr4->get_refcount()) ||
        (2 != derived_ptr1->get_refcount())) {
        ok = false;
        CYG_TEST_FAIL("Reference counts after assignment operators do not match up");
    }
    if (ok) {
        CYG_TEST_PASS("Assignment of smart pointers");
    }
 
    // Now try assigning zero. Incidentally this is necessary if the underlying
    // objects are to be destroyed again at the end.
    class01_ptr3 = 0;
    class01_ptr4 = 0;
    class01_ptr5 = 0;
 
    ok = true;
    if (0 != class01_ptr3) {
        ok = false;
        CYG_TEST_FAIL("assigning 0 to a smart pointer does not work");
    }
    if ((1 != class01_ptr1->get_refcount()) ||
        (1 != class01_ptr2->get_refcount()) ||
        (1 != derived_ptr1->get_refcount())) {
        ok = false;
        CYG_TEST_FAIL("Reference counts after assignment operators do not match up");
    }
    if (ok) {
        CYG_TEST_PASS("Assigning zero to smart pointers");
    }
 
    // Make sure that implicit casts to const work. This is really
    // a compiler test.
    if (check_const_arg(class01_ptr1) &&
        check_const_arg(derived_ptr1)) {
        CYG_TEST_PASS("Implicit cast to const smart pointer");
    }
 
#if 0
    // All of this code should fail to compile.
    // Applying delete to a smart pointer does not work. Use destroy() instead.
    delete class01_ptr1;
#endif
#if 0
    // Attempts to do incompatible assignments should fail.
    class01_ptr1 = class02_ptr1;
#endif
#if 0    
    // Comparing completely different types should fail.
    if (class01_ptr1 == class02_ptr1) {
        CYG_TEST_FAIL("it should not be possible to compare objects of different types");
    }
#endif
#if 0
    {
        const class01 const_class01_ptr = class01_ptr1;
        const_class01_ptr->modify();
    }
#endif
#if 0
    {
        const class01 const_derived_ptr = derived_ptr1;
        const_derived_ptr->modify();
    }
#endif
 
    // Check that destroy() actually gets rid of the underlying objects.
    class01_ptr1.destroy();
    class01_ptr2.destroy();
    class02_ptr1.destroy();
    derived_ptr1.destroy();
    if ((0 != derived_body::derived_objects) ||
        (0 != class02_body::class02_objects)    ||
        (0 != class01_body::class01_objects)) {
        CYG_TEST_FAIL("There are still objects after the smart pointers have been destroyed");
    } else {
        CYG_TEST_PASS("Using destroy() on the smart pointers cleans up the underlying objects");
    }
 
    return EXIT_SUCCESS;
}
#endif