[pygccxml-commit] SF.net SVN: pygccxml: [1158] pyplusplus_dev/unittests

[<rom...@us...>]

Revision: 1158
          http://pygccxml.svn.sourceforge.net/pygccxml/?rev=1158&view=rev
Author:   roman_yakovenko
Date:     2007-11-19 13:05:05 -0800 (Mon, 19 Nov 2007)

Log Message:
-----------
adding new test case for reported bug

Modified Paths:
--------------
    pyplusplus_dev/unittests/test_all.py

Added Paths:
-----------
    pyplusplus_dev/unittests/data/include_exclude_bug_to_be_exported.hpp
    pyplusplus_dev/unittests/include_exclude_bug_tester.py

Property Changed:
----------------
    pyplusplus_dev/unittests/data/


Property changes on: pyplusplus_dev/unittests/data
___________________________________________________________________
Name: svn:ignore
   - *.obj
call_policies_to_be_exported.os

   + *.obj
call_policies_to_be_exported.os
global_variables_to_be_exported.os
member_functions_to_be_exported.os


Added: pyplusplus_dev/unittests/data/include_exclude_bug_to_be_exported.hpp
===================================================================
--- pyplusplus_dev/unittests/data/include_exclude_bug_to_be_exported.hpp	                        (rev 0)
+++ pyplusplus_dev/unittests/data/include_exclude_bug_to_be_exported.hpp	2007-11-19 21:05:05 UTC (rev 1158)
@@ -0,0 +1,398 @@
+// Copyright 2004-2007 Roman Yakovenko.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//This file is base on OgreAny.h file, just slightly modified to remove dependencies.
+
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser 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, or go to
+http://www.gnu.org/copyleft/lesser.txt.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+// -- Based on boost::any, original copyright information follows --
+// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompAnying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// -- End original copyright --
+
+#ifndef __OGRE_ANY_H__
+#define __OGRE_ANY_H__
+
+#include <string>
+#include <algorithm>
+#include <stdexcept>
+#include <typeinfo>
+
+
+namespace Ogre
+{
+	/** Variant type that can hold Any other type.
+	*/
+    class Any
+    {
+    public: // constructors
+
+        Any()
+          : mContent(0)
+        {
+        }
+
+        template<typename ValueType>
+        explicit Any(const ValueType & value)
+          : mContent(new holder<ValueType>(value))
+        {
+        }
+
+        Any(const Any & other)
+          : mContent(other.mContent ? other.mContent->clone() : 0)
+        {
+        }
+
+        virtual ~Any()
+        {
+            delete mContent;
+        }
+
+    public: // modifiers
+
+        Any& swap(Any & rhs)
+        {
+            std::swap(mContent, rhs.mContent);
+            return *this;
+        }
+
+        template<typename ValueType>
+        Any& operator=(const ValueType & rhs)
+        {
+            Any(rhs).swap(*this);
+            return *this;
+        }
+
+        Any & operator=(const Any & rhs)
+        {
+            Any(rhs).swap(*this);
+            return *this;
+        }
+
+    public: // queries
+
+        bool isEmpty() const
+        {
+            return !mContent;
+        }
+
+        const std::type_info& getType() const
+        {
+            return mContent ? mContent->getType() : typeid(void);
+        }
+
+		inline friend std::ostream& operator <<
+			( std::ostream& o, const Any& v )
+		{
+			if (v.mContent)
+				v.mContent->writeToStream(o);
+			return o;
+		}
+
+
+    protected: // types
+
+        class placeholder
+        {
+        public: // structors
+    
+            virtual ~placeholder()
+            {
+            }
+
+        public: // queries
+
+            virtual const std::type_info& getType() const = 0;
+
+            virtual placeholder * clone() const = 0;
+    
+			virtual void writeToStream(std::ostream& o) = 0;
+
+        };
+
+        template<typename ValueType>
+        class holder : public placeholder
+        {
+        public: // structors
+
+            holder(const ValueType & value)
+              : held(value)
+            {
+            }
+
+        public: // queries
+
+            virtual const std::type_info & getType() const
+            {
+                return typeid(ValueType);
+            }
+
+            virtual placeholder * clone() const
+            {
+                return new holder(held);
+            }
+
+			virtual void writeToStream(std::ostream& o)
+			{
+				o << held;
+			}
+
+
+        public: // representation
+
+            ValueType held;
+
+        };
+
+
+
+    protected: // representation
+        placeholder * mContent;
+
+        template<typename ValueType>
+        friend ValueType * any_cast(Any *);
+
+
+    public: 
+
+	    template<typename ValueType>
+    	ValueType operator()() const
+    	{
+			if (!mContent) 
+			{
+				throw std::runtime_error( "Bad cast from uninitialised Any" );
+			}
+			else if(getType() == typeid(ValueType))
+			{
+             	return static_cast<Any::holder<ValueType> *>(mContent)->held;
+			}
+			else
+			{
+                throw std::runtime_error( "Bad cast from specific type" );
+			}
+		}
+
+		
+
+    };
+
+
+	/** Specialised Any class which has built in arithmetic operators, but can 
+		hold only types which support operator +,-,* and / .
+	*/
+	class AnyNumeric : public Any
+	{
+	public:
+		AnyNumeric()
+		: Any()
+		{
+		}
+
+		template<typename ValueType>
+		AnyNumeric(const ValueType & value)
+			
+		{
+			mContent = new numholder<ValueType>(value);
+		}
+
+		AnyNumeric(const AnyNumeric & other)
+            : Any()
+		{
+			mContent = other.mContent ? other.mContent->clone() : 0; 
+		}
+	protected:
+		class numplaceholder : public Any::placeholder
+		{
+		public: // structors
+
+			~numplaceholder()
+			{
+			}
+			virtual Any::placeholder* add(Any::placeholder* rhs) = 0;
+			virtual Any::placeholder* subtract(Any::placeholder* rhs) = 0;
+			virtual Any::placeholder* multiply(Any::placeholder* rhs) = 0;
+			virtual Any::placeholder* multiply(double factor) = 0;
+			virtual Any::placeholder* divide(Any::placeholder* rhs) = 0;
+		};
+
+		template<typename ValueType>
+		class numholder : public numplaceholder
+		{
+		public: // structors
+
+			numholder(const ValueType & value)
+				: held(value)
+			{
+			}
+
+		public: // queries
+
+			virtual const std::type_info & getType() const
+			{
+				return typeid(ValueType);
+			}
+
+			virtual placeholder * clone() const
+			{
+				return new numholder(held);
+			}
+
+			virtual placeholder* add(placeholder* rhs)
+			{
+				return new numholder(held + static_cast<numholder*>(rhs)->held);
+			}
+			virtual placeholder* subtract(placeholder* rhs)
+			{
+				return new numholder(held - static_cast<numholder*>(rhs)->held);
+			}
+			virtual placeholder* multiply(placeholder* rhs)
+			{
+				return new numholder(held * static_cast<numholder*>(rhs)->held);
+			}
+			virtual placeholder* multiply(double factor)
+			{
+				return new numholder(held * factor);
+			}
+			virtual placeholder* divide(placeholder* rhs)
+			{
+				return new numholder(held / static_cast<numholder*>(rhs)->held);
+			}
+			virtual void writeToStream(std::ostream& o)
+			{
+				o << held;
+			}
+
+		public: // representation
+
+			ValueType held;
+
+		};
+
+		/// Construct from holder
+		AnyNumeric(placeholder* pholder)
+		{
+			mContent = pholder;
+		}
+
+	public:
+		AnyNumeric & operator=(const AnyNumeric & rhs)
+		{
+			AnyNumeric(rhs).swap(*this);
+			return *this;
+		}
+		AnyNumeric operator+(const AnyNumeric& rhs) const
+		{
+			return AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->add(rhs.mContent));
+		}
+		AnyNumeric operator-(const AnyNumeric& rhs) const
+		{
+			return AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->subtract(rhs.mContent));
+		}
+		AnyNumeric operator*(const AnyNumeric& rhs) const
+		{
+			return AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->multiply(rhs.mContent));
+		}
+		AnyNumeric operator*(double factor) const
+		{
+			return AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->multiply(factor));
+		}
+		AnyNumeric operator/(const AnyNumeric& rhs) const
+		{
+			return AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->divide(rhs.mContent));
+		}
+		AnyNumeric& operator+=(const AnyNumeric& rhs)
+		{
+			*this = AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->add(rhs.mContent));
+			return *this;
+		}
+		AnyNumeric& operator-=(const AnyNumeric& rhs)
+		{
+			*this = AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->subtract(rhs.mContent));
+			return *this;
+		}
+		AnyNumeric& operator*=(const AnyNumeric& rhs)
+		{
+			*this = AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->multiply(rhs.mContent));
+			return *this;
+		}
+		AnyNumeric& operator/=(const AnyNumeric& rhs)
+		{
+			*this = AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->divide(rhs.mContent));
+			return *this;
+		}
+
+
+
+
+	};
+
+
+    template<typename ValueType>
+    ValueType * any_cast(Any * operand)
+    {
+        return operand && operand->getType() == typeid(ValueType)
+                    ? &static_cast<Any::holder<ValueType> *>(operand->mContent)->held
+                    : 0;
+    }
+
+    template<typename ValueType>
+    const ValueType * any_cast(const Any * operand)
+    {
+        return any_cast<ValueType>(const_cast<Any *>(operand));
+    }
+
+    template<typename ValueType>
+    ValueType any_cast(const Any & operand)
+    {
+        const ValueType * result = any_cast<ValueType>(&operand);
+        if(!result)
+		{
+            throw std::runtime_error( "Bad cast from specific type" );
+		}
+        return *result;
+    }
+
+
+}
+
+#endif//__OGRE_ANY_H__

Added: pyplusplus_dev/unittests/include_exclude_bug_tester.py
===================================================================
--- pyplusplus_dev/unittests/include_exclude_bug_tester.py	                        (rev 0)
+++ pyplusplus_dev/unittests/include_exclude_bug_tester.py	2007-11-19 21:05:05 UTC (rev 1158)
@@ -0,0 +1,36 @@
+# Copyright 2004 Roman Yakovenko.
+# Distributed under the Boost Software License, Version 1.0. (See
+# accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+import os
+import sys
+import unittest
+import fundamental_tester_base
+from pyplusplus import code_creators
+
+class tester_t(fundamental_tester_base.fundamental_tester_base_t):
+    EXTENSION_NAME = 'include_exclude_bug'
+    
+    def __init__( self, *args ):
+        fundamental_tester_base.fundamental_tester_base_t.__init__( 
+            self
+            , tester_t.EXTENSION_NAME
+            , *args )
+
+    def customize(self, mb ):
+        pass
+        
+    def run_tests( self, module):
+        pass
+        
+def create_suite():
+    suite = unittest.TestSuite()    
+    suite.addTest( unittest.makeSuite(tester_t))
+    return suite
+
+def run_suite():
+    unittest.TextTestRunner(verbosity=2).run( create_suite() )
+
+if __name__ == "__main__":
+    run_suite()

Modified: pyplusplus_dev/unittests/test_all.py
===================================================================
--- pyplusplus_dev/unittests/test_all.py	2007-11-15 15:37:20 UTC (rev 1157)
+++ pyplusplus_dev/unittests/test_all.py	2007-11-19 21:05:05 UTC (rev 1158)
@@ -92,6 +92,7 @@
 import transfer_ownership_old_tester
 import transfer_ownership_tester
 import unicode_bug
+import include_exclude_bug_tester
 
 
 
@@ -175,6 +176,7 @@
     , transfer_ownership_old_tester
     , transfer_ownership_tester
     , unicode_bug
+    , include_exclude_bug_tester
 ]
 
 class process_tester_runner_t( object ):


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.