activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r910686 [8/8] - in /activemq/activemq-cpp/trunk/activemq-cpp: ./ src/main/ src/main/decaf/internal/util/zip/ src/main/decaf/util/zip/ src/test/ src/test/decaf/util/zip/
Date Tue, 16 Feb 2010 20:54:11 GMT
Added: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterTest.cpp?rev=910686&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterTest.cpp (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterTest.cpp Tue Feb 16 20:54:08 2010
@@ -0,0 +1,949 @@
+/*
+ * 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 "InflaterTest.h"
+
+#include <decaf/util/zip/Deflater.h>
+#include <decaf/util/zip/Inflater.h>
+#include <decaf/util/zip/Adler32.h>
+#include <decaf/util/zip/CRC32.h>
+
+#include <vector>
+
+using namespace std;
+using namespace decaf;
+using namespace decaf::lang;
+using namespace decaf::lang::exceptions;
+using namespace decaf::util;
+using namespace decaf::util::zip;
+
+////////////////////////////////////////////////////////////////////////////////
+InflaterTest::InflaterTest() {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+InflaterTest::~InflaterTest() {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::setUp() {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::tearDown() {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testEnd() {
+
+    // test method of java.util.zip.inflater.end()
+    unsigned char byteArray[] = { 5, 2, 3, 7, 8 };
+
+    int r = 0;
+    Inflater inflate;
+    inflate.setInput( byteArray, 5, 0, 5 );
+    inflate.end();
+
+    try {
+        inflate.reset();
+        inflate.setInput( byteArray, 5, 0, 5 );
+    } catch( IllegalStateException& e ) {
+        r = 1;
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "inflate can still be used after end is called", 1, r );
+
+    Inflater i;
+    i.end();
+    // check for exception
+    i.end();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testFinished() {
+
+    static const std::size_t SIZE = 10;
+    unsigned char byteArray[] = { 1, 3, 4, 7, 8, 'e', 'r', 't', 'y', '5' };
+
+    std::vector<unsigned char> outPutBuf( 500 );
+    std::vector<unsigned char> outPutInf( 500 );
+
+    Deflater deflater;
+    deflater.setInput( byteArray, SIZE, 0, SIZE );
+    deflater.finish();
+    while( !deflater.finished() ) {
+        deflater.deflate( outPutBuf );
+    }
+
+    Inflater inflate;
+    try {
+
+        while( !( inflate.finished() ) ) {
+            if( inflate.needsInput() ) {
+                inflate.setInput( outPutBuf );
+            }
+
+            inflate.inflate( outPutInf );
+        }
+        CPPUNIT_ASSERT_MESSAGE(
+            "the method finished() returned false when no more data needs to be decompressed",
+            inflate.finished() );
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL( "Invalid input to be decompressed" );
+    }
+
+    for( std::size_t i = 0; i < SIZE; i++ ) {
+        CPPUNIT_ASSERT_MESSAGE( "Final decompressed data does not equal the original data",
+                                byteArray[i] == outPutInf[i] );
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE(
+        "final decompressed data contained more bytes than original - finished()",
+        0, (int)outPutInf[SIZE]);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testGetAdler() {
+
+    static const int DICT_SIZE = 7;
+    static const int ARRAY_SIZE = 15;
+
+    unsigned char dictionary[] = { 'e', 'r', 't', 'a', 'b', 2, 3 };
+    unsigned char byteArray[] = { 4, 5, 3, 2, 'a', 'b', 6, 7, 8, 9, 0, 's', '3', 'w', 'r' };
+    std::vector<unsigned char> outPutBuf( 100 );
+    std::vector<unsigned char> outPutInf( 100 );
+
+    Deflater defl;
+    defl.setDictionary( dictionary, DICT_SIZE, 0, DICT_SIZE );
+
+    defl.setInput( byteArray, ARRAY_SIZE, 0, ARRAY_SIZE );
+    defl.finish();
+    while( !defl.finished() ) {
+        defl.deflate( outPutBuf );
+    }
+    defl.end();
+
+    // getting the checkSum value through the Adler32 class
+    Adler32 adl;
+    adl.update( dictionary, DICT_SIZE, 0, DICT_SIZE );
+    std::size_t checkSumR = adl.getValue();
+
+    Inflater inflateDiction;
+    inflateDiction.setInput( outPutBuf );
+    inflateDiction.inflate( outPutInf );
+
+    CPPUNIT_ASSERT_MESSAGE( "Inflater did not detect the need for a Dictionary",
+                            inflateDiction.needsDictionary() );
+
+    CPPUNIT_ASSERT_MESSAGE(
+        "the checksum value returned by getAdler() is not the same as the checksum returned "
+        "by creating the adler32 instance",
+        checkSumR == inflateDiction.getAdler() );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testGetRemaining() {
+
+    unsigned char byteArray[] = { 1, 3, 5, 6, 7 };
+    Inflater inflate;
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "upon creating an instance of inflate, getRemaining returned a non zero value",
+                                  0, (int)inflate.getRemaining());
+    inflate.setInput( byteArray, 5, 0, 5 );
+    CPPUNIT_ASSERT_MESSAGE(
+        "getRemaining returned zero when there is input in the input buffer",
+        inflate.getRemaining() != 0 );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testInflateVector() {
+
+    static const std::size_t SIZE = 39;
+
+    unsigned char byteArray[] = { 120, -38, 75, -54, 73, -52, 80, 40,
+                                  46, 41, -54, -52, 75, 87, 72, -50,
+                                  -49, 43, 73, -52, -52, 43, 86, 72,
+                                  2, 10, 34, 99, -123, -60, -68, 20,
+                                  -80, 32, 0, -101, -69, 17, 84 };
+
+    std::string codedString = "blah string contains blahblahblahblah and blah";
+
+    std::vector<unsigned char> outPutBuf( byteArray, byteArray + SIZE );
+    std::vector<unsigned char> outPutInf( 500, 0 );
+
+    Inflater inflate;
+    try {
+        while( !( inflate.finished() ) ) {
+            if( inflate.needsInput() ) {
+                inflate.setInput( outPutBuf );
+            }
+            inflate.inflate( outPutInf );
+        }
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL("Invalid input to be decompressed");
+    }
+
+    for( std::size_t i = 0; i < codedString.length(); i++ ) {
+        CPPUNIT_ASSERT_MESSAGE( "Final decompressed data does not equal the original data",
+                                codedString[i] == outPutInf[i] );
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "final decompressed data contained more bytes than original - inflateB",
+                                  0, (int)outPutInf[codedString.length()] );
+    // testing for an empty input array
+    outPutBuf.clear();
+    outPutBuf.resize( 500 );
+    outPutInf.assign( outPutInf.size(), 0 );
+    std::vector<unsigned char> emptyArray( 11, 0 );
+    std::size_t x = 0;
+    Deflater defEmpty( 3 );
+    defEmpty.setInput( emptyArray );
+    while( !( defEmpty.needsInput() ) ) {
+        x += defEmpty.deflate( outPutBuf, x, outPutBuf.size() - x );
+    }
+    defEmpty.finish();
+    while( !( defEmpty.finished() ) ) {
+        x += defEmpty.deflate( outPutBuf, x, outPutBuf.size() - x );
+    }
+    CPPUNIT_ASSERT_MESSAGE( "the total number of unsigned char from deflate did not equal "
+                            "getTotalOut - inflate(unsigned char)",
+                            x == (std::size_t)defEmpty.getBytesWritten() );
+    CPPUNIT_ASSERT_MESSAGE(
+                "the number of input unsigned char from the array did not correspond with getTotalIn - inflate(unsigned char)",
+                (std::size_t)defEmpty.getBytesRead() == emptyArray.size() );
+    Inflater infEmpty;
+    try {
+        while( !( infEmpty.finished() ) ) {
+            if( infEmpty.needsInput() ) {
+                infEmpty.setInput( outPutBuf );
+            }
+            infEmpty.inflate( outPutInf );
+        }
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL( "Invalid input to be decompressed" );
+    }
+
+    for( std::size_t i = 0; i < 11; i++ ) {
+        CPPUNIT_ASSERT_MESSAGE( "Final decompressed data does not equal the original data",
+                                emptyArray[i] == outPutInf[i] );
+        CPPUNIT_ASSERT_EQUAL_MESSAGE( "Final decompressed data does not equal zero",
+                                      0, (int)outPutInf[i] );
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "Final decompressed data contains more element than original data",
+                                  0, (int)outPutInf[11] );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testInflateB1() {
+
+    static const std::size_t CODEDATA_SIZE = 39;
+
+    unsigned char codedData[] = { 120, -38, 75, -54, 73, -52, 80, 40,
+                                  46, 41, -54, -52, 75, 87, 72, -50,
+                                  -49, 43, 73, -52, -52, 43, 86, 72,
+                                  2, 10, 34, 99, -123, -60, -68, 20,
+                                  -80, 32, 0, -101, -69, 17, 84 };
+    std::string codedString = "blah string contains blahblahblahblah and blah";
+
+    Inflater infl1;
+    Inflater infl2;
+
+    std::vector<unsigned char> result( 100 );
+    std::size_t decLen = 0;
+
+    infl1.setInput( codedData, CODEDATA_SIZE, 0, CODEDATA_SIZE );
+    try {
+        decLen = infl1.inflate( result );
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL("Unexpected DataFormatException");
+    }
+
+    infl1.end();
+    CPPUNIT_ASSERT_EQUAL( codedString, std::string( result.begin(), result.begin() + decLen ) );
+    codedData[5] = 0;
+
+    infl2.setInput( codedData, CODEDATA_SIZE, 0, CODEDATA_SIZE );
+
+    CPPUNIT_ASSERT_THROW_MESSAGE(
+        "Expected DataFormatException",
+        decLen = infl2.inflate( result ),
+        DataFormatException );
+
+    infl2.end();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testInflateBII() {
+
+    static const std::size_t SIZE = 39;
+
+    unsigned char byteArray[] = { 120, -38, 75, -54, 73, -52, 80, 40,
+                                  46, 41, -54, -52, 75, 87, 72, -50,
+                                  -49, 43, 73, -52, -52, 43, 86, 72,
+                                  2, 10, 34, 99, -123, -60, -68, 20,
+                                  -80, 32, 0, -101, -69, 17, 84 };
+
+    std::string codedString = "blah string contains blahblahblahblah and blah";
+
+    std::vector<unsigned char> outPutBuf( byteArray, byteArray + SIZE );
+    std::vector<unsigned char> outPutInf( 100 );
+    std::size_t y = 0;
+    Inflater inflate;
+    try {
+        while( !( inflate.finished() ) ) {
+            if( inflate.needsInput() ) {
+                inflate.setInput( outPutBuf );
+            }
+            y += inflate.inflate( outPutInf, y, outPutInf.size() - y );
+        }
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL("Invalid input to be decompressed");
+    }
+    for( std::size_t i = 0; i < codedString.length(); i++ ) {
+        CPPUNIT_ASSERT_MESSAGE(
+                        "Final decompressed data does not equal the original data",
+                        codedString[i] == outPutInf[i]);
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "final decompressed data contained more bytes than original - inflateB",
+                                  0, (int)outPutInf[codedString.length()]);
+
+    // test boundary checks
+    inflate.reset();
+    int r = 0;
+    std::size_t offSet = 0;
+    std::size_t lengthError = 101;
+    try {
+        if( inflate.needsInput() ) {
+            inflate.setInput( outPutBuf );
+        }
+        inflate.inflate( outPutInf, offSet, lengthError );
+
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL("Invalid input to be decompressed");
+    } catch( IndexOutOfBoundsException& e ) {
+        r = 1;
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "out of bounds error did not get caught", 1, r );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testInflateBII1() {
+
+    static const std::size_t CODEDATA_SIZE = 39;
+    unsigned char codedData[] = { 120, -38, 75, -54, 73, -52, 80, 40, 46, 41, -54, -52, 75,
+                                  87, 72, -50, -49, 43, 73, -52, -52, 43, 86, 72, 2, 10,
+                                  34, 99, -123, -60, -68, 20, -80, 32, 0, -101, -69, 17, 84 };
+
+    std::string codedString = "blah string";
+
+    Inflater infl1;
+    Inflater infl2;
+
+    std::vector<unsigned char> result( 100 );
+    std::size_t decLen = 0;
+
+    infl1.setInput( codedData, CODEDATA_SIZE, 0, CODEDATA_SIZE );
+    try {
+        decLen = infl1.inflate( result, 10, 11 );
+        CPPUNIT_ASSERT( decLen != 0 );
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL("Unexpected DataFormatException");
+    }
+
+    std::string outputStr;
+    for( std::size_t ix = 10; ix < decLen + 10; ++ix ) {
+        outputStr += (char)result[ix];
+    }
+
+    infl1.end();
+    CPPUNIT_ASSERT_EQUAL( codedString, outputStr );
+    codedData[5] = 0;
+
+    infl2.setInput( codedData, CODEDATA_SIZE, 0, CODEDATA_SIZE );
+    CPPUNIT_ASSERT_THROW_MESSAGE(
+        "Expected DataFormatException",
+        decLen = infl2.inflate( result, 10, 11 ),
+        DataFormatException );
+
+    infl2.end();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testConstructor() {
+
+    Inflater inflate;
+    CPPUNIT_ASSERT_MESSAGE( "failed to create the instance of inflater",
+                            inflate.getBytesRead() == 0LL );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testConstructorZ() {
+
+    static const std::size_t SIZE = 10;
+
+    // note does not throw exception if deflater has a header, but inflater
+    // doesn't or vice versa.
+    unsigned char byteArray[] = { 1, 3, 4, 7, 8, 'e', 'r', 't', 'y', '5' };
+    std::vector<unsigned char> outPutBuf( 500 );
+
+    Deflater deflater;
+
+    deflater.setInput( byteArray, SIZE, 0, SIZE );
+    deflater.finish();
+
+    std::size_t read = 0;
+    while( !deflater.finished() ) {
+        read = deflater.deflate( outPutBuf, read, outPutBuf.size() - read );
+    }
+    deflater.end();
+
+    Inflater inflate( true );
+    std::vector<unsigned char> outPutInf( 500 );
+
+    int r = 0;
+    try {
+
+        while( !( inflate.finished() ) ) {
+
+            if( inflate.needsInput() ) {
+                inflate.setInput( outPutBuf );
+            }
+
+            inflate.inflate( outPutInf );
+        }
+        for( std::size_t i = 0; i < SIZE; i++ ) {
+            CPPUNIT_ASSERT_EQUAL_MESSAGE(
+                "the output array from inflate should contain 0 because the header of inflate "
+                "and deflate did not match, but this failed",
+                0, (int)outPutBuf[i] );
+        }
+    } catch( DataFormatException& e ) {
+        r = 1;
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "Error: exception should be thrown because of header inconsistency", 1, r );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testNeedsDictionary() {
+
+    static const int DICT_SIZE = 7;
+    static const int ARRAY_SIZE = 15;
+
+    // This test is very close to getAdler()
+    std::vector<unsigned char> dictionary( DICT_SIZE );
+    dictionary[0] = 'e';
+    dictionary[1] = 'r';
+    dictionary[2] = 't';
+    dictionary[3] = 'a';
+    dictionary[4] = 'b';
+    dictionary[5] = 2;
+    dictionary[6] = 3;
+
+    unsigned char byteArray[] = { 4, 5, 3, 2, 'a', 'b', 6, 7, 8, 9, 0, 's', '3', 'w', 'r' };
+    std::vector<unsigned char> outPutBuf( 100 );
+
+    Deflater defl;
+    defl.setDictionary( dictionary, 0, DICT_SIZE );
+
+    defl.setInput( byteArray, ARRAY_SIZE, 0, ARRAY_SIZE );
+    defl.finish();
+    while( !defl.finished() ) {
+        defl.deflate( outPutBuf );
+    }
+
+    // note: this flag is set after inflate is called
+    std::vector<unsigned char> outPutInf( 500 );
+
+    // testing with dictionary set.
+    Inflater inflateDiction;
+    if( inflateDiction.needsInput() ) {
+        inflateDiction.setInput( outPutBuf );
+    }
+    try {
+        CPPUNIT_ASSERT_EQUAL_MESSAGE( "should return 0 because needs dictionary",
+                                      0, (int)inflateDiction.inflate( outPutInf ) );
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL("Should not cause exception");
+    }
+    CPPUNIT_ASSERT_MESSAGE(
+        "method needsDictionary returned false when dictionary was used in deflater",
+        inflateDiction.needsDictionary() );
+
+    // Recompress without a Dictionary
+    outPutBuf.assign( outPutBuf.size(), 0 );
+    outPutInf.assign( outPutInf.size(), 0 );
+
+    defl.reset();
+    defl.setInput( byteArray, ARRAY_SIZE, 0, ARRAY_SIZE );
+    defl.finish();
+    while( !defl.finished() ) {
+        defl.deflate( outPutBuf );
+    }
+    defl.end();
+
+    // testing without dictionary
+    Inflater inflate;
+    try {
+        inflate.setInput( outPutBuf );
+        inflate.inflate( outPutInf );
+        CPPUNIT_ASSERT_MESSAGE(
+            "method needsDictionary returned true when dictionary was not used in deflater",
+            !inflate.needsDictionary() );
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL( "Input to inflate is invalid or corrupted - needsDictionary" );
+    }
+
+    Inflater inf;
+    CPPUNIT_ASSERT( !inf.needsDictionary() );
+    CPPUNIT_ASSERT_EQUAL( 0LL, inf.getBytesRead() );
+    CPPUNIT_ASSERT_EQUAL( 0LL, inf.getBytesWritten() );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testNeedsInput() {
+
+    Inflater inflate;
+    CPPUNIT_ASSERT_MESSAGE(
+        "needsInput give the wrong bool value as a result of no input buffer",
+        inflate.needsInput() );
+
+    static const std::size_t SIZE = 12;
+
+    unsigned char byteArray[] = { 2, 3, 4, 't', 'y', 'u', 'e', 'w', 7, 6, 5, 9 };
+    inflate.setInput( byteArray, SIZE, 0, SIZE );
+    CPPUNIT_ASSERT_MESSAGE(
+        "methodNeedsInput returned true when the input buffer is full",
+        !inflate.needsInput() );
+
+    inflate.reset();
+    std::vector<unsigned char> byteArrayEmpty( 0 );;
+    inflate.setInput( byteArrayEmpty );
+    inflate.needsInput();
+    CPPUNIT_ASSERT_MESSAGE(
+        "needsInput give wrong bool value as a result of an empty input buffer",
+        inflate.needsInput() );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testReset() {
+
+    static const std::size_t SIZE = 10;
+
+    // note does not throw exception if deflater has a header, but inflater
+    // doesn't or vice versa.
+    unsigned char byteArray[] = { 1, 3, 4, 7, 8, 'e', 'r', 't', 'y', '5' };
+    std::vector<unsigned char> outPutBuf( 500 );
+
+    Deflater deflater;
+
+    deflater.setInput( byteArray, SIZE, 0, SIZE );
+    deflater.finish();
+
+    std::size_t read = 0;
+    while( !deflater.finished() ) {
+        read = deflater.deflate( outPutBuf, read, outPutBuf.size() - read );
+    }
+    deflater.end();
+
+    std::vector<unsigned char> outPutInf( 100 );
+    std::size_t y = 0;
+    Inflater inflate;
+    try {
+
+        while( !( inflate.finished() ) ) {
+            if( inflate.needsInput() ) {
+                inflate.setInput( outPutBuf );
+            }
+            y += inflate.inflate( outPutInf, y, outPutInf.size() - y );
+        }
+
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL("Invalid input to be decompressed");
+    }
+
+    for( std::size_t i = 0; i < SIZE; i++ ) {
+        CPPUNIT_ASSERT_MESSAGE( "Final decompressed data does not equal the original data",
+                                byteArray[i] == outPutInf[i] );
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "final decompressed data contained more bytes than original - reset",
+                                  0, (int)outPutInf[SIZE] );
+
+    // testing that resetting the inflater will also return the correct
+    // decompressed data
+
+    inflate.reset();
+    try {
+
+        while( !( inflate.finished() ) ) {
+            if( inflate.needsInput() ) {
+                inflate.setInput( outPutBuf );
+            }
+            inflate.inflate( outPutInf );
+        }
+
+    } catch( DataFormatException& e ) {
+        CPPUNIT_FAIL("Invalid input to be decompressed");
+    }
+
+    for( std::size_t i = 0; i < SIZE; i++ ) {
+        CPPUNIT_ASSERT_MESSAGE( "Final decompressed data does not equal the original data",
+                                byteArray[i] == outPutInf[i] );
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "final decompressed data contained more bytes than original - reset",
+                                  0, (int)outPutInf[SIZE]);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testSetInputB() {
+
+    static const std::size_t SIZE = 12;
+    unsigned char byteArray[] = { 2, 3, 4, 't', 'y', 'u', 'e', 'w', 7, 6, 5, 9 };
+    Inflater inflate;
+    inflate.setInput( byteArray, SIZE, 0, SIZE );
+    CPPUNIT_ASSERT_MESSAGE( "setInputB did not deliver any unsigned char to the input buffer",
+                            inflate.getRemaining() != 0 );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testSetInputBIII() {
+
+    static const std::size_t SIZE = 12;
+    unsigned char byteArray[] = { 2, 3, 4, 't', 'y', 'u', 'e', 'w', 7, 6, 5, 9 };
+    std::size_t offSet = 6;
+    std::size_t length = 6;
+
+    Inflater inflate;
+    inflate.setInput( byteArray, SIZE, offSet, length );
+    CPPUNIT_ASSERT_MESSAGE( "setInputBII did not deliver the right number of bytes to the input buffer",
+                            inflate.getRemaining() == length );
+
+    // boundary check
+    inflate.reset();
+    int r = 0;
+    try {
+        inflate.setInput( byteArray, SIZE, 100, 100 );
+    } catch( IndexOutOfBoundsException& e ) {
+        r = 1;
+    }
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "boundary check is not present for setInput", 1, r );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testGetBytesRead() {
+
+    Deflater def;
+    Inflater inf;
+    CPPUNIT_ASSERT_EQUAL( 0LL, def.getBytesWritten() );
+    CPPUNIT_ASSERT_EQUAL( 0LL, def.getBytesRead() );
+
+    // Encode a String into bytes
+    std::string inputString = "blahblahblah??";
+    std::vector<unsigned char> input( inputString.begin(), inputString.end() );
+
+    // Compress the bytes
+    std::vector<unsigned char> output( 100 );
+
+    def.setInput( input );
+    def.finish();
+    def.deflate( output );
+    inf.setInput( output );
+    std::size_t compressedDataLength = inf.inflate( input );
+    CPPUNIT_ASSERT_EQUAL( compressedDataLength, (std::size_t)inf.getBytesWritten() );
+    CPPUNIT_ASSERT_EQUAL( 16LL, inf.getBytesRead() );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testGetBytesWritten() {
+
+    Deflater def;
+    Inflater inf;
+    CPPUNIT_ASSERT_EQUAL( 0LL, def.getBytesRead() );
+    CPPUNIT_ASSERT_EQUAL( 0LL, def.getBytesWritten() );
+
+    // Encode a String into bytes
+    std::string inputString = "blahblahblah??";
+    std::vector<unsigned char> input( inputString.begin(), inputString.end() );
+
+    // Compress the bytes
+    std::vector<unsigned char> output( 100 );
+    def.setInput( input );
+    def.finish();
+    def.deflate( output );
+    inf.setInput( output );
+    std::size_t compressedDataLength = inf.inflate( input );
+    CPPUNIT_ASSERT_EQUAL( 16LL, inf.getBytesRead() );
+    CPPUNIT_ASSERT_EQUAL( compressedDataLength, (std::size_t)inf.getBytesWritten() );
+    CPPUNIT_ASSERT_EQUAL( 14LL, inf.getBytesWritten() );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testInflate() {
+
+    Inflater inf;
+    std::vector<unsigned char> empty(0);
+    std::size_t res = inf.inflate( empty );
+
+    CPPUNIT_ASSERT_EQUAL( 0, (int)res );
+
+    // Regression for HARMONY-2508
+    Inflater inflater;
+    std::vector<unsigned char> b( 1024 );
+    CPPUNIT_ASSERT_EQUAL( 0, (int)inflater.inflate( b ) );
+    inflater.end();
+
+    {
+        Inflater inflater;
+        unsigned char array[] = { -1 };
+        inflater.setInput( array, 1, 0, 1 );
+        try {
+            inflater.inflate( b );
+
+            // The RI detects malformed data on the malformed input { -1 }. Both
+            // this implementation and the native zlib API return "need input"
+            // on that data. This is an error if the stream is exhausted, but
+            // not one that results in an exception in the Inflater API.
+            CPPUNIT_ASSERT( inflater.needsInput() );
+        } catch( DataFormatException& e ) {
+            // expected
+        }
+    }
+
+    {
+        Inflater inflater2;
+        unsigned char array[] = { -1, -1, -1 };
+        inflater2.setInput( array, 3, 0, 3);
+        try {
+            inflater2.inflate( b );
+        } catch( DataFormatException& e ) {
+            // expected
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testSetDictionaryB() {
+
+    std::size_t i = 0;
+    std::string inputString = "blah string contains blahblahblahblah and blah";
+    std::vector<unsigned char> input( inputString.begin(), inputString.end() );
+    std::string dictionary1String = "blah";
+    std::vector<unsigned char> dictionary1( dictionary1String.begin(), dictionary1String.end() );
+    std::string dictionary2String = "1234";
+    std::vector<unsigned char> dictionary2( dictionary2String.begin(), dictionary2String.end() );
+
+    std::vector<unsigned char> outputNo( 100 );
+    std::vector<unsigned char> output1( 100 );
+    std::vector<unsigned char> output2( 100 );
+
+    Deflater defDictNo( 9 );
+    Deflater defDict1( 9 );
+    Deflater defDict2( 9 );
+
+    defDict1.setDictionary( dictionary1 );
+    defDict2.setDictionary( dictionary2 );
+
+    defDictNo.setInput( input );
+    defDict1.setInput( input );
+    defDict2.setInput( input );
+
+    defDictNo.finish();
+    defDict1.finish();
+    defDict2.finish();
+
+    std::size_t dataLenNo = defDictNo.deflate( outputNo );
+    std::size_t dataLen1 = defDict1.deflate( output1 );
+    std::size_t dataLen2 = defDict2.deflate( output2 );
+
+    bool passNo1 = false;
+    bool passNo2 = false;
+    bool pass12 = false;
+
+    for( i = 0; i < ( dataLenNo < dataLen1 ? dataLenNo : dataLen1 ); i++ ) {
+        if( outputNo[i] != output1[i] ) {
+            passNo1 = true;
+            break;
+        }
+    }
+    for( i = 0; i < ( dataLenNo < dataLen1 ? dataLenNo : dataLen2 ); i++ ) {
+        if( outputNo[i] != output2[i] ) {
+            passNo2 = true;
+            break;
+        }
+    }
+    for( i = 0; i < ( dataLen1 < dataLen2 ? dataLen1 : dataLen2 ); i++ ) {
+        if( output1[i] != output2[i] ) {
+            pass12 = true;
+            break;
+        }
+    }
+
+    CPPUNIT_ASSERT_MESSAGE( "Compressed data the same for stream with dictionary and without it.", passNo1 );
+    CPPUNIT_ASSERT_MESSAGE( "Compressed data the same for stream with dictionary and without it.", passNo2 );
+    CPPUNIT_ASSERT_MESSAGE( "Compressed data the same for stream with different dictionaries.", pass12 );
+
+    Inflater inflNo;
+    Inflater infl1;
+    Inflater infl2;
+
+    std::vector<unsigned char> result(100);
+    std::size_t decLen;
+
+    inflNo.setInput( outputNo, 0, dataLenNo );
+    decLen = inflNo.inflate( result );
+
+    CPPUNIT_ASSERT( !inflNo.needsDictionary() );
+    inflNo.end();
+    CPPUNIT_ASSERT_EQUAL( inputString, std::string( result.begin(), result.begin() + decLen ) );
+
+    infl1.setInput( output1, 0, dataLen1 );
+    decLen = infl1.inflate( result );
+
+    CPPUNIT_ASSERT( infl1.needsDictionary() );
+    infl1.setDictionary( dictionary1 );
+    decLen = infl1.inflate( result );
+    infl1.end();
+    CPPUNIT_ASSERT_EQUAL( inputString, std::string( result.begin(), result.begin() + decLen ) );
+
+    infl2.setInput( output2, 0, dataLen2 );
+    decLen = infl2.inflate( result );
+
+    CPPUNIT_ASSERT(infl2.needsDictionary());
+    infl2.setDictionary( dictionary2 );
+    decLen = infl2.inflate( result );
+    infl2.end();
+    CPPUNIT_ASSERT_EQUAL(inputString, std::string( result.begin(), result.begin() + decLen ) );
+
+    {
+        Inflater inflNo;
+        Inflater infl1;
+        inflNo.setInput( outputNo, 0, dataLenNo );
+
+        CPPUNIT_ASSERT_THROW_MESSAGE(
+            "IllegalArgumentException expected.",
+            infl1.setDictionary( dictionary1 ),
+            IllegalArgumentException );
+
+        inflNo.end();
+
+        infl1.setInput( output1, 0, dataLen1 );
+        decLen = infl1.inflate( result );
+
+        CPPUNIT_ASSERT( infl1.needsDictionary() );
+
+        CPPUNIT_ASSERT_THROW_MESSAGE(
+            "IllegalArgumentException expected.",
+            infl1.setDictionary( dictionary2 ),
+            IllegalArgumentException );
+
+        infl1.end();
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void InflaterTest::testSetDictionaryBIII() {
+
+    std::size_t i = 0;
+    std::string inputString = "blah string contains blahblahblahblah and blah";
+    std::vector<unsigned char> input( inputString.begin(), inputString.end() );
+    std::string dictionary1String = "blah";
+    std::vector<unsigned char> dictionary1( dictionary1String.begin(), dictionary1String.end() );
+    std::string dictionary2String = "blahblahblah";
+    std::vector<unsigned char> dictionary2( dictionary2String.begin(), dictionary2String.end() );
+
+    std::vector<unsigned char> output1( 100 );
+    std::vector<unsigned char> output2( 100 );
+    std::vector<unsigned char> output3( 100 );
+
+    Deflater defDict1( 9 );
+    Deflater defDict2( 9 );
+    Deflater defDict3( 9 );
+
+    defDict1.setDictionary( dictionary1 );
+    defDict2.setDictionary( dictionary2 );
+    defDict3.setDictionary( dictionary2, 4, 4 );
+
+    defDict1.setInput( input );
+    defDict2.setInput( input );
+    defDict3.setInput( input );
+
+    defDict1.finish();
+    defDict2.finish();
+    defDict3.finish();
+
+    std::size_t dataLen1 = defDict1.deflate( output1 );
+    std::size_t dataLen2 = defDict2.deflate( output2 );
+    std::size_t dataLen3 = defDict3.deflate( output3 );
+
+    bool pass12 = false;
+    bool pass23 = false;
+    bool pass13 = true;
+
+    for( i = 0; i < ( dataLen1 < dataLen2 ? dataLen1 : dataLen2 ); i++ ) {
+        if( output1[i] != output2[i] ) {
+            pass12 = true;
+            break;
+        }
+    }
+    for( i = 0; i < ( dataLen2 < dataLen3 ? dataLen2 : dataLen3 ); i++ ) {
+        if( output2[i] != output3[i] ) {
+            pass23 = true;
+            break;
+        }
+    }
+    for( i = 0; i < ( dataLen1 < dataLen3 ? dataLen1 : dataLen3 ); i++ ) {
+        if( output1[i] != output3[i] ) {
+            pass13 = false;
+            break;
+        }
+    }
+
+    CPPUNIT_ASSERT_MESSAGE( "Compressed data the same for stream with different dictionaries.", pass12 );
+    CPPUNIT_ASSERT_MESSAGE( "Compressed data the same for stream with different dictionaries.", pass23 );
+    CPPUNIT_ASSERT_MESSAGE( "Compressed data the differs for stream with the same dictionaries.", pass13 );
+
+    Inflater infl1;
+    Inflater infl2;
+    Inflater infl3;
+
+    std::vector<unsigned char> result(100);
+    std::size_t decLen;
+
+    infl1.setInput( output1, 0, dataLen1 );
+    decLen = infl1.inflate( result );
+
+    CPPUNIT_ASSERT( infl1.needsDictionary() );
+    infl1.setDictionary( dictionary2, 4, 4 );
+    decLen = infl1.inflate( result );
+    infl1.end();
+    CPPUNIT_ASSERT_EQUAL( inputString, std::string( result.begin(), result.begin() + decLen ) );
+
+    infl2.setInput( output2, 0, dataLen2 );
+    decLen = infl2.inflate( result );
+
+    CPPUNIT_ASSERT(infl2.needsDictionary());
+    CPPUNIT_ASSERT_THROW_MESSAGE(
+        "IllegalArgumentException expected.",
+        infl2.setDictionary( dictionary1 ),
+        IllegalArgumentException );
+
+    infl2.end();
+
+    infl3.setInput( output3, 0, dataLen3 );
+    decLen = infl3.inflate( result );
+
+    CPPUNIT_ASSERT( infl3.needsDictionary() );
+    infl3.setDictionary( dictionary1 );
+    decLen = infl3.inflate( result );
+    infl3.end();
+    CPPUNIT_ASSERT_EQUAL( inputString, std::string( result.begin(), result.begin() + decLen ) );
+}

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterTest.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterTest.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterTest.h?rev=910686&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterTest.h (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterTest.h Tue Feb 16 20:54:08 2010
@@ -0,0 +1,86 @@
+/*
+ * 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_ZIP_INFLATERTEST_H_
+#define _DECAF_UTIL_ZIP_INFLATERTEST_H_
+
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+namespace decaf {
+namespace util {
+namespace zip {
+
+    class InflaterTest : public CppUnit::TestFixture {
+
+        CPPUNIT_TEST_SUITE( InflaterTest );
+        CPPUNIT_TEST( testEnd );
+        CPPUNIT_TEST( testFinished );
+        CPPUNIT_TEST( testGetAdler );
+        CPPUNIT_TEST( testGetRemaining );
+        CPPUNIT_TEST( testInflateVector );
+        CPPUNIT_TEST( testInflateB1 );
+        CPPUNIT_TEST( testInflateBII );
+        CPPUNIT_TEST( testInflateBII1 );
+        CPPUNIT_TEST( testConstructor );
+        CPPUNIT_TEST( testConstructorZ );
+        CPPUNIT_TEST( testNeedsDictionary );
+        CPPUNIT_TEST( testNeedsInput );
+        CPPUNIT_TEST( testReset );
+        CPPUNIT_TEST( testSetInputB );
+        CPPUNIT_TEST( testSetInputBIII );
+        CPPUNIT_TEST( testGetBytesRead );
+        CPPUNIT_TEST( testGetBytesWritten );
+        CPPUNIT_TEST( testInflate );
+        CPPUNIT_TEST( testSetDictionaryB );
+        CPPUNIT_TEST( testSetDictionaryBIII );
+        CPPUNIT_TEST_SUITE_END();
+
+    public:
+
+        InflaterTest();
+        virtual ~InflaterTest();
+
+        virtual void setUp();
+        virtual void tearDown();
+
+        void testEnd();
+        void testFinished();
+        void testGetAdler();
+        void testGetRemaining();
+        void testInflateVector();
+        void testInflateB1();
+        void testInflateBII();
+        void testInflateBII1();
+        void testConstructor();
+        void testConstructorZ();
+        void testNeedsDictionary();
+        void testNeedsInput();
+        void testReset();
+        void testSetInputB();
+        void testSetInputBIII();
+        void testGetBytesRead();
+        void testGetBytesWritten();
+        void testInflate();
+        void testSetDictionaryB();
+        void testSetDictionaryBIII();
+
+    };
+
+}}}
+
+#endif /* _DECAF_UTIL_ZIP_INFLATERTEST_H_ */

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterTest.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=910686&r1=910685&r2=910686&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp Tue Feb 16 20:54:08 2010
@@ -18,264 +18,273 @@
 // 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/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/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 <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/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/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 );
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Marshaler Tests



Mime
View raw message