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

#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;
        //read buffer
//      float nominal_test_vector_I, nominal_test_vector_Q;
        short nominal_expected_results_I, nominal_expected_results_Q;
        short nominal_test_vector_I_short, nominal_test_vector_Q_short;

//get n

        //float to short conversion
        float max_float_value = 3;   //double check this value later if signal is noisy
        short max_short_value = 32767;
        float tmp_float; 
        unsigned int N_in = 512;
        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 = (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 = (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 + 0; //Need some buffer for mismatched samples per symbol
        short* system_output_I = new short[N_out];
        short* system_output_Q = 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, system_output_I, system_output_Q, N_out);

        //verify
        //TS_ASSERT_SAME_DATA(system_output_I, nominal_expected_results_I,N_out);
        //TS_ASSERT_SAME_DATA(system_output_Q, nominal_expected_results_Q,N_out);

        TS_WARN("Test not fully implemented");
        delete [] system_output_I;
        delete [] system_output_Q;
    }


};

#endif