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

#ifndef __SYMBOLSYNCPOLYDSPTEST_H
#define __SYMBOLSYNCPOLYDSPTEST_H

#include <cxxtest/TestSuite.h>
#include "../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"

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

    void test1() {
        // initialize variables
        mf_i  = -10;
        dmf_i =  10;
        mf_q  =  10;
        dmf_q =  10;
        GenerateErrorSignal();
        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;
        GenerateErrorSignal();
        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 testBasicSynchronization()
    {
        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;
    }

};

#endif