root/SigProc/trunk/SigProc/autotest_sources/pack_testsuite.h @ 5413

#ifndef __PACK_BYTE_TEST_H__
#define __PACK_BYTE_TEST_H__

#include <cxxtest/TestSuite.h>
#include "../SigProc.h"

using namespace SigProc;

//
// A simple test suite: Just inherit CxxTest::TestSuite and write tests!
//

class pack_bytes_Testsuite : public CxxTest::TestSuite
{
public:

    //
    // pack_bytes
    //
    
    void test_pack_bytes_01() {
        char * output = (char*) calloc(8, sizeof(char));
        unsigned int N;
        
        char input[36] = {
            0, 0, 0, 0, 0, 0, 0, 0, // 0:   0000 0000
            1, 1, 1, 1, 1, 1, 1, 1, // 255: 1111 1111
            0, 0, 0, 0, 1, 1, 1, 1, // 15:  0000 1111
            1, 0, 1, 0, 1, 0, 1, 0  // 170: 1010 1010
        };

        // Test packing entire array
        char output_test_01[4] = {0x00, 0xFF, 0x0F, 0xAA};
        pack_bytes( input, 32, output, 8, &N );
        TS_ASSERT_EQUALS( N, 4 );
        TS_ASSERT_SAME_DATA( output, output_test_01, 4 );

        // Test packing only 28 elements
        char output_test_02[4] = {0x00, 0xFF, 0x0F, 0x0A};
        pack_bytes( input, 28, output, 8, &N );
        TS_ASSERT_EQUALS( N, 4 );
        TS_ASSERT_SAME_DATA( output, output_test_02, 4 );
        
        // Test packing only 25 elements
        char output_test_03[4] = {0x00, 0xFF, 0x0F, 0x01};
        pack_bytes( input, 25, output, 8, &N );
        TS_ASSERT_EQUALS( N, 4 );
        TS_ASSERT_SAME_DATA( output, output_test_03, 4 );

        // Test packing only 24 elements (3 bytes)
        char output_test_04[3] = {0x00, 0xFF, 0x0F};
        pack_bytes( input, 24, output, 8, &N );
        TS_ASSERT_EQUALS( N, 3 );
        TS_ASSERT_SAME_DATA( output, output_test_04, 3 );

        free(output);
    }
    
    
    //
    // unpack_bytes
    //
    
    void test_unpack_bytes_01() {
        char input[5] = {0x00, 0x01, 0xFF, 0x0F, 0xAA};
        
        char * output = (char*) calloc(64, sizeof(char));
        unsigned int N;

        char output_test[40] = {
            0, 0, 0, 0, 0, 0, 0, 0, // 0:   0000 0000
            0, 0, 0, 0, 0, 0, 0, 1, // 1:   0000 0001
            1, 1, 1, 1, 1, 1, 1, 1, // 255: 1111 1111
            0, 0, 0, 0, 1, 1, 1, 1, // 15:  0000 1111
            1, 0, 1, 0, 1, 0, 1, 0  // 170: 1010 1010
        };
        
        // Test packing entire array
        unpack_bytes( input, 4, output, 40, &N );
        TS_ASSERT_EQUALS( N, 32 );
        TS_ASSERT_SAME_DATA( output, output_test, 32 );

        free(output);
    }


    //
    // repack_bytes
    //
    
    void test_repack_bytes_01() {
        char input[] = {
            0x07,   // 111
            0x00,   // 000
            0x06,   // 110
            0x07    // 111
        };

        char output_test[] = {
            0x03,   // 11
            0x02,   // 10
            0x00,   // 00
            0x03,   // 11
            0x01,   // 01
            0x03    // 11
        };

        char * output = (char*) calloc(8, sizeof(char));
        unsigned int N;

        repack_bytes( input, 3, 4, output, 2, 8, &N );

        TS_ASSERT_EQUALS( N, 6 );
        TS_ASSERT_SAME_DATA( output, output_test, 6 );
    }
   
    void test_repack_bytes_02() {
        char input[] = {
            0x01,   // 00001
            0x02,   // 00010
            0x04    // 00100
        };

        char output_test[] = {
            0x00,   // 000
            0x02,   // 010
            0x01,   // 001
            0x00,   // 000
            0x04    // 100
        };

        char * output = (char*) calloc(8, sizeof(char));
        unsigned int N;

        repack_bytes( input, 5, 3, output, 3, 8, &N );

        TS_ASSERT_EQUALS( N, 5 );
        TS_ASSERT_SAME_DATA( output, output_test, 5 );
    }

    void test_repack_bytes_03() {
        char input[] = {
            0x00,   // 000
            0x02,   // 010
            0x01,   // 001
            0x00,   // 000
            0x04    // 100
        };

        char output_test[] = {
            0x01,   // 00001
            0x02,   // 00010
            0x04    // 00100
        };

        char * output = (char*) calloc(8, sizeof(char));
        unsigned int N;

        repack_bytes( input, 3, 5, output, 5, 8, &N );

        TS_ASSERT_EQUALS( N, 3 );
        TS_ASSERT_SAME_DATA( output, output_test, 3 );
    }

};


#endif // __PACK_BYTE_TEST_H__