root/experimental/components/Packetizer/trunk/Packetizer-metadata/tests/Depacketizer_testsuite.h @ 5428

#ifndef __DEPACKETIZERDSPTEST_H__
#define __DEPACKETIZERDSPTEST_H__

#include <cxxtest/TestSuite.h>
#include "src/PacketizerDSP.h"

//
// A simple test suite: Just inherit CxxTest::TestSuite and write tests!
//
// NOTE: " : public CxxTest::TestSuite" must be on the same line as the class
//       definition, otherwise the python script does not recognize it
//       as a test class
class Depacketizer_testsuite1 : public CxxTest::TestSuite,
    public PacketDecoder
{
public:
    void test_CorrelateSequence() {
        int r(0);
        
        // Test for positive P/N sync code correlation
        for (unsigned int i=0; i<63; i++)
            binary_sequence_push( pn_sync_buffer,  pnSyncCode[i] );

        r = binary_sequence_correlate( pn_sync_buffer, pn_sync_code );
        TS_ASSERT_EQUALS( r, 63 );
        
        // Test for negative P/N sync code correlation
        for (unsigned int i=0; i<63; i++)
            binary_sequence_push( pn_sync_buffer,  1-pnSyncCode[i] );

        r = binary_sequence_correlate( pn_sync_buffer, pn_sync_code );
        TS_ASSERT_EQUALS( r, -63 );

        // Test for positive P/N control code correlation
        for (unsigned int i=0; i<7; i++)
            binary_sequence_push( pn_control_buffer,  pnControlCode[i] );

        r = binary_sequence_correlate( pn_control_buffer, pn_control_code );
        TS_ASSERT_EQUALS( r, 7 );
        
        // Test for positive P/N control code correlation
        for (unsigned int i=0; i<7; i++)
            binary_sequence_push( pn_control_buffer,  1-pnControlCode[i] );

        r = binary_sequence_correlate( pn_control_buffer, pn_control_code );
        TS_ASSERT_EQUALS( r, -7 );
        
    }
    
    void test_ExtractSubheader_01() {
        ConfigurePacketType( PACKET_RAW_400 );
        unsigned int N(packet_subheader_length);
        
        char * input = (char*) malloc( N );
        for (unsigned int i=0; i<N; i++)
            input[i] = rand() & 0x01;

        char * output = (char*) malloc( 256 );

        unsigned int num_read;
        unsigned int num_written(0);
        bool subheader_extracted;
        subheader_extracted = ExtractSubheader( input, N, num_read, output, 256, num_written );

        TS_ASSERT_EQUALS( subheader_extracted, true );
        TS_ASSERT_EQUALS( num_written, N );
        TS_ASSERT_SAME_DATA( input, output, N );


        // reset output; try again but break input bufferinto pieces
        // First attempt: read first 8 bits
        memset(output, 0, 256);
        num_written = 0;
        num_subheader_bits_read = 0;
        unsigned int n(0);
        subheader_extracted = ExtractSubheader( input, 8, num_read, output, 256, num_written );
        n+=num_written;
        TS_ASSERT_EQUALS( subheader_extracted, false );
        TS_ASSERT_EQUALS( num_subheader_bits_read, 8 );
        TS_ASSERT_EQUALS( num_read, 8 );
        TS_ASSERT_EQUALS( num_written, 8 );
        TS_ASSERT_EQUALS( n, 8 );

        // Second attempt: read remaining 13 bits
        subheader_extracted = ExtractSubheader( input+n, 13, num_read, output+n, 256-n, num_written );
        n+=num_written;
        TS_ASSERT_EQUALS( subheader_extracted, true );
        TS_ASSERT_EQUALS( num_subheader_bits_read, 21 );
        TS_ASSERT_EQUALS( num_read, 13 );
        TS_ASSERT_EQUALS( num_written, 13 );
        TS_ASSERT_EQUALS( n, 21 );

        TS_ASSERT_EQUALS( n, N );
        TS_ASSERT_SAME_DATA( input, output, N );

        free(input);
        free(output);
    }

    //
    // Basic test for creating and extracting a packet of type PACKET_RAW_400
    // 
    void test_Extract_PACKET_RAW_400_01() {
        PacketEncoder p;

        // generate input buffer
        char * input;
        input = (char*) calloc( 400, sizeof(char) );
        input[0] = 1;
        input[1] = 0;
        input[2] = 1;

        // generate temporary buffer
        char * buf = (char*) calloc( 512, sizeof(char) );

        // generate packet buffer for encoded packet
        char * packet;
        packet = (char*) calloc( 1024, sizeof(char) );
        memset( packet, 0x01, 1024*sizeof(char) );

        // generate output buffer for decoded packet
        char * output;
        output = (char*) calloc( 1024, sizeof(char) );
        memset( output, 0x01, 1024*sizeof(char) );

        bool packet_header_found;
        bool packet_header_extracted;
        bool packet_header_decoded;
        bool packet_subheader_extracted;
        bool packet_subheader_decoded;
        bool packet_data_extracted;
        unsigned int n;

        // try to extract packet header before packet has been assembled
        packet_header_found = FindHeader( packet, 1024, n );
        TS_ASSERT_EQUALS(packet_header_found, false);  // should not have found header
        TS_ASSERT_EQUALS(n, 1024);              // should have read entire buffer

        //
        // ASSEMBLE PACKET
        //

        // assemble packet
        unsigned int num_read;
        unsigned int num_written;
        p.packet_id = 6;
        p.ConfigurePacketType( PACKET_RAW_400 );
        p.AssemblePacket( input, 400, num_read, packet, 1024, num_written );

        //
        // EXTRACT PACKET
        //

        //
        // MODE 0: FIND_HEADER
        //

        // try to find packet header
        unsigned int num_read_total(0);     // total bits read from input
        unsigned int num_written_total(0);  // total bits writtent to output buffer
        unsigned int nr;                    // number of bits read from input on each function call
        unsigned int nw;                    // number of bits written to output on each function call
        packet_header_found = FindHeader( packet+num_read_total, 1024, nr );
        num_read_total += nr;
        TS_ASSERT_EQUALS(packet_header_found, true);       // should have found header
        TS_ASSERT_EQUALS(nr, PN_SYNC_CODE_LENGTH);   // should have only read 63 values

        //
        // MODE 1: EXTRACT_HEADER
        //

        // try to extract packet type
        packet_header_extracted = ExtractHeader( packet+num_read_total, PN_CONTROL_CODE_LENGTH, nr, buf, 256, nw );
        num_read_total += nr;
        // should not have extracted packet type because buffer was said to only be
        // 7 samples long
        TS_ASSERT_EQUALS(packet_header_extracted, false);
        TS_ASSERT_EQUALS(nr, PN_CONTROL_CODE_LENGTH);    // should have only read 1 control code

        packet_header_extracted = ExtractHeader( packet+num_read_total, 500, nr, buf+nw, 256-nw, nw );
        num_read_total += nr;
        TS_ASSERT_EQUALS(packet_header_extracted, true);
        TS_ASSERT_EQUALS( nr, (NUM_CONTROL_CODES-1)*PN_CONTROL_CODE_LENGTH);    // should have read remaining control codes
        TS_ASSERT_EQUALS( num_read_total, PN_SYNC_CODE_LENGTH + NUM_CONTROL_CODES*PN_CONTROL_CODE_LENGTH);

        //
        // MODE 2: DECODE_HEADER
        //

        packet_header_decoded = DecodeHeader(buf, 256);
        TS_ASSERT_EQUALS(packet_header_decoded, true);
        TS_ASSERT_EQUALS(packet_type, 0);

        //
        // MODE 3: EXTRACT_SUBHEADER
        //

        // try to extract the subheader; dump into temporary buffer
        memset(buf, 0x01, 256);
        packet_subheader_extracted = ExtractSubheader( packet+num_read_total, 500, nr, buf, 256, nw );
        num_read_total += nr;
        TS_ASSERT_EQUALS(packet_subheader_extracted, true);
        TS_ASSERT_EQUALS(nr, 21);
        TS_ASSERT_EQUALS(nw, 21);
        TS_ASSERT_EQUALS(num_read_total, 112);

        //
        // MODE 4: DECODE_SUBHEADER
        //

        // Decode subheader data
        packet_id = 0;
        packet_subheader_decoded = DecodeSubheader( buf, 256 );
        TS_ASSERT_EQUALS( packet_subheader_decoded, true );
        TS_ASSERT_EQUALS( packet_id, 6 );

        //
        // MODE 5: EXTRACT_PACKET_DATA
        //

        // try to extract packet data
        packet_data_extracted = ExtractPacketData( packet+num_read_total, 400, nr, output, 1024, nw );
        num_read_total += nr;
        TS_ASSERT_EQUALS( packet_data_extracted, true );
        TS_ASSERT_EQUALS( nr, 400 );
        TS_ASSERT_EQUALS( nw, 400 );
        TS_ASSERT_SAME_DATA( input, output, 400 );
        
        //
        // MODE 6: DECODE_PACKET_DATA
        //

        // No need to decode packet data for PACKET_RAW_400

        free(input);
        free(buf);
        free(packet);
        free(output);
    }

    //
    // Test extracting a packet with bit inversion
    // 
    void test_Extract_PACKET_RAW_400_02() {
        PacketEncoder p;

        // generate input buffer
        char * input;
        input = (char*) calloc( 400, sizeof(char) );
        input[0] = 1;
        input[1] = 0;
        input[2] = 1;

        // generate temporary buffer
        char * buf = (char*) malloc( 512 );

        // generate packet buffer for encoded packet
        char * packet;
        packet = (char*) calloc( 1024, sizeof(char) );
        memset( packet, 0x01, 1024*sizeof(char) );

        // generate output buffer for decoded packet
        char * output;
        output = (char*) calloc( 1024, sizeof(char) );
        memset( output, 0x01, 1024*sizeof(char) );

        bool packet_header_found;
        bool packet_header_extracted;
        bool packet_header_decoded;
        bool packet_subheader_extracted;
        bool packet_subheader_decoded;
        bool packet_data_extracted;

        // assemble packet
        unsigned int num_read;
        unsigned int num_written;
        p.packet_id = 6;
        p.ConfigurePacketType( PACKET_RAW_400 );
        p.AssemblePacket( input, 400, num_read, packet, 1024, num_written );

        // emulate channel
        // flip all the bits
        for (unsigned int i=0; i<1024; i++)
            packet[i] = 1-packet[i];
        // reset packet id
        packet_id = 0;

        //
        // EXTRACT PACKET
        //

        //
        // MODE 0: FIND_HEADER
        //

        // try to extract packet header
        unsigned int num_read_total(0);     // total bits read from input
        unsigned int num_written_total(0);  // total bits writtent to output buffer
        unsigned int nr;                    // number of bits read from input on each function call
        unsigned int nw;                    // number of bits written to output on each function call
        packet_header_found = FindHeader( packet+num_read_total, 1024, nr );
        num_read_total += nr;
        TS_ASSERT_EQUALS(packet_header_found, true);       // should have found header
        TS_ASSERT_EQUALS(nr, PN_SYNC_CODE_LENGTH);   // should have only read 63 values
        TS_ASSERT_EQUALS(rxy, -PN_SYNC_CODE_LENGTH);// correlator should be negative

        //
        // MODE 1: EXTRACT_HEADER
        //

        // try to extract packet type
        packet_header_extracted = ExtractHeader( packet+num_read_total, 500, nr, buf, 256, nw );
        num_read_total += nr;
        TS_ASSERT_EQUALS(packet_header_extracted, true);
        TS_ASSERT_EQUALS( nr, NUM_CONTROL_CODES*PN_CONTROL_CODE_LENGTH);    // should have read control codes
        TS_ASSERT_EQUALS( nw, NUM_CONTROL_CODES*PN_CONTROL_CODE_LENGTH);    // should have written control codes
        TS_ASSERT_EQUALS( num_read_total, PN_SYNC_CODE_LENGTH + NUM_CONTROL_CODES*PN_CONTROL_CODE_LENGTH);

        //
        // MODE 2: DECODE_HEADER
        //

        packet_header_decoded = DecodeHeader(buf, 256);
        TS_ASSERT_EQUALS(packet_header_decoded, true);
        TS_ASSERT_EQUALS(packet_type, 0);

        //
        // MODE 3: EXTRACT_SUBHEADER
        //

        // try to extract the subheader; dump into temporary buffer
        packet_subheader_extracted = ExtractSubheader( packet+num_read_total, 500, nr, buf, 256, nw );
        num_read_total += nr;
        TS_ASSERT_EQUALS(packet_subheader_extracted, true);
        TS_ASSERT_EQUALS(nr, 21);
        // PN sync code :               63
        // PN control codes :           4x7
        // PACKET_RAW_400 subheader :   21
        // total :                      112
        TS_ASSERT_EQUALS(num_read_total, 112);

        //
        // MODE 4: DECODE_SUBHEADER
        //

        // Decode subheader data
        packet_id = 0;
        packet_subheader_decoded = DecodeSubheader( buf, 256 );
        TS_ASSERT_EQUALS( packet_subheader_decoded, true );
        TS_ASSERT_EQUALS( packet_id, 6 );

        //
        // MODE 5: EXTRACT_PACKET_DATA
        //

        // try to extract packet data in pieces
        // First attempt: read only 150 bits
        packet_data_extracted = ExtractPacketData( packet+num_read_total, 150, nr, output, 1024, nw );
        num_read_total += nr;
        num_written_total += nw;
        TS_ASSERT_EQUALS( packet_data_extracted, false );
        TS_ASSERT_EQUALS( num_written_total, 150 );
        TS_ASSERT_EQUALS( nr, 150 );
        TS_ASSERT_EQUALS( nw, 150 );

        // Second attempt: read remaining 250 bits
        packet_data_extracted = ExtractPacketData( packet+num_read_total, 500, nr, output+150, 1024-150, nw );
        num_read_total += nr;
        num_written_total += nw;
        TS_ASSERT_EQUALS( packet_data_extracted, true );
        TS_ASSERT_EQUALS( num_read_total, 512 );
        TS_ASSERT_EQUALS( num_written_total, 400 );
        TS_ASSERT_EQUALS( nr, 250 );
        TS_ASSERT_EQUALS( nw, 250 );

        //
        // MODE 6: DECODE_PACKET_DATA
        //

        // DecodePacketData(...)
        // NOTE: no need to decode for PACKET_RAW_400

        // output data should be the same, even though the packet was decoded with bit inversions;
        // the P/N sync correlator should have detected this and corrected for it appropriately
        TS_ASSERT_SAME_DATA( input, output, 400 );
        
        free(input);
        free(buf);
        free(packet);
        free(output);
    }

};

#endif