root/experimental/components/SymbolSyncPoly/autotest_sources/SymbolSyncPoly_testsuite.h @ 3790

#ifndef __SYMBOLSYNCPOLYDSPTEST_H
#define __SYMBOLSYNCPOLYDSPTEST_H

#include <cxxtest/TestSuite.h>
#include "src/SymbolSyncPolyDSP.h"
#include "I_in_rrc_qpsk_N512_dT0_dF0_k4_m4_b025_Npfb32.h"
#include "Q_in_rrc_qpsk_N512_dT0_dF0_k4_m4_b025_Npfb32.h"
#include "msg_i_rrc_qpsk_N512_dT0_dF0_k4_m4_b025_Npfb32.h"
#include "msg_q_rrc_qpsk_N512_dT0_dF0_k4_m4_b025_Npfb32.h"

#include "test_02.h"
#include "test_03.h"

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

unsigned int CountSymbolErrors( short * msg_in_i,
        short * msg_in_q,
        short * msg_out_i,
        short * msg_out_q,
        short tol,
        unsigned int N)
{
    unsigned int num_errors(0);
    for (unsigned int i=0; i<N; i++) {
        if ( abs(msg_in_i[i]-msg_out_i[i]) > tol && abs(msg_in_q[i]-msg_out_q[i]) > tol )
            num_errors++;
    }
    return num_errors;
}


// 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 SymbolSyncPoly_testsuite1 : public CxxTest::TestSuite,
    public SymbolSyncPolyDSP
{
public:

    void test1() {
        // initialize variables
        mf_i  = -10;
        dmf_i =  10;
        mf_q  =  10;
        dmf_q =  10;
        GenerateTimingErrorSignal();
        TS_ASSERT_DELTA( q, 0.0f/(Ac*Ac), 1e-6f );
    }

    void test2() {
        // initialize variables
        mf_i  =  30;
        dmf_i =  5;
        mf_q  =  20;
        dmf_q =  1;
        GenerateTimingErrorSignal();
        TS_ASSERT_DELTA( q, -85.0f/(Ac*Ac), 1e-12f );
    }

};


class SymbolSyncPoly_testsuite_ComputeFilterBankIndex : public CxxTest::TestSuite,
    public SymbolSyncPolyDSP
{
  public:
    void testShift() {
        // Normal operation
        Npfb = 32;
        b_soft = 11.0f;
        ComputeFilterBankIndex();
        TS_ASSERT_EQUALS( b, 11 );
        TS_ASSERT_DELTA( b_soft, 11.0f, 0.0001f );
        TS_ASSERT_EQUALS( lc, SHIFT );
    }

    void testStuff() {
        // Filter bank overflow
        Npfb = 32;
        b_soft = 32.1f;
        ComputeFilterBankIndex();
        TS_ASSERT_EQUALS( b, 0 );
        TS_ASSERT_DELTA( b_soft, 0.1f, 0.0001f );
        TS_ASSERT_EQUALS( lc, STUFF );
    }

    void testSkip() {
        // Filter bank underflow
        Npfb = 32;
        b_soft = -2.1f;
        ComputeFilterBankIndex();
        TS_ASSERT_EQUALS( b, 30 );
        TS_ASSERT_DELTA( b_soft, 29.9f, 0.0001f );
        TS_ASSERT_EQUALS( lc, SKIP );
    }

};

/** \brief Test suite for SymbolSyncPolyDSP class
 *
 * In here we perform robust testing of the synchonization mechanism 
 * using different configurations and input vectors
 */
class SymbolSyncPoly_symboltestsuite: public CxxTest::TestSuite
{
public:

    ///\Basic test case for SynchronizeAndDecimate. No symbol offsets or timing errors
    void xtestBasicSynchronization()
    {
        SymbolSyncPolyDSP symbolSync;
        ///The following input buffers and expected results are defined in header files
        ///float nominal_test_vector_I, nominal_test_vector_Q;
        ///short nominal_expected_results_I, nominal_expected_results_Q;

        //float to short conversion
        //float max_float_value = 3;   //double check this value later if signal is noisy
        short max_short_value = 10000;//32767;
        //float tmp_float; 
        unsigned int N_in = 512; //This number must match with the lenght of the input buffer
        short* nominal_test_vector_I_short = new short[N_in];
        short* nominal_test_vector_Q_short = new short[N_in];
        for(unsigned int i =0 ; i < N_in; i++){
            //tmp_float = nominal_test_vector_I[i];// / max_float_value; //gives a value between 0 and 1
            nominal_test_vector_I_short[i] = (short) (nominal_test_vector_I[i] * max_short_value);

            //tmp_float = nominal_test_vector_Q[i];// / max_float_value; //gives a value between 0 and 1
            nominal_test_vector_Q_short[i] = (short) (nominal_test_vector_Q[i] * max_short_value);
        }

        ///Init variables shall match the values used in MATLAB to get the test vectors and
        ///expected result
        char type[] = "rrcos";  ///< filter type
        unsigned int k = 2;        ///< samples per symbol
        unsigned int m = 4;        ///< symbol delay
        float beta = .25;        ///< rolloff factor
        unsigned int Npfb = 32;    ///< polyphse filter bank size

        unsigned int N_out = N_in/k + 2; //Need some buffer for mismatched samples per symbol
        short* systemOutputI = new short[N_out];
        short* systemOutputQ = new short[N_out];


        symbolSync.ConfigureFilterBank(type, k, m, beta, Npfb);

        //send test data
        symbolSync.SynchronizeAndDecimate(  nominal_test_vector_I_short,
                                            nominal_test_vector_Q_short,
                                            N_in,
                                            systemOutputI,
                                            systemOutputQ,
                                            N_out);

        std::cout << std::endl << "testBasicSynchronization:" << std::endl;
        std::cout << N_in << " Input samples and " << N_out << " Output symbols" << std::endl;    
        //hard decision to see if we recovered the message correctly
        for(unsigned int i = 0; i<N_out; i++){
            systemOutputI[i] = (systemOutputI[i] < 0)? -1 : 1;
            systemOutputQ[i] = (systemOutputQ[i] < 0)? -1 : 1;
        }

        //verify
        TS_ASSERT_SAME_DATA(&systemOutputI[m],
                            nominal_expected_results_I,
                            (N_out - m)*sizeof(short));

        TS_ASSERT_SAME_DATA(&systemOutputQ[m],
                            nominal_expected_results_Q,
                            (N_out - m)*sizeof(short));

        delete [] systemOutputI;
        delete [] systemOutputQ;
        delete [] nominal_test_vector_I_short;
        delete [] nominal_test_vector_Q_short;
    }

    // test_02
    void testSymbolSynchronizationTimingOffset_02()
    {
        std::cout << std::endl << "testSymbolSynchronizationTimingOffset_02" << std::endl;
        SymbolSyncPolyDSP symbolSync;

        // Init variables shall match the values used in MATLAB to get the test vectors and
        // expected result
        unsigned int N_out_02 = N_in_02;

        //Need some buffer for mismatched samples per symbol
        short* I_out_02 = new short[N_out_02];
        short* Q_out_02 = new short[N_out_02];
        memset( I_out_02, 0, N_out_02*sizeof(short) );
        memset( Q_out_02, 0, N_out_02*sizeof(short) );

        symbolSync.ConfigureFilterBank(type_02, k_02, m_02, beta_02, Npfb_02);
        symbolSync.UpdateTimingLoopFilterCoefficients(alpha_s_02, beta_s_02);

        //send test data
        symbolSync.SynchronizeAndDecimate(
            I_in_02,
            Q_in_02,
            N_in_02,
            I_out_02,
            Q_out_02,
            N_out_02);

        //hard decision to see if we recovered the message correctly
        unsigned int num_correct_symbols(0);
        short t_min = short(Ac_02 / sqrtf(2) * 0.5);      // minimum threshold
        short t_max = short(Ac_02 / sqrtf(2) * 1.5);    // maximum threshold
        for(unsigned int i = 0; i<N_out_02; i++){
            if ( abs(I_out_02[i])>t_min && abs(I_out_02[i])<t_max &&
                 abs(Q_out_02[i])>t_min && abs(Q_out_02[i])<t_max )
                num_correct_symbols++;
            //std::cout << "  " << I_out_02[i] << "  " << Q_out_02[i] << std::endl;
        }

        std::cout << "num_correct_symbols : " << num_correct_symbols << std::endl;

        TS_ASSERT(num_correct_symbols > 200);

        delete [] I_out_02;
        delete [] Q_out_02;
    }


    // test_03
    void testSymbolSynchronizationTimingOffset_03()
    {
        std::cout << std::endl << "testSymbolSynchronizationTimingOffset_03" << std::endl;
        SymbolSyncPolyDSP symbolSync;

        // Init variables shall match the values used in MATLAB to get the test vectors and
        // expected result
        unsigned int N_out_03 = N_in_03;

        //Need some buffer for mismatched samples per symbol
        short* I_out_03 = new short[N_out_03];
        short* Q_out_03 = new short[N_out_03];
        memset( I_out_03, 0, N_out_03*sizeof(short) );
        memset( Q_out_03, 0, N_out_03*sizeof(short) );

        symbolSync.ConfigureFilterBank(type_03, k_03, m_03, beta_03, Npfb_03);
        symbolSync.UpdateTimingLoopFilterCoefficients(alpha_s_03, beta_s_03);

        //send test data
        symbolSync.SynchronizeAndDecimate(
            I_in_03,
            Q_in_03,
            N_in_03,
            I_out_03,
            Q_out_03,
            N_out_03);

        // hard decision to see if we recovered the message correctly
        unsigned int num_errors_2_percent;
        num_errors_2_percent =
            CountSymbolErrors(I_out_03+m_03-1, Q_out_03+m_03-1, msg_i_03, msg_q_03, Ac_03/50, N_out_03-m_03);
        std::cout << "  num errors outside 2% tolerance = " << num_errors_2_percent << std::endl;
        TS_ASSERT(num_errors_2_percent < 50);
        
        unsigned int num_errors_5_percent;
        num_errors_5_percent =
            CountSymbolErrors(I_out_03+m_03-1, Q_out_03+m_03-1, msg_i_03, msg_q_03, Ac_03/20, N_out_03-m_03);
        std::cout << "  num errors outside 5% tolerance = " << num_errors_5_percent << std::endl;
        TS_ASSERT(num_errors_5_percent < 20);

        delete [] I_out_03;
        delete [] Q_out_03;
    }

};

#endif