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

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

};

class SymbolSyncPoly_symboltestsuite: public CxxTest::TestSuite
{
public:

    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) (tmp_float * 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) (tmp_float * max_short_value);
        }

        //init variables
        char type[] = "rrcos";
        unsigned int k = 4;             //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);
    //debug printing
    std::cout<<std::endl;
    for(int i = 0; i<10; i++){
        std::cout<<nominal_test_vector_I[i]<<" ";
    }
    std::cout<<std::endl;

        //send test data
        symbolSync.SynchronizeAndDecimate(nominal_test_vector_I_short, nominal_test_vector_Q_short, N_in, systemOutputI, systemOutputQ, N_out);
    std::cout << "N_out = "<< N_out<<std::endl;    

    for(unsigned int i=0; i<N_out; i++) {
        std::cout << systemOutputI[i] << "  " << systemOutputQ[i] << std::endl;
    }

    //hard decision to see if we recovered the message
    for(unsigned int i = 0; i<N_out; i++){
        if (systemOutputI[i] < 0){
            systemOutputI[i] = 1;
        }else{
            systemOutputI[i] = -1;
        }

        if (systemOutputQ[i] < 0){
            systemOutputQ[i] = 1;
        }else{
            systemOutputQ[i] = -1;
        }
    }

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

        TS_WARN("Test not fully implemented");
        delete [] systemOutputI;
        delete [] systemOutputQ;
        delete [] nominal_test_vector_I_short;
        delete [] nominal_test_vector_Q_short;
    }

};

#endif