activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r922020 - in /activemq/activemq-cpp/trunk/activemq-cpp/src: main/ main/decaf/lang/ main/decaf/util/concurrent/atomic/ test/ test/decaf/lang/
Date Thu, 11 Mar 2010 21:04:39 GMT
Author: tabish
Date: Thu Mar 11 21:04:38 2010
New Revision: 922020

URL: http://svn.apache.org/viewvc?rev=922020&view=rev
Log:
Add a new Array smart pointer class and clean up the Pointer class, add some more tests.

Added:
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/ArrayPointer.h   (with props)
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/atomic/AtomicRefCounter.h   (with props)
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.cpp   (with props)
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.h   (with props)
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.cpp   (with props)
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.h   (with props)
Modified:
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/Makefile.am
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/Pointer.h
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/String.cpp
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/String.h
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/Makefile.am
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/Makefile.am
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/Makefile.am?rev=922020&r1=922019&r2=922020&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/Makefile.am (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/Makefile.am Thu Mar 11 21:04:38 2010
@@ -1191,6 +1191,7 @@ h_sources = \
     decaf/io/UnsupportedEncodingException.h \
     decaf/io/Writer.h \
     decaf/lang/Appendable.h \
+    decaf/lang/ArrayPointer.h \
     decaf/lang/Boolean.h \
     decaf/lang/Byte.h \
     decaf/lang/CharSequence.h \

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/ArrayPointer.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/ArrayPointer.h?rev=922020&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/ArrayPointer.h (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/ArrayPointer.h Thu Mar 11 21:04:38 2010
@@ -0,0 +1,371 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _DECAF_LANG_ARRAYPOINTER_H_
+#define _DECAF_LANG_ARRAYPOINTER_H_
+
+#include <decaf/util/Config.h>
+#include <decaf/lang/exceptions/NullPointerException.h>
+#include <decaf/lang/exceptions/IndexOutOfBoundsException.h>
+#include <decaf/lang/exceptions/IllegalArgumentException.h>
+#include <decaf/util/concurrent/atomic/AtomicRefCounter.h>
+#include <decaf/util/Comparator.h>
+#include <memory>
+#include <typeinfo>
+#include <algorithm>
+
+namespace decaf {
+namespace lang {
+
+    /**
+     * Decaf's implementation of a Smart Pointer that is a template on a Type
+     * and is Thread Safe if the default Reference Counter is used.  This Pointer
+     * type allows for the substitution of different Reference Counter implementations
+     * which provide a means of using invasive reference counting if desired using
+     * a custom implementation of <code>ReferenceCounter</code>.
+     * <p>
+     * The Decaf smart pointer provide comparison operators for comparing Pointer
+     * instances in the same manner as normal pointer, except that it does not provide
+     * an overload of operators ( <, <=, >, >= ).  To allow use of a Pointer in a STL
+     * container that requires it, Pointer provides an implementation of std::less.
+     *
+     * @since 1.0
+     */
+    template< typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter >
+    class ArrayPointer : public REFCOUNTER {
+    private:
+
+        struct ArrayData {
+            T* value;
+            std::size_t length;
+
+            ArrayData() : value( NULL ), length( 0 ) {}
+            ArrayData( T* value, std::size_t length ) : value( value ), length( length ) {}
+        };
+
+        typedef void (*deletionFuncPtr)(ArrayData* p);
+
+    private:
+
+        ArrayData* array;
+
+        // Pointer to our internal delete function, allows incompletes.
+        deletionFuncPtr onDelete;
+
+    public:
+
+        typedef T* PointerType;          // type returned by operator->
+        typedef T& ReferenceType;        // type returned by operator*
+        typedef REFCOUNTER CounterType;  // Type of the Reference Counter
+
+    public:
+
+        /**
+         * Default Constructor
+         *
+         * Initialized the contained array pointer to NULL, using the subscript operator
+         * results in an exception unless reset to contain a real value.
+         */
+        ArrayPointer() : REFCOUNTER(), array( new ArrayData() ), onDelete( onDeleteFunc ) {}
+
+        /**
+         * Create a new ArrayPointer instance and allocates an internal array that is sized
+         * using the passed in size value.
+         *
+         * @param size
+         *      The size of the array to allocate for this ArrayPointer instance.
+         */
+        ArrayPointer( std::size_t size ) :
+            REFCOUNTER(), array( NULL ), onDelete( onDeleteFunc ) {
+
+            if( size == 0 ) {
+                return;
+            }
+
+            try{
+                T* value = new T[size];
+                this->array = new ArrayData( value, size );
+            } catch( std::exception& ex ) {
+                REFCOUNTER::release();
+                throw ex;
+            } catch(...) {
+                REFCOUNTER::release();
+                throw std::bad_alloc();
+            }
+        }
+
+        /**
+         * Explicit Constructor, creates an ArrayPointer that contains value with a
+         * single reference.  This object now has ownership until a call to release.
+         *
+         * @param value
+         *      The pointer to the instance of the array we are taking ownership of.
+         * @param size
+         *      The size of the array this object is taking ownership of.
+         */
+        explicit ArrayPointer( const PointerType value, std::size_t size ) :
+            REFCOUNTER(), array( new ArrayData( value, size ) ), onDelete( onDeleteFunc ) {
+        }
+
+        /**
+         * Copy constructor. Copies the value contained in the ArrayPointer to the new
+         * instance and increments the reference counter.
+         */
+        ArrayPointer( const ArrayPointer& value ) throw() :
+            REFCOUNTER( value ), array( value.array ), onDelete( onDeleteFunc ) {}
+
+        virtual ~ArrayPointer() throw() {
+            if( REFCOUNTER::release() == true ) {
+                onDelete( this->array );
+            }
+        }
+
+        /**
+         * Resets the ArrayPointer to hold the new value.  Before the new value is stored
+         * reset checks if the old value should be destroyed and if so calls delete.
+         * Call reset with a value of NULL is supported and acts to set this Pointer
+         * to a NULL pointer.
+         *
+         * @param value
+         *      The new array pointer value to contain.
+         * @param size
+         *      The size of the new array value this object now contains.
+         */
+        void reset( T* value, std::size_t size = 0 ) {
+            ArrayPointer( value, size ).swap( *this );
+        }
+
+        /**
+         * Releases the Pointer held and resets the internal pointer value to Null.  This method
+         * is not guaranteed to be safe if the Pointer is held by more than one object or this
+         * method is called from more than one thread.
+         *
+         * @param value - The new value to contain.
+         *
+         * @returns The pointer instance that was held by this Pointer object, the pointer is
+         *          no longer owned by this Pointer and won't be freed when this Pointer goes
+         *          out of scope.
+         */
+        T* release() {
+            T* temp = this->value;
+            this->array = NULL;
+            return temp;
+        }
+
+        /**
+         * Gets the real array pointer that is contained within this Pointer.  This
+         * is not really safe since the caller could delete or alter the pointer but
+         * it mimics the STL auto_ptr and gives access in cases where the caller
+         * absolutely needs the real Pointer.  Use at your own risk.
+         *
+         * @return the contained pointer.
+         */
+        PointerType get() const {
+            return this->array->value;
+        }
+
+        /**
+         * Returns the current size of the contained array or zero if the array is
+         * NULL.
+         *
+         * @returns the size of the array or zero if the array is NULL
+         */
+        std::size_t length() const {
+            return this->array->length;
+        }
+
+        /**
+         * Exception Safe Swap Function
+         * @param value - the value to swap with this.
+         */
+        void swap( ArrayPointer& value ) throw() {
+            std::swap( this->array, value.array );
+            REFCOUNTER::swap( value );
+        }
+
+        /**
+         * Assigns the value of right to this Pointer and increments the reference Count.
+         * @param right - Pointer on the right hand side of an operator= call to this.
+         */
+        ArrayPointer& operator= ( const ArrayPointer& right ) throw() {
+            if( this == (void*)&right ) {
+                return *this;
+            }
+
+            ArrayPointer temp( right );
+            temp.swap( *this );
+            return *this;
+        }
+        template< typename T1, typename R1>
+        ArrayPointer& operator= ( const ArrayPointer<T1, R1>& right ) throw() {
+            if( this == (void*)&right ) {
+                return *this;
+            }
+
+            ArrayPointer temp( right );
+            temp.swap( *this );
+            return *this;
+        }
+
+        /**
+         * Dereference Operator, returns a reference to the Contained value.  This
+         * method throws an NullPointerException if the contained value is NULL.
+         *
+         * @return reference to the contained pointer.
+         *
+         * @throws NullPointerException if the contained value is Null
+         */
+        ReferenceType operator[]( std::size_t index ) {
+            if( this->array->value == NULL ) {
+                throw decaf::lang::exceptions::NullPointerException(
+                    __FILE__, __LINE__, "ArrayPointer operator& - Pointee is NULL." );
+            }
+
+            if( this->array->length <= index ) {
+                throw decaf::lang::exceptions::IndexOutOfBoundsException(
+                    __FILE__, __LINE__, "Array Index %d is out of bounds for this array.", this->array->length );
+            }
+
+            return this->array->value[index];
+        }
+        ReferenceType operator[]( std::size_t index ) const {
+            if( this->array->value == NULL ) {
+                throw decaf::lang::exceptions::NullPointerException(
+                    __FILE__, __LINE__, "ArrayPointer operator& - Pointee is NULL." );
+            }
+
+            if( this->array->length <= index ) {
+                throw decaf::lang::exceptions::IndexOutOfBoundsException(
+                    __FILE__, __LINE__, "Array Index %d is out of bounds for this array.", *( this->array->length ) );
+            }
+
+            return this->array->value[index];
+        }
+
+        bool operator!() const {
+            return this->array->value == NULL;
+        }
+
+        inline friend bool operator==( const ArrayPointer& left, const T* right ) {
+            return left.get() == right;
+        }
+
+        inline friend bool operator==( const T* left, const ArrayPointer& right ) {
+            return left == right.get();
+        }
+
+        inline friend bool operator!=( const ArrayPointer& left, const T* right ) {
+            return left.get() != right;
+        }
+
+        inline friend bool operator!=( const T* left, const ArrayPointer& right ) {
+            return left != right.get();
+        }
+
+        template< typename T1, typename R1 >
+        bool operator==( const ArrayPointer<T1, R1>& right ) const {
+            return this->array->value == right.get();
+        }
+
+        template< typename T1, typename R1 >
+        bool operator!=( const ArrayPointer<T1, R1>& right ) const {
+            return this->array->value != right.get();
+        }
+
+    private:
+
+        // Internal Static deletion function.
+        static void onDeleteFunc( ArrayData* value ) {
+            delete [] value->value;
+            delete value;
+        }
+
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    template< typename T, typename R, typename U >
+    inline bool operator==( const ArrayPointer<T, R>& left, const U* right ) {
+        return left.get() == right;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    template< typename T, typename R, typename U >
+    inline bool operator==( const U* left, const ArrayPointer<T, R>& right ) {
+        return right.get() == left;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    template< typename T, typename R, typename U >
+    inline bool operator!=( const ArrayPointer<T, R>& left, const U* right ) {
+        return !( left.get() == right );
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    template< typename T, typename R, typename U >
+    inline bool operator!=( const U* left, const ArrayPointer<T, R>& right ) {
+        return right.get() != left;
+    }
+
+    /**
+     * This implementation of Comparator is designed to allows objects in a Collection
+     * to be sorted or tested for equality based on the value of the value of the actual
+     * pointer to the array being contained in this ArrayPointer.  This allows for a basic
+     * ordering to be acheived in Decaf containers.
+     *
+     * Custom implementations are possible where an array of some type has a logical natural
+     * ordering such as array of integers where the sum of all ints in the array is used.
+     */
+    template< typename T, typename R = decaf::util::concurrent::atomic::AtomicRefCounter >
+    class ArrayPointerComparator : public decaf::util::Comparator< ArrayPointer<T,R> > {
+    public:
+
+        // Allows for operator less on types that implement Comparable or provide
+        // a workable operator <
+        virtual bool operator() ( const ArrayPointer<T,R>& left, const ArrayPointer<T,R>& right ) const {
+            return left.get() < right.get();
+        }
+
+        // Requires that the type in the pointer is an instance of a Comparable.
+        virtual int compare( const ArrayPointer<T,R>& left, const ArrayPointer<T,R>& right ) const {
+            return left.get() < right.get() ? -1 : right.get() < left.get() ? 1 : 0;
+        }
+
+    };
+
+}}
+
+////////////////////////////////////////////////////////////////////////////////
+namespace std{
+
+    /**
+     * An override of the less function object so that the Pointer objects
+     * can be stored in STL Maps, etc.
+     */
+    template< typename T >
+    struct less< decaf::lang::ArrayPointer<T> > :
+        public binary_function< decaf::lang::ArrayPointer<T>,
+                                decaf::lang::ArrayPointer<T>, bool>
+    {
+        bool operator()( const decaf::lang::ArrayPointer<T>& left,
+                         const decaf::lang::ArrayPointer<T>& right ) const
+        {
+            return less<T*>()( left.get(), right.get() );
+        }
+    };
+}
+
+#endif /*_DECAF_LANG_ARRAYPOINTER_H_*/

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/ArrayPointer.h
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/ArrayPointer.h
------------------------------------------------------------------------------
    svn:executable = *

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/Pointer.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/Pointer.h?rev=922020&r1=922019&r2=922020&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/Pointer.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/Pointer.h Thu Mar 11 21:04:38 2010
@@ -21,7 +21,7 @@
 #include <decaf/util/Config.h>
 #include <decaf/lang/exceptions/NullPointerException.h>
 #include <decaf/lang/exceptions/ClassCastException.h>
-#include <decaf/util/concurrent/atomic/AtomicInteger.h>
+#include <decaf/util/concurrent/atomic/AtomicRefCounter.h>
 #include <decaf/util/Comparator.h>
 #include <memory>
 #include <typeinfo>
@@ -30,52 +30,6 @@
 namespace decaf {
 namespace lang {
 
-    class AtomicRefCounter {
-    private:
-
-        decaf::util::concurrent::atomic::AtomicInteger* counter;
-
-    private:
-
-        AtomicRefCounter& operator= ( const AtomicRefCounter& );
-
-    public:
-
-        AtomicRefCounter() :
-            counter( new decaf::util::concurrent::atomic::AtomicInteger( 1 ) ) {}
-        AtomicRefCounter( const AtomicRefCounter& other ) : counter( other.counter ) {
-            this->counter->incrementAndGet();
-        }
-
-    protected:
-
-        /**
-         * Swaps this instance's reference counter with the one given, this allows
-         * for copy-and-swap semantics of this object.
-         *
-         * @param other
-         *      The value to swap with this one's.
-         */
-        void swap( AtomicRefCounter& other ) {
-            std::swap( this->counter, other.counter );
-        }
-
-        /**
-         * Removes a reference to the counter Atomically and returns if the counter
-         * has reached zero, once the counter hits zero, the internal counter is
-         * destroyed and this instance is now considered to be unreferenced.
-         *
-         * @return true if the count is now zero.
-         */
-        bool release() {
-            if( this->counter->decrementAndGet() == 0 ) {
-                delete this->counter;
-                return true;
-            }
-            return false;
-        }
-    };
-
     // Used internally in Pointer.
     struct STATIC_CAST_TOKEN {};
     struct DYNAMIC_CAST_TOKEN {};
@@ -94,7 +48,7 @@ namespace lang {
      *
      * @since 1.0
      */
-    template< typename T, typename REFCOUNTER = AtomicRefCounter >
+    template< typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter >
     class Pointer : public REFCOUNTER {
     private:
 
@@ -396,7 +350,7 @@ namespace lang {
      * to be compared based on the comparison of the object itself and not just the value of
      * the pointer.
      */
-    template< typename T, typename R = AtomicRefCounter >
+    template< typename T, typename R = decaf::util::concurrent::atomic::AtomicRefCounter >
     class PointerComparator : public decaf::util::Comparator< Pointer<T,R> > {
     public:
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/String.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/String.cpp?rev=922020&r1=922019&r2=922020&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/String.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/String.cpp Thu Mar 11 21:04:38 2010
@@ -29,17 +29,22 @@ using namespace decaf::lang::exceptions;
 namespace decaf{
 namespace lang{
 
-    class StringContents {
+    class Contents {
     public:
 
         unsigned char* value;
+        int length;
+        int offset;
 
     public:
 
-        StringContents() : value( NULL ) {
+        Contents() : value( NULL ), length( 0 ), offset( 0 ) {
         }
 
-        ~StringContents() {
+        Contents( int length ) : value( new unsigned char[length] ), length( length ), offset( 0 ) {
+        }
+
+        ~Contents() {
             delete [] value;
         }
 
@@ -49,15 +54,14 @@ namespace lang{
 
 ////////////////////////////////////////////////////////////////////////////////
 String::String() {
-    this->contents = new StringContents();
+    this->contents.reset( new Contents() );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 String::String( const std::string& source ) {
 
     // Initialize the contents object.
-    this->contents = new StringContents();
-    this->contents->value = new unsigned char[source.length()];
+    this->contents.reset( new Contents( source.length() ) );
 
     // load the passed string into the contents value.
     System::arraycopy( (unsigned char*)source.c_str(), 0, contents->value, 0, source.length() );
@@ -66,7 +70,6 @@ String::String( const std::string& sourc
 ////////////////////////////////////////////////////////////////////////////////
 String::~String() {
     try{
-        delete this->contents;
     }
     DECAF_CATCH_NOTHROW( Exception )
     DECAF_CATCHALL_NOTHROW()

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/String.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/String.h?rev=922020&r1=922019&r2=922020&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/String.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/String.h Thu Mar 11 21:04:38 2010
@@ -22,13 +22,14 @@
 
 #include <decaf/lang/CharSequence.h>
 #include <decaf/lang/Comparable.h>
+#include <decaf/lang/Pointer.h>
 
 #include <string>
 
 namespace decaf {
 namespace lang {
 
-    class StringContents;
+    class Contents;
 
     /**
      * The String class represents an immutable sequence of chars.
@@ -38,7 +39,7 @@ namespace lang {
     class DECAF_API String {
     private:
 
-        StringContents* contents;
+        decaf::lang::Pointer<Contents> contents;
 
     public:
 

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/atomic/AtomicRefCounter.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/atomic/AtomicRefCounter.h?rev=922020&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/atomic/AtomicRefCounter.h (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/atomic/AtomicRefCounter.h Thu Mar 11 21:04:38 2010
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _DECAF_UTIL_CONCURRENT_ATOMIC_ATOMICREFCOUNTER_H_
+#define _DECAF_UTIL_CONCURRENT_ATOMIC_ATOMICREFCOUNTER_H_
+
+#include <decaf/util/concurrent/atomic/AtomicInteger.h>
+
+namespace decaf{
+namespace util{
+namespace concurrent{
+namespace atomic{
+
+    class AtomicRefCounter {
+    private:
+
+        decaf::util::concurrent::atomic::AtomicInteger* counter;
+
+    private:
+
+        AtomicRefCounter& operator= ( const AtomicRefCounter& );
+
+    public:
+
+        AtomicRefCounter() :
+            counter( new decaf::util::concurrent::atomic::AtomicInteger( 1 ) ) {}
+        AtomicRefCounter( const AtomicRefCounter& other ) : counter( other.counter ) {
+            this->counter->incrementAndGet();
+        }
+
+    protected:
+
+        /**
+         * Swaps this instance's reference counter with the one given, this allows
+         * for copy-and-swap semantics of this object.
+         *
+         * @param other
+         *      The value to swap with this one's.
+         */
+        void swap( AtomicRefCounter& other ) {
+            std::swap( this->counter, other.counter );
+        }
+
+        /**
+         * Removes a reference to the counter Atomically and returns if the counter
+         * has reached zero, once the counter hits zero, the internal counter is
+         * destroyed and this instance is now considered to be unreferenced.
+         *
+         * @return true if the count is now zero.
+         */
+        bool release() {
+            if( this->counter->decrementAndGet() == 0 ) {
+                delete this->counter;
+                return true;
+            }
+            return false;
+        }
+    };
+
+}}}}
+
+#endif /* _DECAF_UTIL_CONCURRENT_ATOMIC_ATOMICREFCOUNTER_H_ */

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/atomic/AtomicRefCounter.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/Makefile.am
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/Makefile.am?rev=922020&r1=922019&r2=922020&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/Makefile.am (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/Makefile.am Thu Mar 11 21:04:38 2010
@@ -97,6 +97,7 @@ cc_sources = \
     decaf/io/PushbackInputStreamTest.cpp \
     decaf/io/ReaderTest.cpp \
     decaf/io/WriterTest.cpp \
+    decaf/lang/ArrayPointerTest.cpp \
     decaf/lang/BooleanTest.cpp \
     decaf/lang/ByteTest.cpp \
     decaf/lang/CharacterTest.cpp \
@@ -108,6 +109,7 @@ cc_sources = \
     decaf/lang/MathTest.cpp \
     decaf/lang/PointerTest.cpp \
     decaf/lang/ShortTest.cpp \
+    decaf/lang/StringTest.cpp \
     decaf/lang/SystemTest.cpp \
     decaf/lang/ThreadTest.cpp \
     decaf/net/SocketFactoryTest.cpp \
@@ -242,6 +244,7 @@ h_sources = \
     decaf/io/PushbackInputStreamTest.h \
     decaf/io/ReaderTest.h \
     decaf/io/WriterTest.h \
+    decaf/lang/ArrayPointerTest.h \
     decaf/lang/BooleanTest.h \
     decaf/lang/ByteTest.h \
     decaf/lang/CharacterTest.h \
@@ -253,6 +256,7 @@ h_sources = \
     decaf/lang/MathTest.h \
     decaf/lang/PointerTest.h \
     decaf/lang/ShortTest.h \
+    decaf/lang/StringTest.h \
     decaf/lang/SystemTest.h \
     decaf/lang/ThreadTest.h \
     decaf/net/SocketFactoryTest.h \

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.cpp?rev=922020&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.cpp (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.cpp Thu Mar 11 21:04:38 2010
@@ -0,0 +1,497 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ArrayPointerTest.h"
+
+#include <decaf/lang/ArrayPointer.h>
+#include <decaf/lang/Thread.h>
+#include <decaf/lang/Runnable.h>
+#include <decaf/lang/exceptions/ClassCastException.h>
+#include <decaf/util/concurrent/CountDownLatch.h>
+
+#include <map>
+#include <string>
+
+using namespace std;
+using namespace decaf;
+using namespace decaf::lang;
+using namespace decaf::lang::exceptions;
+using namespace decaf::util::concurrent;
+
+////////////////////////////////////////////////////////////////////////////////
+namespace {
+
+    class TestClassBase {
+    public:
+
+        virtual ~TestClassBase(){}
+
+        virtual std::string returnHello() = 0;
+
+    };
+
+    class TestClassA : public TestClassBase {
+    public:
+
+        virtual ~TestClassA() {
+            //std::cout << std::endl << "TestClassA - Destructor" << std::endl;
+        }
+
+        std::string returnHello() {
+            return "Hello";
+        }
+
+    };
+
+    class TestClassB : public TestClassBase {
+    public:
+
+        virtual ~TestClassB() {
+            //std::cout << std::endl << "TestClassB - Destructor" << std::endl;
+        }
+
+        std::string returnHello() {
+            return "GoodBye";
+        }
+
+    };
+
+    class SomeOtherClass {
+    public:
+
+    };
+
+    class ExceptionThrowingClass {
+    public:
+
+        ExceptionThrowingClass() {
+            throw std::bad_alloc();
+        }
+    };
+
+    struct X {
+        ArrayPointer<X> next;
+    };
+
+    template<typename T>
+    void ConstReferenceMethod( const ArrayPointer<T>& pointer ) {
+        ArrayPointer<T> copy = pointer;
+        CPPUNIT_ASSERT( copy.get() != NULL );
+    }
+
+    template<typename T>
+    void ReferenceMethod( ArrayPointer<T>& pointer ) {
+        pointer.reset( NULL );
+        CPPUNIT_ASSERT( pointer.get() == NULL );
+    }
+
+    ArrayPointer<TestClassA> ReturnByValue() {
+        ArrayPointer<TestClassA> pointer( 1 );
+        CPPUNIT_ASSERT( pointer.get() != NULL );
+        return pointer;
+    }
+
+    const ArrayPointer<TestClassA>& ReturnByConstReference() {
+        static ArrayPointer<TestClassA> pointer( 1 );
+        CPPUNIT_ASSERT( pointer.get() != NULL );
+        return pointer;
+    }
+
+    TestClassA* methodReturnRawPointer( std::size_t size ) {
+        return new TestClassA[size];
+    }
+
+    ArrayPointer<TestClassA> methodReturnArrayPointer() {
+        return ArrayPointer<TestClassA>( methodReturnRawPointer( 10 ), 10 );
+    }
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ArrayPointerTest::testBasics() {
+
+    TestClassA* anArray = new TestClassA[12];
+
+    // Test Null Initialize
+    ArrayPointer<TestClassA> nullPointer;
+    CPPUNIT_ASSERT( nullPointer.get() == NULL );
+    CPPUNIT_ASSERT( nullPointer == NULL );
+    CPPUNIT_ASSERT_NO_THROW( nullPointer.reset( NULL ) );
+
+    // Test Size Constructor
+    ArrayPointer<TestClassA> pointer1( 256 );
+    CPPUNIT_ASSERT( pointer1.get() != NULL );
+    CPPUNIT_ASSERT( pointer1.length() == 256 );
+
+    // Test Value Constructor
+    ArrayPointer<TestClassA> pointer2( anArray, 12 );
+    CPPUNIT_ASSERT( pointer2.get() == anArray );
+    CPPUNIT_ASSERT( pointer2.get() != NULL );
+    CPPUNIT_ASSERT( pointer2.length() == 12 );
+
+    // Test Copy Constructor
+    ArrayPointer<TestClassA> ctorCopy( pointer2 );
+    CPPUNIT_ASSERT( ctorCopy.get() == anArray );
+    CPPUNIT_ASSERT( ctorCopy.length() == 12 );
+
+    // Test Assignment
+    ArrayPointer<TestClassA> copy = pointer2;
+    CPPUNIT_ASSERT( copy.get() == anArray );
+    CPPUNIT_ASSERT( copy.length() == 12 );
+
+    CPPUNIT_ASSERT( pointer1[0].returnHello() == "Hello" );
+
+    copy.reset( NULL );
+    CPPUNIT_ASSERT( copy.get() == NULL );
+
+    ArrayPointer<X> p( 1 );
+    p[0].next = ArrayPointer<X>( 1 );
+    p = p[0].next;
+    CPPUNIT_ASSERT( !p[0].next );
+
+    try{
+        ArrayPointer<ExceptionThrowingClass> ex( 1 );
+        CPPUNIT_FAIL( "Should Have Thrown." );
+    } catch(...) {}
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ArrayPointerTest::testAssignment() {
+
+    const std::size_t SIZE = 50;
+
+    TestClassA* thePointerA = new TestClassA[SIZE];
+    TestClassB* thePointerB = new TestClassB[SIZE + SIZE];
+
+    ArrayPointer<TestClassBase> pointer;
+    CPPUNIT_ASSERT( pointer.get() == NULL );
+
+    pointer.reset( thePointerA, SIZE );
+    CPPUNIT_ASSERT( pointer.get() == thePointerA );
+    CPPUNIT_ASSERT( pointer.length() == SIZE );
+
+    pointer.reset( thePointerB, SIZE + SIZE );
+    CPPUNIT_ASSERT( pointer.get() == thePointerB );
+    CPPUNIT_ASSERT( pointer.length() == SIZE + SIZE );
+
+    // Doing this however won't compile.
+    //    SomeOtherClass* other = new SomeOtherClass[SIZE];
+    //    pointer.reset( other );
+
+    ArrayPointer<TestClassA> pointer1( new TestClassA[SIZE], SIZE );
+    ArrayPointer<TestClassA> pointer2 = pointer1;
+    ArrayPointer<TestClassA> pointer3 = pointer2;
+
+    CPPUNIT_ASSERT( pointer1.get() == pointer2.get() );
+    CPPUNIT_ASSERT( pointer2.get() == pointer3.get() );
+
+    pointer3.reset( NULL, 0 );
+    CPPUNIT_ASSERT( pointer1.get() != NULL );
+    CPPUNIT_ASSERT( pointer2.get() != NULL );
+    CPPUNIT_ASSERT( pointer3.get() == NULL );
+
+    ConstReferenceMethod( pointer1 );
+    ReferenceMethod( pointer2 );
+    CPPUNIT_ASSERT( pointer2.get() == NULL );
+
+    ReturnByValue();
+
+    {
+        ArrayPointer<TestClassA> copy = ReturnByValue();
+        CPPUNIT_ASSERT( copy.get() != NULL );
+    }
+
+    {
+        ArrayPointer<TestClassA> copy = ReturnByConstReference();
+        CPPUNIT_ASSERT( copy.get() != NULL );
+    }
+
+    ReturnByConstReference();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ArrayPointerTest::testComparisons() {
+
+    const std::size_t SIZE = 50;
+
+    ArrayPointer<TestClassBase> pointer1( new TestClassA[SIZE], SIZE );
+    ArrayPointer<TestClassBase> pointer2( new TestClassB[SIZE], SIZE );
+
+    TestClassA* raw1 = new TestClassA[SIZE];
+
+    CPPUNIT_ASSERT( ( pointer1 == pointer2 ) == false );
+    CPPUNIT_ASSERT( ( pointer1 != pointer2 ) == true );
+
+    CPPUNIT_ASSERT( ( pointer1 == raw1 ) == false );
+    CPPUNIT_ASSERT( ( pointer1 != raw1 ) == true );
+    CPPUNIT_ASSERT( ( raw1 == pointer2 ) == false );
+    CPPUNIT_ASSERT( ( raw1 != pointer2 ) == true );
+
+    delete [] raw1;
+
+    ArrayPointer<TestClassBase> pointer3( new TestClassA[SIZE], SIZE );
+    ArrayPointer<TestClassA> pointer4( 1 );
+
+    CPPUNIT_ASSERT( ( pointer3 == pointer4 ) == false );
+    CPPUNIT_ASSERT( ( pointer3 != pointer4 ) == true );
+
+    CPPUNIT_ASSERT( pointer1 != NULL );
+    CPPUNIT_ASSERT( !pointer1 == false );
+    CPPUNIT_ASSERT( !!pointer1 == true );
+
+    // This won't compile which is correct.
+    //ArrayPointer<TestClassB> pointer5( 1 );
+    //ArrayPointer<TestClassA> pointer6( 1 );
+    //CPPUNIT_ASSERT( pointer5 != pointer6 );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+namespace {
+    class ArrayPointerTestRunnable : public decaf::lang::Runnable {
+    private:
+
+        ArrayPointer<TestClassA> mine;
+
+    public:
+
+        ArrayPointerTestRunnable( const ArrayPointer<TestClassA>& value ) : mine( value ) {}
+
+        void run() {
+
+            for( int i = 0; i < 999; ++i ) {
+                ArrayPointer<TestClassA> copy = this->mine;
+                CPPUNIT_ASSERT( copy[0].returnHello() == "Hello" );
+                copy.reset( new TestClassA[1], 1 );
+                CPPUNIT_ASSERT( copy[0].returnHello() == "Hello" );
+            }
+        }
+    };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ArrayPointerTest::testThreaded1() {
+    ArrayPointer<TestClassA> pointer( 10 );
+
+    ArrayPointerTestRunnable runnable( pointer );
+    Thread testThread( &runnable );
+
+    testThread.start();
+
+    for( int i = 0; i < 999; ++i ) {
+        ArrayPointer<TestClassA> copy = pointer;
+        CPPUNIT_ASSERT( copy[0].returnHello() == "Hello" );
+        Thread::yield();
+        copy.reset( new TestClassA[1], 1 );
+        CPPUNIT_ASSERT( copy[0].returnHello() == "Hello" );
+    }
+
+    testThread.join();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ArrayPointerTest::testThreaded2() {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ArrayPointerTest::testOperators() {
+
+    ArrayPointer<TestClassBase*> pointer1( 1 );
+    ArrayPointer<TestClassBase*> pointer2( 1 );
+    ArrayPointer<TestClassB> pointer3;
+
+    pointer1[0] = new TestClassA;
+    pointer2[0] = new TestClassB;
+
+    CPPUNIT_ASSERT( pointer1[0]->returnHello() == "Hello" );
+    CPPUNIT_ASSERT( pointer2[0]->returnHello() == "GoodBye" );
+
+    CPPUNIT_ASSERT_THROW_MESSAGE(
+        "operator[] with bigger index than the array size should throw an IndexOutOfBoundsException",
+        pointer2[1]->returnHello(),
+        decaf::lang::exceptions::IndexOutOfBoundsException );
+    CPPUNIT_ASSERT_THROW_MESSAGE(
+        "operator[] on a NULL Should Throw a NullPointerException",
+        pointer3[0].returnHello(),
+        decaf::lang::exceptions::NullPointerException );
+
+    delete pointer1[0];
+    delete pointer2[0];
+
+    pointer1[0] = NULL;
+    pointer2[0] = NULL;
+
+    pointer2.reset( NULL );
+
+    CPPUNIT_ASSERT_THROW_MESSAGE(
+        "operator[] on a NULL Should Throw a NullPointerException",
+        pointer2[0]->returnHello(),
+        decaf::lang::exceptions::NullPointerException );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ArrayPointerTest::testSTLContainers() {
+
+    ArrayPointer<TestClassA> pointer1( 1 );
+    ArrayPointer<TestClassA> pointer2( 1 );
+    ArrayPointer<TestClassA> pointer3( pointer2 );
+
+    CPPUNIT_ASSERT( pointer1.get() != NULL );
+    CPPUNIT_ASSERT( pointer2.get() != NULL );
+
+    std::map< ArrayPointer<TestClassA>, std::string > testMap;
+
+    testMap.insert( std::make_pair( pointer1, "Bob" ) );
+    testMap.insert( std::make_pair( pointer2, "Steve" ) );
+    testMap.insert( std::make_pair( pointer3, "Steve" ) );
+
+    // Two and Three should be equivalent (not equal) but in this case
+    // equivalent is what matters.  So pointer2 should be bumped out of the map.
+    CPPUNIT_ASSERT( testMap.size() == 2 );
+
+    testMap.insert( std::make_pair( ArrayPointer<TestClassA>( new TestClassA[4], 4 ), "Fred" ) );
+
+    CPPUNIT_ASSERT( testMap.find( pointer1 ) != testMap.end() );
+    CPPUNIT_ASSERT( testMap.find( pointer2 ) != testMap.end() );
+
+    ArrayPointer< int > one( 1 );
+    ArrayPointer< int > two( 1 );
+    ArrayPointer< int > three( 1 );
+
+    one[0] = 1;
+    two[0] = 2;
+    three[0] = 3;
+
+    std::map< ArrayPointer<int>, int, ArrayPointerComparator<int> > testMap2;
+
+    CPPUNIT_ASSERT( testMap2.size() == 0 );
+    testMap2.insert( std::make_pair( three, 3 ) );
+    testMap2.insert( std::make_pair( two, 2 ) );
+    testMap2.insert( std::make_pair( one, 1 ) );
+    CPPUNIT_ASSERT( testMap2.size() == 3 );
+    CPPUNIT_ASSERT( testMap2.begin()->first.get() < testMap2.rbegin()->first.get() );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ArrayPointerTest::testReturnByValue() {
+    ArrayPointer<TestClassA> result = methodReturnArrayPointer();
+    CPPUNIT_ASSERT( result.get() != NULL );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+namespace {
+
+    class Gate {
+    private:
+
+        CountDownLatch * enter_latch;
+        CountDownLatch * leave_latch;
+        Mutex mutex;
+        bool closed;
+
+    public:
+
+        Gate() : closed( true ) {}
+        virtual ~Gate() {}
+
+        void open( int count ) {
+            leave_latch = new CountDownLatch( count );
+            enter_latch = new CountDownLatch( count );
+            mutex.lock();
+            closed = false;
+            mutex.notifyAll();
+            mutex.unlock();
+        }
+
+        void enter() {
+            mutex.lock();
+            while( closed )
+                mutex.wait();
+            enter_latch->countDown();
+            if( enter_latch->await( 0 ) ) {
+                closed = true;
+            }
+            mutex.unlock();
+        }
+
+        void leave() {
+            leave_latch->countDown();
+        }
+
+        void close() {
+            leave_latch->await();
+            delete leave_latch;
+            delete enter_latch;
+        }
+    };
+
+    class ArrayPointerTestThread: public Thread {
+    private:
+
+        Gate *_gate;
+        ArrayPointer<std::string> _s;
+
+    public:
+
+        ArrayPointerTestThread( Gate *gate ) : _gate( gate ) {}
+        virtual ~ArrayPointerTestThread() {}
+
+        void setString( ArrayPointer<std::string> s ) {
+            _s = s;
+        }
+
+        virtual void run() {
+            for( int j = 0; j < 1000; j++ ) {
+                _gate->enter();
+                _s.reset( NULL );
+                _gate->leave();
+            }
+        }
+    };
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ArrayPointerTest::testThreadSafety() {
+
+    ArrayPointer<ArrayPointerTestThread*> thread( 10 );
+    Gate gate;
+
+    for( int i = 0; i < 10; i++ ) {
+        thread[i] = new ArrayPointerTestThread( &gate );
+        thread[i]->start();
+    }
+
+    for( int j = 0; j < 1000; j++ ) {
+        // Put this in its own scope so that the main thread frees the string
+        // before the threads.
+        {
+            ArrayPointer<std::string> s( 1 );
+            for( int i = 0; i < 10; i++ ) {
+                thread[i]->setString( s );
+            }
+        }
+
+        // Signal the threads to free the string.
+        gate.open( 10 );
+        gate.close();
+    }
+
+    for( int i = 0; i < 10; i++ ) {
+        thread[i]->join();
+        delete thread[i];
+    }
+}

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.cpp
------------------------------------------------------------------------------
    svn:executable = *

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.h?rev=922020&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.h (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.h Thu Mar 11 21:04:38 2010
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _DECAF_LANG_ARRAYPOINTERTEST_H_
+#define _DECAF_LANG_ARRAYPOINTERTEST_H_
+
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+namespace decaf {
+namespace lang {
+
+    class ArrayPointerTest : public CppUnit::TestFixture {
+
+        CPPUNIT_TEST_SUITE( ArrayPointerTest );
+        CPPUNIT_TEST( testBasics );
+        CPPUNIT_TEST( testAssignment );
+        CPPUNIT_TEST( testComparisons );
+        CPPUNIT_TEST( testThreaded1 );
+        CPPUNIT_TEST( testThreaded2 );
+        CPPUNIT_TEST( testOperators );
+        CPPUNIT_TEST( testSTLContainers );
+        CPPUNIT_TEST( testReturnByValue );
+        CPPUNIT_TEST( testThreadSafety );
+        CPPUNIT_TEST_SUITE_END();
+
+    public:
+
+        ArrayPointerTest() {}
+        virtual ~ArrayPointerTest() {}
+
+        void testBasics();
+        void testAssignment();
+        void testComparisons();
+        void testThreaded1();
+        void testThreaded2();
+        void testOperators();
+        void testSTLContainers();
+        void testReturnByValue();
+        void testThreadSafety();
+
+    };
+
+}}
+
+#endif /*_DECAF_LANG_ARRAYPOINTERTEST_H_*/

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.h
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/ArrayPointerTest.h
------------------------------------------------------------------------------
    svn:executable = *

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.cpp?rev=922020&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.cpp (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.cpp Thu Mar 11 21:04:38 2010
@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "StringTest.h"
+
+#include <decaf/lang/String.h>
+
+using namespace std;
+using namespace decaf;
+using namespace decaf::lang;
+
+////////////////////////////////////////////////////////////////////////////////
+StringTest::StringTest() {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+StringTest::~StringTest() {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void StringTest::test() {
+}

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.h?rev=922020&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.h (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.h Thu Mar 11 21:04:38 2010
@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _DECAF_LANG_STRINGTEST_H_
+#define _DECAF_LANG_STRINGTEST_H_
+
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+namespace decaf {
+namespace lang {
+
+    class StringTest : public CppUnit::TestFixture
+    {
+        CPPUNIT_TEST_SUITE( StringTest );
+        CPPUNIT_TEST( test );
+        CPPUNIT_TEST_SUITE_END();
+
+    public:
+
+        StringTest();
+
+        virtual ~StringTest();
+
+        void test();
+
+    };
+
+}}
+
+#endif /* _DECAF_LANG_STRINGTEST_H_ */

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/lang/StringTest.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp?rev=922020&r1=922019&r2=922020&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp Thu Mar 11 21:04:38 2010
@@ -18,287 +18,291 @@
 // All CPP Unit tests are registered in here so we can disable them and
 // enable them easily in one place.
 
-#include <activemq/commands/BrokerInfoTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::BrokerInfoTest );
-#include <activemq/commands/BrokerIdTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::BrokerIdTest );
-#include <activemq/commands/ActiveMQTopicTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQTopicTest );
-#include <activemq/commands/ActiveMQTextMessageTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQTextMessageTest );
-#include <activemq/commands/ActiveMQTempTopicTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQTempTopicTest );
-#include <activemq/commands/ActiveMQTempQueueTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQTempQueueTest );
-#include <activemq/commands/ActiveMQQueueTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQQueueTest );
-#include <activemq/commands/ActiveMQMessageTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQMessageTest );
-#include <activemq/commands/ActiveMQMapMessageTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQMapMessageTest );
-#include <activemq/commands/ActiveMQDestinationTest2.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQDestinationTest );
-#include <activemq/commands/ActiveMQBytesMessageTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQBytesMessageTest );
-#include <activemq/commands/ActiveMQStreamMessageTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQStreamMessageTest );
-
-#include <activemq/wireformat/openwire/marshal/BaseDataStreamMarshallerTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::marshal::BaseDataStreamMarshallerTest );
-#include <activemq/wireformat/openwire/marshal/PrimitiveTypesMarshallerTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::marshal::PrimitiveTypesMarshallerTest );
-
-#include <activemq/wireformat/openwire/utils/BooleanStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::utils::BooleanStreamTest );
-#include <activemq/wireformat/openwire/utils/HexTableTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::utils::HexTableTest );
-#include <activemq/wireformat/openwire/utils/OpenwireStringSupportTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::utils::OpenwireStringSupportTest );
-#include <activemq/wireformat/openwire/utils/MessagePropertyInterceptorTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::utils::MessagePropertyInterceptorTest );
-
-#include <activemq/wireformat/openwire/OpenWireFormatTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::OpenWireFormatTest );
-
-#include <activemq/cmsutil/CmsAccessorTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::cmsutil::CmsAccessorTest );
-#include <activemq/cmsutil/CmsDestinationAccessorTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::cmsutil::CmsDestinationAccessorTest );
-#include <activemq/cmsutil/CmsTemplateTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::cmsutil::CmsTemplateTest );
-#include <activemq/cmsutil/DynamicDestinationResolverTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::cmsutil::DynamicDestinationResolverTest );
-#include <activemq/cmsutil/SessionPoolTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::cmsutil::SessionPoolTest );
-
-#include <activemq/core/ActiveMQConnectionFactoryTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::core::ActiveMQConnectionFactoryTest );
-#include <activemq/core/ActiveMQConnectionTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::core::ActiveMQConnectionTest );
-#include <activemq/core/ActiveMQSessionTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::core::ActiveMQSessionTest );
-#include <activemq/core/MessageDispatchChannelTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::core::MessageDispatchChannelTest );
-
-#include <activemq/state/ConnectionStateTrackerTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::ConnectionStateTrackerTest );
-#include <activemq/state/ConnectionStateTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::ConnectionStateTest );
-#include <activemq/state/ConsumerStateTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::ConsumerStateTest );
-#include <activemq/state/ProducerStateTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::ProducerStateTest );
-#include <activemq/state/SessionStateTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::SessionStateTest );
-#include <activemq/state/TransactionStateTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::TransactionStateTest );
-
-#include <activemq/transport/failover/FailoverTransportTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::failover::FailoverTransportTest );
-
-#include <activemq/transport/correlator/ResponseCorrelatorTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::correlator::ResponseCorrelatorTest );
-
-#include <activemq/transport/mock/MockTransportFactoryTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::mock::MockTransportFactoryTest );
-
-#include <activemq/transport/inactivity/InactivityMonitorTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::inactivity::InactivityMonitorTest );
-
-#include <activemq/transport/TransportRegistryTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::TransportRegistryTest );
-#include <activemq/transport/IOTransportTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::IOTransportTest );
-
-#include <activemq/exceptions/ActiveMQExceptionTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::exceptions::ActiveMQExceptionTest );
-
-#include <activemq/util/LongSequenceGeneratorTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::LongSequenceGeneratorTest );
-#include <activemq/util/PrimitiveValueNodeTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::PrimitiveValueNodeTest );
-#include <activemq/util/PrimitiveListTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::PrimitiveListTest );
-#include <activemq/util/PrimitiveMapTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::PrimitiveMapTest );
-#include <activemq/util/PrimitiveValueConverterTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::PrimitiveValueConverterTest );
-#include <activemq/util/URISupportTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::URISupportTest );
-#include <activemq/util/MemoryUsageTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::MemoryUsageTest );
-
-#include <activemq/threads/DedicatedTaskRunnerTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::threads::DedicatedTaskRunnerTest );
-#include <activemq/threads/CompositeTaskRunnerTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::threads::CompositeTaskRunnerTest );
-
-#include <activemq/wireformat/WireFormatRegistryTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::WireFormatRegistryTest );
-
-#include <decaf/internal/util/ByteArrayAdapterTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::util::ByteArrayAdapterTest );
-#include <decaf/internal/util/TimerTaskHeapTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::util::TimerTaskHeapTest );
-
-#include <decaf/internal/nio/ByteArrayPerspectiveTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::ByteArrayPerspectiveTest );
-#include <decaf/internal/nio/ByteArrayBufferTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::ByteArrayBufferTest );
-#include <decaf/internal/nio/BufferFactoryTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::BufferFactoryTest );
-#include <decaf/internal/nio/CharArrayBufferTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::CharArrayBufferTest );
-#include <decaf/internal/nio/DoubleArrayBufferTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::DoubleArrayBufferTest );
-#include <decaf/internal/nio/FloatArrayBufferTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::FloatArrayBufferTest );
-#include <decaf/internal/nio/LongArrayBufferTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::LongArrayBufferTest );
-#include <decaf/internal/nio/IntArrayBufferTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::IntArrayBufferTest );
-#include <decaf/internal/nio/ShortArrayBufferTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::ShortArrayBufferTest );
-
-#include <decaf/internal/net/URIEncoderDecoderTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::net::URIEncoderDecoderTest );
-#include <decaf/internal/net/URIHelperTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::net::URIHelperTest );
-
-#include <decaf/nio/BufferTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::nio::BufferTest );
-
-#include <decaf/io/InputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::InputStreamTest );
-#include <decaf/io/OutputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::OutputStreamTest );
-#include <decaf/io/FilterInputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::FilterInputStreamTest );
-#include <decaf/io/FilterOutputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::FilterOutputStreamTest );
-#include <decaf/io/BufferedInputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::BufferedInputStreamTest );
-#include <decaf/io/BufferedOutputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::BufferedOutputStreamTest );
-#include <decaf/io/ByteArrayInputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::ByteArrayInputStreamTest );
-#include <decaf/io/ByteArrayOutputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::ByteArrayOutputStreamTest );
-#include <decaf/io/PushbackInputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::PushbackInputStreamTest );
-#include <decaf/io/DataInputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::DataInputStreamTest );
-#include <decaf/io/DataOutputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::DataOutputStreamTest );
-#include <decaf/io/WriterTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::WriterTest );
-#include <decaf/io/ReaderTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::ReaderTest );
-#include <decaf/io/OutputStreamWriterTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::OutputStreamWriterTest );
-#include <decaf/io/InputStreamReaderTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::InputStreamReaderTest );
-
-#include <decaf/lang/MathTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::MathTest );
-#include <decaf/lang/ByteTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::ByteTest );
-#include <decaf/lang/CharacterTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::CharacterTest );
-#include <decaf/lang/BooleanTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::BooleanTest );
-#include <decaf/lang/ShortTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::ShortTest );
-#include <decaf/lang/IntegerTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::IntegerTest );
-#include <decaf/lang/LongTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::LongTest );
-#include <decaf/lang/FloatTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::FloatTest );
-#include <decaf/lang/DoubleTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::DoubleTest );
-#include <decaf/lang/ExceptionTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::ExceptionTest );
-#include <decaf/lang/ThreadTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::ThreadTest );
-#include <decaf/lang/SystemTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::SystemTest );
+//#include <activemq/commands/BrokerInfoTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::BrokerInfoTest );
+//#include <activemq/commands/BrokerIdTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::BrokerIdTest );
+//#include <activemq/commands/ActiveMQTopicTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQTopicTest );
+//#include <activemq/commands/ActiveMQTextMessageTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQTextMessageTest );
+//#include <activemq/commands/ActiveMQTempTopicTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQTempTopicTest );
+//#include <activemq/commands/ActiveMQTempQueueTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQTempQueueTest );
+//#include <activemq/commands/ActiveMQQueueTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQQueueTest );
+//#include <activemq/commands/ActiveMQMessageTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQMessageTest );
+//#include <activemq/commands/ActiveMQMapMessageTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQMapMessageTest );
+//#include <activemq/commands/ActiveMQDestinationTest2.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQDestinationTest );
+//#include <activemq/commands/ActiveMQBytesMessageTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQBytesMessageTest );
+//#include <activemq/commands/ActiveMQStreamMessageTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::commands::ActiveMQStreamMessageTest );
+//
+//#include <activemq/wireformat/openwire/marshal/BaseDataStreamMarshallerTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::marshal::BaseDataStreamMarshallerTest );
+//#include <activemq/wireformat/openwire/marshal/PrimitiveTypesMarshallerTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::marshal::PrimitiveTypesMarshallerTest );
+//
+//#include <activemq/wireformat/openwire/utils/BooleanStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::utils::BooleanStreamTest );
+//#include <activemq/wireformat/openwire/utils/HexTableTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::utils::HexTableTest );
+//#include <activemq/wireformat/openwire/utils/OpenwireStringSupportTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::utils::OpenwireStringSupportTest );
+//#include <activemq/wireformat/openwire/utils/MessagePropertyInterceptorTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::utils::MessagePropertyInterceptorTest );
+//
+//#include <activemq/wireformat/openwire/OpenWireFormatTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::openwire::OpenWireFormatTest );
+//
+//#include <activemq/cmsutil/CmsAccessorTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::cmsutil::CmsAccessorTest );
+//#include <activemq/cmsutil/CmsDestinationAccessorTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::cmsutil::CmsDestinationAccessorTest );
+//#include <activemq/cmsutil/CmsTemplateTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::cmsutil::CmsTemplateTest );
+//#include <activemq/cmsutil/DynamicDestinationResolverTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::cmsutil::DynamicDestinationResolverTest );
+//#include <activemq/cmsutil/SessionPoolTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::cmsutil::SessionPoolTest );
+//
+//#include <activemq/core/ActiveMQConnectionFactoryTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::core::ActiveMQConnectionFactoryTest );
+//#include <activemq/core/ActiveMQConnectionTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::core::ActiveMQConnectionTest );
+//#include <activemq/core/ActiveMQSessionTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::core::ActiveMQSessionTest );
+//#include <activemq/core/MessageDispatchChannelTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::core::MessageDispatchChannelTest );
+//
+//#include <activemq/state/ConnectionStateTrackerTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::ConnectionStateTrackerTest );
+//#include <activemq/state/ConnectionStateTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::ConnectionStateTest );
+//#include <activemq/state/ConsumerStateTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::ConsumerStateTest );
+//#include <activemq/state/ProducerStateTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::ProducerStateTest );
+//#include <activemq/state/SessionStateTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::SessionStateTest );
+//#include <activemq/state/TransactionStateTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::state::TransactionStateTest );
+//
+//#include <activemq/transport/failover/FailoverTransportTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::failover::FailoverTransportTest );
+//
+//#include <activemq/transport/correlator/ResponseCorrelatorTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::correlator::ResponseCorrelatorTest );
+//
+//#include <activemq/transport/mock/MockTransportFactoryTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::mock::MockTransportFactoryTest );
+//
+//#include <activemq/transport/inactivity/InactivityMonitorTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::inactivity::InactivityMonitorTest );
+//
+//#include <activemq/transport/TransportRegistryTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::TransportRegistryTest );
+//#include <activemq/transport/IOTransportTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::transport::IOTransportTest );
+//
+//#include <activemq/exceptions/ActiveMQExceptionTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::exceptions::ActiveMQExceptionTest );
+//
+//#include <activemq/util/LongSequenceGeneratorTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::LongSequenceGeneratorTest );
+//#include <activemq/util/PrimitiveValueNodeTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::PrimitiveValueNodeTest );
+//#include <activemq/util/PrimitiveListTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::PrimitiveListTest );
+//#include <activemq/util/PrimitiveMapTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::PrimitiveMapTest );
+//#include <activemq/util/PrimitiveValueConverterTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::PrimitiveValueConverterTest );
+//#include <activemq/util/URISupportTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::URISupportTest );
+//#include <activemq/util/MemoryUsageTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::util::MemoryUsageTest );
+//
+//#include <activemq/threads/DedicatedTaskRunnerTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::threads::DedicatedTaskRunnerTest );
+//#include <activemq/threads/CompositeTaskRunnerTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::threads::CompositeTaskRunnerTest );
+//
+//#include <activemq/wireformat/WireFormatRegistryTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( activemq::wireformat::WireFormatRegistryTest );
+//
+//#include <decaf/internal/util/ByteArrayAdapterTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::util::ByteArrayAdapterTest );
+//#include <decaf/internal/util/TimerTaskHeapTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::util::TimerTaskHeapTest );
+//
+//#include <decaf/internal/nio/ByteArrayPerspectiveTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::ByteArrayPerspectiveTest );
+//#include <decaf/internal/nio/ByteArrayBufferTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::ByteArrayBufferTest );
+//#include <decaf/internal/nio/BufferFactoryTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::BufferFactoryTest );
+//#include <decaf/internal/nio/CharArrayBufferTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::CharArrayBufferTest );
+//#include <decaf/internal/nio/DoubleArrayBufferTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::DoubleArrayBufferTest );
+//#include <decaf/internal/nio/FloatArrayBufferTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::FloatArrayBufferTest );
+//#include <decaf/internal/nio/LongArrayBufferTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::LongArrayBufferTest );
+//#include <decaf/internal/nio/IntArrayBufferTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::IntArrayBufferTest );
+//#include <decaf/internal/nio/ShortArrayBufferTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::nio::ShortArrayBufferTest );
+//
+//#include <decaf/internal/net/URIEncoderDecoderTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::net::URIEncoderDecoderTest );
+//#include <decaf/internal/net/URIHelperTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::internal::net::URIHelperTest );
+//
+//#include <decaf/nio/BufferTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::nio::BufferTest );
+//
+//#include <decaf/io/InputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::InputStreamTest );
+//#include <decaf/io/OutputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::OutputStreamTest );
+//#include <decaf/io/FilterInputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::FilterInputStreamTest );
+//#include <decaf/io/FilterOutputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::FilterOutputStreamTest );
+//#include <decaf/io/BufferedInputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::BufferedInputStreamTest );
+//#include <decaf/io/BufferedOutputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::BufferedOutputStreamTest );
+//#include <decaf/io/ByteArrayInputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::ByteArrayInputStreamTest );
+//#include <decaf/io/ByteArrayOutputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::ByteArrayOutputStreamTest );
+//#include <decaf/io/PushbackInputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::PushbackInputStreamTest );
+//#include <decaf/io/DataInputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::DataInputStreamTest );
+//#include <decaf/io/DataOutputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::DataOutputStreamTest );
+//#include <decaf/io/WriterTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::WriterTest );
+//#include <decaf/io/ReaderTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::ReaderTest );
+//#include <decaf/io/OutputStreamWriterTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::OutputStreamWriterTest );
+//#include <decaf/io/InputStreamReaderTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::io::InputStreamReaderTest );
+//
+//#include <decaf/lang/MathTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::MathTest );
+//#include <decaf/lang/ByteTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::ByteTest );
+//#include <decaf/lang/CharacterTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::CharacterTest );
+//#include <decaf/lang/BooleanTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::BooleanTest );
+//#include <decaf/lang/ShortTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::ShortTest );
+//#include <decaf/lang/IntegerTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::IntegerTest );
+//#include <decaf/lang/LongTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::LongTest );
+//#include <decaf/lang/FloatTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::FloatTest );
+//#include <decaf/lang/DoubleTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::DoubleTest );
+//#include <decaf/lang/ExceptionTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::ExceptionTest );
+//#include <decaf/lang/ThreadTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::ThreadTest );
+//#include <decaf/lang/SystemTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::SystemTest );
 #include <decaf/lang/PointerTest.h>
 CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::PointerTest );
-
-#include <decaf/net/SocketFactoryTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::SocketFactoryTest );
-#include <decaf/net/SocketTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::SocketTest );
-#include <decaf/net/URITest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::URITest );
-#include <decaf/net/URISyntaxExceptionTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::URISyntaxExceptionTest );
-#include <decaf/net/URLEncoderTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::URLEncoderTest );
-#include <decaf/net/URLDecoderTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::URLDecoderTest );
-
-#include <decaf/util/concurrent/ConcurrentStlMapTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::ConcurrentStlMapTest );
-#include <decaf/util/concurrent/CountDownLatchTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::CountDownLatchTest );
-#include <decaf/util/concurrent/MutexTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::MutexTest );
-#include <decaf/util/concurrent/ThreadPoolTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::ThreadPoolTest );
-#include <decaf/util/concurrent/TimeUnitTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::TimeUnitTest );
-
-#include <decaf/util/concurrent/atomic/AtomicBooleanTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::atomic::AtomicBooleanTest );
-#include <decaf/util/concurrent/atomic/AtomicIntegerTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::atomic::AtomicIntegerTest );
-#include <decaf/util/concurrent/atomic/AtomicReferenceTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::atomic::AtomicReferenceTest );
-
-#include <decaf/util/concurrent/locks/LockSupportTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::locks::LockSupportTest );
-
-#include <decaf/util/DateTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::DateTest );
-#include <decaf/util/UUIDTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::UUIDTest );
-#include <decaf/util/ListTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::ListTest );
-#include <decaf/util/StlMapTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::StlMapTest );
-#include <decaf/util/PropertiesTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::PropertiesTest );
-#include <decaf/util/QueueTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::QueueTest );
-#include <decaf/util/RandomTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::RandomTest );
-#include <decaf/util/SetTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::SetTest );
-#include <decaf/util/StringTokenizerTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::StringTokenizerTest );
-#include <decaf/util/TimerTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::TimerTest );
-#include <decaf/util/PriorityQueueTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::PriorityQueueTest );
-
-#include <decaf/util/zip/DeflaterTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::DeflaterTest );
-#include <decaf/util/zip/InflaterTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::InflaterTest );
-#include <decaf/util/zip/Adler32Test.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::Adler32Test );
-#include <decaf/util/zip/CRC32Test.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::CRC32Test );
-#include <decaf/util/zip/CheckedInputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::CheckedInputStreamTest );
-#include <decaf/util/zip/CheckedOutputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::CheckedOutputStreamTest );
-#include <decaf/util/zip/DeflaterOutputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::DeflaterOutputStreamTest );
-#include <decaf/util/zip/InflaterInputStreamTest.h>
-CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::InflaterInputStreamTest );
+#include <decaf/lang/ArrayPointerTest.h>
+CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::ArrayPointerTest );
+#include <decaf/lang/StringTest.h>
+CPPUNIT_TEST_SUITE_REGISTRATION( decaf::lang::StringTest );
+
+//#include <decaf/net/SocketFactoryTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::SocketFactoryTest );
+//#include <decaf/net/SocketTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::SocketTest );
+//#include <decaf/net/URITest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::URITest );
+//#include <decaf/net/URISyntaxExceptionTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::URISyntaxExceptionTest );
+//#include <decaf/net/URLEncoderTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::URLEncoderTest );
+//#include <decaf/net/URLDecoderTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::net::URLDecoderTest );
+//
+//#include <decaf/util/concurrent/ConcurrentStlMapTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::ConcurrentStlMapTest );
+//#include <decaf/util/concurrent/CountDownLatchTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::CountDownLatchTest );
+//#include <decaf/util/concurrent/MutexTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::MutexTest );
+//#include <decaf/util/concurrent/ThreadPoolTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::ThreadPoolTest );
+//#include <decaf/util/concurrent/TimeUnitTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::TimeUnitTest );
+//
+//#include <decaf/util/concurrent/atomic/AtomicBooleanTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::atomic::AtomicBooleanTest );
+//#include <decaf/util/concurrent/atomic/AtomicIntegerTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::atomic::AtomicIntegerTest );
+//#include <decaf/util/concurrent/atomic/AtomicReferenceTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::atomic::AtomicReferenceTest );
+//
+//#include <decaf/util/concurrent/locks/LockSupportTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::concurrent::locks::LockSupportTest );
+//
+//#include <decaf/util/DateTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::DateTest );
+//#include <decaf/util/UUIDTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::UUIDTest );
+//#include <decaf/util/ListTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::ListTest );
+//#include <decaf/util/StlMapTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::StlMapTest );
+//#include <decaf/util/PropertiesTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::PropertiesTest );
+//#include <decaf/util/QueueTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::QueueTest );
+//#include <decaf/util/RandomTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::RandomTest );
+//#include <decaf/util/SetTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::SetTest );
+//#include <decaf/util/StringTokenizerTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::StringTokenizerTest );
+//#include <decaf/util/TimerTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::TimerTest );
+//#include <decaf/util/PriorityQueueTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::PriorityQueueTest );
+//
+//#include <decaf/util/zip/DeflaterTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::DeflaterTest );
+//#include <decaf/util/zip/InflaterTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::InflaterTest );
+//#include <decaf/util/zip/Adler32Test.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::Adler32Test );
+//#include <decaf/util/zip/CRC32Test.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::CRC32Test );
+//#include <decaf/util/zip/CheckedInputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::CheckedInputStreamTest );
+//#include <decaf/util/zip/CheckedOutputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::CheckedOutputStreamTest );
+//#include <decaf/util/zip/DeflaterOutputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::DeflaterOutputStreamTest );
+//#include <decaf/util/zip/InflaterInputStreamTest.h>
+//CPPUNIT_TEST_SUITE_REGISTRATION( decaf::util::zip::InflaterInputStreamTest );
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Marshaler Tests



Mime
View raw message