root/experimental/components/DigitalModem/trunk/DigitalModem/atsrc/DigitalModulator_testsuite.h @ 4746

#ifndef __DIGITALMODULATORTEST_H__
#define __DIGITALMODULATORTEST_H__

#include <cxxtest/TestSuite.h>
#include "src/DigitalModem.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 DigitalModulator_TestMiscellaneousFunctions : public CxxTest::TestSuite,
    public DigitalModem
{
public:

    void test_ConvertBitsToSymbol_01() {
        char b[2] = {BIT0, BIT1};
        
        unsigned short s;
        
        SetModulationScheme( SigProc::BPSK );

        for (unsigned int i=0; i<2; i++) {
            ConvertBitsToSymbol(b+i*bitsPerSymbol, s);
            TS_ASSERT_EQUALS( s, i );
        }
    }

    void test_ConvertBitsToSymbol_02() {
        char b[8] = {BIT0, BIT0,
                     BIT0, BIT1,
                     BIT1, BIT0,
                     BIT1, BIT1};
        
        unsigned short s;
        
        SetModulationScheme( SigProc::QPSK );

        for (unsigned int i=0; i<4; i++) {
            ConvertBitsToSymbol(b+i*bitsPerSymbol, s);
            TS_ASSERT_EQUALS( s, i );
        }
    }

    void test_ConvertBitsToSymbol_03() {
        char b[24] = {BIT0, BIT0, BIT0,
                      BIT0, BIT0, BIT1,
                      BIT0, BIT1, BIT0,
                      BIT0, BIT1, BIT1,
                      BIT1, BIT0, BIT0,
                      BIT1, BIT0, BIT1,
                      BIT1, BIT1, BIT0,
                      BIT1, BIT1, BIT1};
        
        unsigned short s;
        
        SetModulationScheme( SigProc::PSK8 );

        for (unsigned int i=0; i<8; i++) {
            ConvertBitsToSymbol(b+i*bitsPerSymbol, s);
            TS_ASSERT_EQUALS( s, i );
        }
    }
};

// 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 DigitalModulator_TestModulation : public CxxTest::TestSuite,
    public DigitalModem
{
public:

    void test_ModulateBPSK() {
        char b[2] = {BIT0, BIT1};
        short * I_out = new short[2];
        short * Q_out = new short[2];

        SetModulationScheme( SigProc::BPSK );
        ModulateSequence( b, 2, I_out, Q_out );
        
        TS_ASSERT_EQUALS( I_out[0], -BPSK_LEVEL );
        TS_ASSERT_EQUALS( Q_out[0],  0          );
        
        TS_ASSERT_EQUALS( I_out[1],  BPSK_LEVEL );
        TS_ASSERT_EQUALS( Q_out[1],  0          );
        
        delete [] I_out;
        delete [] Q_out;
    }

    void test_ModulateQPSK() {
        char b[8] = {BIT0, BIT0,
                     BIT0, BIT1,
                     BIT1, BIT0,
                     BIT1, BIT1};
                     
        short * I_out = new short[4];
        short * Q_out = new short[4];

        SetModulationScheme( SigProc::QPSK );
        ModulateSequence( b, 8, I_out, Q_out );
        
        TS_ASSERT_EQUALS( I_out[0],  QPSK_LEVEL );
        TS_ASSERT_EQUALS( Q_out[0],  QPSK_LEVEL );
        
        TS_ASSERT_EQUALS( I_out[1],  QPSK_LEVEL );
        TS_ASSERT_EQUALS( Q_out[1], -QPSK_LEVEL );
        
        TS_ASSERT_EQUALS( I_out[2], -QPSK_LEVEL );
        TS_ASSERT_EQUALS( Q_out[2],  QPSK_LEVEL );
        
        TS_ASSERT_EQUALS( I_out[3], -QPSK_LEVEL );
        TS_ASSERT_EQUALS( Q_out[3], -QPSK_LEVEL );
        
        delete [] I_out;
        delete [] Q_out;

    }

    void test_Modulate8PSK() {
        char b[24] = {BIT0, BIT0, BIT0,
                      BIT0, BIT0, BIT1,
                      BIT0, BIT1, BIT0,
                      BIT0, BIT1, BIT1,
                      BIT1, BIT0, BIT0,
                      BIT1, BIT0, BIT1,
                      BIT1, BIT1, BIT0,
                      BIT1, BIT1, BIT1};
        
        short * I_out = new short[8];
        short * Q_out = new short[8];

        SetModulationScheme( SigProc::PSK8 );
        ModulateSequence(b, 24, I_out, Q_out);

        TS_ASSERT_EQUALS( I_out[0],  PSK8_LEVEL_2 );
        TS_ASSERT_EQUALS( Q_out[0],  0            );
        
        TS_ASSERT_EQUALS( I_out[1],  PSK8_LEVEL_1 );
        TS_ASSERT_EQUALS( Q_out[1],  PSK8_LEVEL_1 );
        
        TS_ASSERT_EQUALS( I_out[2],  PSK8_LEVEL_1 );
        TS_ASSERT_EQUALS( Q_out[2], -PSK8_LEVEL_1 );
        
        TS_ASSERT_EQUALS( I_out[3],  0            );
        TS_ASSERT_EQUALS( Q_out[3], -PSK8_LEVEL_2 );
        
        TS_ASSERT_EQUALS( I_out[4], -PSK8_LEVEL_1 );
        TS_ASSERT_EQUALS( Q_out[4],  PSK8_LEVEL_1 );
        
        TS_ASSERT_EQUALS( I_out[5],  0            );
        TS_ASSERT_EQUALS( Q_out[5],  PSK8_LEVEL_2 );
        
        TS_ASSERT_EQUALS( I_out[6], -PSK8_LEVEL_2 );
        TS_ASSERT_EQUALS( Q_out[6],  0            );
        
        TS_ASSERT_EQUALS( I_out[7], -PSK8_LEVEL_1 );
        TS_ASSERT_EQUALS( Q_out[7], -PSK8_LEVEL_1 );
        
        delete [] I_out;
        delete [] Q_out;

    }

    void test_Modulate16QAM() {
    }

    void test_Modulate4PAM() {
    }

};

#endif