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

#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 PacketizerDSP
{
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 );
        
    }

    //
    // Basic test for creating and extracting a packet of type PACKET_RAW_400
    // 
    void test_ExtractPacketHeader_01() {
        // generate input buffer
        char * input;
        input = (char*) calloc( 400, sizeof(char) );
        input[0] = 1;
        input[1] = 0;
        input[2] = 1;

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

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

        bool found_header;
        bool packet_type_extracted;
        bool packet_subheader_extracted;
        bool packet_data_extracted;
        unsigned int n;

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

        // assemble packet
        unsigned int packet_length(1024);
        AssemblePacket( input, 400, packet, packet_length, PACKET_RAW_400 );

        // try to extract packet header
        unsigned int N(0);                      // total bits read from input
        found_header = ExtractPacketHeader( packet+N, 1024, n );
        N += n;
        TS_ASSERT_EQUALS(found_header, true);       // should have found header
        TS_ASSERT_EQUALS(n, PN_SYNC_CODE_LENGTH);   // should have only read 63 values

        // try to extract packet type
        packet_type_extracted = ExtractPacketType( packet+N, PN_CONTROL_CODE_LENGTH, n );
        N += n;
        // should not have extracted packet type because buffer was said to only be
        // 7 samples long
        TS_ASSERT_EQUALS(packet_type_extracted, false);
        TS_ASSERT_EQUALS(n, PN_CONTROL_CODE_LENGTH);    // should have only read 1 control code

        packet_type_extracted = ExtractPacketType( packet+N, 500, n );
        N += n;
        TS_ASSERT_EQUALS(packet_type_extracted, true);
        TS_ASSERT_EQUALS(n, (NUM_CONTROL_CODES-1)*PN_CONTROL_CODE_LENGTH);    // should have read remaining control codes
        TS_ASSERT_EQUALS( N, PN_SYNC_CODE_LENGTH + NUM_CONTROL_CODES*PN_CONTROL_CODE_LENGTH);

        TS_ASSERT_EQUALS(new_packet_type, 0);

        // try to extract the subheader
        packet_subheader_extracted = ExtractPacketSubheader( packet+N, 500, output, n );
        N += n;
        TS_ASSERT_EQUALS(packet_subheader_extracted, true);
        TS_ASSERT_EQUALS(n, 21);
        TS_ASSERT_EQUALS(N, 112);

        // try to extract packet data
        n = 1024;
        packet_data_extracted = ExtractPacketData( packet+N, 400, output, n );
        N += n;
        TS_ASSERT_EQUALS( packet_data_extracted, true );
        TS_ASSERT_EQUALS( n, 400 );
        TS_ASSERT_SAME_DATA( input, output, 400 );
        
        free(input);
        free(packet);
        free(output);
    }

    //
    // Test extracting a packet with bit inversion
    // 
    void test_ExtractPacketHeader_02() {
        // generate input buffer
        char * input;
        input = (char*) calloc( 400, sizeof(char) );
        input[0] = 1;
        input[1] = 0;
        input[2] = 1;

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

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

        bool found_header;
        bool packet_type_extracted;
        bool packet_subheader_extracted;
        bool packet_data_extracted;
        unsigned int n;

        // assemble packet
        unsigned int packet_length(1024);
        AssemblePacket( input, 400, packet, packet_length, PACKET_RAW_400 );

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

        // try to extract packet header
        unsigned int N(0);                      // total bits read from input
        found_header = ExtractPacketHeader( packet+N, 1024, n );
        N += n;
        TS_ASSERT_EQUALS(found_header, true);       // should have found header
        TS_ASSERT_EQUALS(n, PN_SYNC_CODE_LENGTH);   // should have only read 63 values
        TS_ASSERT_EQUALS(rxy, -PN_SYNC_CODE_LENGTH);// correlator should be negative

        // try to extract packet type
        packet_type_extracted = ExtractPacketType( packet+N, 500, n );
        N += n;
        TS_ASSERT_EQUALS(packet_type_extracted, true);
        TS_ASSERT_EQUALS(n, NUM_CONTROL_CODES*PN_CONTROL_CODE_LENGTH);    // should have read control codes
        TS_ASSERT_EQUALS( N, PN_SYNC_CODE_LENGTH + NUM_CONTROL_CODES*PN_CONTROL_CODE_LENGTH);

        TS_ASSERT_EQUALS(new_packet_type, 0);

        // try to extract the subheader
        packet_subheader_extracted = ExtractPacketSubheader( packet+N, 500, output, n );
        N += n;
        TS_ASSERT_EQUALS(packet_subheader_extracted, true);
        TS_ASSERT_EQUALS(n, 21);
        TS_ASSERT_EQUALS(N, 112);

        // try to extract packet data
        n = 1024;
        packet_data_extracted = ExtractPacketData( packet+N, 400, output, n );
        N += n;
        TS_ASSERT_EQUALS( packet_data_extracted, true );
        TS_ASSERT_EQUALS( n, 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(packet);
        free(output);
    }

};

#endif