-/******************************************************************************\r
-*\r
-* Copyright (c) 2019 Intel.\r
-*\r
-* Licensed under the Apache License, Version 2.0 (the "License");\r
-* you may not use this file except in compliance with the License.\r
-* You may obtain a copy of the License at\r
-*\r
-* http://www.apache.org/licenses/LICENSE-2.0\r
-*\r
-* Unless required by applicable law or agreed to in writing, software\r
-* distributed under the License is distributed on an "AS IS" BASIS,\r
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
-* See the License for the specific language governing permissions and\r
-* limitations under the License.\r
-*\r
-*******************************************************************************/\r
-\r
-\r
-#include "common.hpp"\r
-#include "xran_common.h"\r
-#include "xran_fh_o_du.h"\r
-#include "ethernet.h"\r
-#include "xran_transport.h"\r
-#include "xran_cp_api.h"\r
-\r
-#include <stdint.h>\r
-\r
-\r
-const std::string module_name = "Prach_test";\r
-\r
-\r
-class PrachCheck : public KernelTests\r
-{\r
-private:\r
- struct xran_section_gen_info *m_pSectResult = NULL;\r
-\r
-protected:\r
- struct xran_fh_config *m_xranConf;\r
- struct xran_device_ctx m_xran_dev_ctx;\r
- struct xran_prach_config *m_pPRACHConfig;\r
- struct xran_ru_config *m_pRUConfig;\r
- struct xran_prach_cp_config *m_pPrachCPConfig;\r
-\r
- struct xran_section_gen_info *m_pSectGenInfo = NULL;\r
- int m_maxSections = 8; /* not used */\r
- int lastsymbol;\r
-\r
- struct rte_mbuf *m_pTestBuffer;\r
-\r
- struct xran_cp_gen_params m_params;\r
- struct xran_recv_packet_info m_pktInfo;\r
- struct xran_cp_gen_params m_result;\r
-\r
- uint8_t m_dir;\r
- std::string m_dirStr;\r
- uint8_t m_sectionType;\r
-\r
- uint8_t m_ccId, m_antId;\r
- uint8_t m_seqId;\r
- uint8_t m_frameId, m_subframeId, m_slotId;\r
- uint8_t m_symStart, m_symNum;\r
- uint16_t *m_prbStart = NULL, *m_prbNum = NULL;\r
-\r
- uint8_t m_iqWidth, m_compMethod;\r
- uint16_t m_beamId;\r
- uint16_t m_reMask = 0xfff;\r
- uint16_t m_sectionId;\r
- uint8_t m_filterIndex;\r
- //uint16_t m_timeOffset;\r
- uint8_t m_fftSize;\r
-\r
- //define reference values\r
- uint8_t m_startSymId;\r
- uint8_t m_x;\r
- uint8_t m_filterIdx;\r
- uint16_t m_startPrbc;\r
- uint8_t m_numPrbc;\r
- uint8_t m_numSymbol;\r
- uint16_t m_timeOffset;\r
- int32_t m_freqOffset;\r
- uint8_t m_nrofPrachInSlot;\r
- uint8_t m_occassionsInPrachSlot;\r
- uint8_t m_y[XRAN_PRACH_CANDIDATE_Y];\r
- uint8_t m_isPRACHslot[XRAN_PRACH_CANDIDATE_SLOT];\r
- int m_prach_start_symbol;\r
- int m_prach_last_symbol;\r
- uint8_t m_SlotNrNum;\r
- uint16_t m_m_params_timeOffset;\r
- uint16_t m_id;\r
-\r
- void SetUp() override\r
- {\r
- init_test("prach_functional");\r
- memset(&m_xran_dev_ctx, 0, sizeof(struct xran_device_ctx));\r
- //modify\r
- m_xranConf = &m_xran_dev_ctx.fh_cfg;\r
-\r
- m_pPRACHConfig = &m_xranConf->prach_conf;\r
- m_pRUConfig = &m_xranConf->ru_conf;\r
- m_pPrachCPConfig = &m_xran_dev_ctx.PrachCPConfig;\r
- //initialize input parameters\r
- m_xranConf->frame_conf.nNumerology = get_input_parameter<uint8_t>("Numerology");\r
- m_xranConf->frame_conf.nFrameDuplexType = get_input_parameter<uint8_t>("FrameDuplexType");\r
- m_xranConf->log_level = get_input_parameter<uint32_t>("loglevel");\r
- m_pPRACHConfig->nPrachConfIdx = get_input_parameter<uint8_t>("PrachConfIdx");\r
- m_pPRACHConfig->nPrachFreqStart = get_input_parameter<uint16_t>("PrachFreqStart");\r
- m_pPRACHConfig->nPrachFreqOffset = get_input_parameter<int32_t>("PrachFreqOffset");\r
- m_pPRACHConfig->nPrachSubcSpacing = get_input_parameter<uint8_t>("PrachSubcSpacing");\r
-\r
- m_pRUConfig->iqWidth = get_input_parameter<uint8_t>("iqWidth");\r
- m_pRUConfig->compMeth = get_input_parameter<uint8_t>("compMeth");\r
- m_pRUConfig->fftSize = get_input_parameter<uint8_t>("fftSize");\r
-\r
- m_frameId = get_input_parameter<uint8_t>("frameId");\r
- m_subframeId = get_input_parameter<uint8_t>("subframeId");\r
- m_slotId = get_input_parameter<uint8_t>("slotId");\r
- m_beamId = get_input_parameter<uint16_t>("beamId");\r
- m_ccId = get_input_parameter<uint8_t>("ccId");\r
- m_antId = get_input_parameter<uint8_t>("antId");\r
-\r
- //initialize reference output\r
- m_startSymId = get_reference_parameter<uint8_t>("startSymId");\r
- m_x = get_reference_parameter<uint8_t>("x_value");\r
-\r
- m_filterIdx = get_reference_parameter<uint8_t>("filterIdx");\r
- m_startPrbc = get_reference_parameter<uint16_t>("startPrbc");\r
- m_numPrbc = get_reference_parameter<uint8_t>("numPrbc");\r
- m_timeOffset = get_reference_parameter<uint16_t>("timeOffset");\r
- m_freqOffset = get_reference_parameter<uint32_t>("freqOffset");\r
- m_nrofPrachInSlot = get_reference_parameter<uint8_t>("nrofPrachInSlot");\r
- m_m_params_timeOffset = get_reference_parameter<uint16_t>("m_params_timeOffset");\r
- m_id = get_reference_parameter<uint16_t>("id");\r
- std::vector<uint8_t> y_vec = get_reference_parameter<std::vector<uint8_t>>("y_value");\r
- for(int i=0; i < XRAN_PRACH_CANDIDATE_Y; i++) {\r
- m_y[i] = y_vec[i];\r
- }\r
-\r
- m_numSymbol = get_reference_parameter<uint8_t>("numSymbol");\r
- m_occassionsInPrachSlot = get_reference_parameter<uint8_t>("occassionsInPrachSlot");\r
-\r
- std::vector<uint8_t> index_vec = get_reference_parameter<std::vector<uint8_t>>("isPRACHslot");\r
- m_SlotNrNum = get_reference_parameter<uint8_t>("SlotNrNum");\r
- for(int i = 0; i < XRAN_PRACH_CANDIDATE_SLOT; i++){\r
- m_isPRACHslot[i]=0;\r
- }\r
- for(int i=0; i<m_SlotNrNum;i++){\r
- m_isPRACHslot[index_vec[i]]=1;\r
- }\r
-\r
-\r
- m_prach_start_symbol = get_reference_parameter<int>("prach_start_symbol");\r
- m_prach_last_symbol = get_reference_parameter<int>("prach_last_symbol");\r
-\r
- /* allocate and prepare required data storage */\r
- m_pSectGenInfo = new struct xran_section_gen_info[8];\r
- ASSERT_NE(m_pSectGenInfo, nullptr);\r
- m_params.sections = m_pSectGenInfo;\r
-\r
- /* allocating an mbuf for packet generatrion */\r
- m_pTestBuffer = (struct rte_mbuf*)rte_pktmbuf_alloc(_eth_mbuf_pool);\r
- ASSERT_FALSE(m_pTestBuffer == NULL);\r
-\r
- }\r
-\r
- void TearDown() override\r
- {\r
- if(m_pTestBuffer != NULL)\r
- rte_pktmbuf_free(m_pTestBuffer);\r
- if(m_pSectGenInfo)\r
- delete[] m_pSectGenInfo;\r
- return;\r
- }\r
-};\r
-\r
-\r
-TEST_P(PrachCheck, PacketGen)//TestCaseName TestName\r
-{\r
- int ret;\r
- int32_t i;\r
- void *pHandle = NULL;\r
-\r
- /* Preparing input data for prach config */\r
- ret = xran_init_prach(m_xranConf, &m_xran_dev_ctx);\r
- ASSERT_TRUE(ret == XRAN_STATUS_SUCCESS);\r
-\r
- /* Verify the result */\r
- EXPECT_EQ(m_pPrachCPConfig->filterIdx, m_filterIdx);\r
- EXPECT_EQ(m_pPrachCPConfig->startSymId, m_startSymId);\r
- EXPECT_EQ(m_pPrachCPConfig->startPrbc, m_startPrbc);\r
- EXPECT_EQ(m_pPrachCPConfig->numPrbc, m_numPrbc);\r
- EXPECT_EQ(m_pPrachCPConfig->timeOffset, m_timeOffset);\r
- EXPECT_EQ(m_pPrachCPConfig->freqOffset, m_freqOffset);\r
- EXPECT_EQ(m_pPrachCPConfig->x, m_x);\r
- EXPECT_EQ(m_pPrachCPConfig->nrofPrachInSlot, m_nrofPrachInSlot);\r
- EXPECT_EQ(m_pPrachCPConfig->y[0], m_y[0]);\r
- EXPECT_EQ(m_pPrachCPConfig->y[1], m_y[1]);\r
- EXPECT_EQ(m_pPrachCPConfig->numSymbol, m_numSymbol);\r
- EXPECT_EQ(m_pPrachCPConfig->occassionsInPrachSlot, m_occassionsInPrachSlot);\r
- for (i = 0; i < XRAN_PRACH_CANDIDATE_SLOT; i++){\r
- EXPECT_EQ(m_pPrachCPConfig->isPRACHslot[i], m_isPRACHslot[i]);\r
- }\r
- for (i = 0; i < XRAN_MAX_SECTOR_NR; i++){\r
- EXPECT_EQ(m_xran_dev_ctx.prach_start_symbol[i], m_prach_start_symbol);\r
- EXPECT_EQ(m_xran_dev_ctx.prach_last_symbol[i], m_prach_last_symbol);\r
- }\r
-\r
- ret = xran_open(pHandle, m_xranConf);\r
- ASSERT_TRUE(ret == XRAN_STATUS_SUCCESS);\r
-\r
- ret = generate_cpmsg_prach(pHandle, &m_params, m_pSectGenInfo, m_pTestBuffer, &m_xran_dev_ctx,\r
- m_frameId, m_subframeId, m_slotId,\r
- m_beamId, m_ccId, m_antId, 0);\r
- ASSERT_TRUE(ret == XRAN_STATUS_SUCCESS);\r
- /* Verify the result */\r
- EXPECT_EQ(m_params.sectionType, XRAN_CP_SECTIONTYPE_3);\r
- EXPECT_EQ(m_params.dir, XRAN_DIR_UL);\r
- EXPECT_EQ(m_params.hdr.filterIdx, m_filterIdx);\r
- EXPECT_EQ(m_params.hdr.frameId, m_frameId);\r
- EXPECT_EQ(m_params.hdr.subframeId, m_subframeId);\r
- EXPECT_EQ(m_params.hdr.slotId, m_slotId);\r
- EXPECT_EQ(m_params.hdr.startSymId, m_startSymId);\r
- EXPECT_EQ(m_params.hdr.iqWidth, (m_pRUConfig->iqWidth==16)?0:m_pRUConfig->iqWidth);\r
- EXPECT_EQ(m_params.hdr.compMeth,m_pRUConfig->compMeth );\r
- EXPECT_EQ(m_params.hdr.timeOffset, m_m_params_timeOffset);\r
- EXPECT_EQ(m_params.hdr.fftSize,m_pRUConfig->fftSize);\r
- EXPECT_EQ(m_params.hdr.scs, m_pPRACHConfig->nPrachSubcSpacing);\r
- EXPECT_EQ(m_params.hdr.cpLength, 0);\r
- EXPECT_EQ(m_params.numSections, 1);\r
-\r
- EXPECT_EQ(m_params.sections[0].info.type, XRAN_CP_SECTIONTYPE_3);\r
- EXPECT_EQ(m_params.sections[0].info.startSymId, m_startSymId);\r
- EXPECT_EQ(m_params.sections[0].info.iqWidth, (m_pRUConfig->iqWidth==16)?0:m_pRUConfig->iqWidth);\r
- EXPECT_EQ(m_params.sections[0].info.compMeth, m_pRUConfig->compMeth);\r
-\r
- EXPECT_EQ(m_params.sections[0].info.id, m_id);\r
- EXPECT_EQ(m_params.sections[0].info.rb, XRAN_RBIND_EVERY);\r
- EXPECT_EQ(m_params.sections[0].info.symInc, XRAN_SYMBOLNUMBER_NOTINC);\r
- EXPECT_EQ(m_params.sections[0].info.startPrbc, m_startPrbc);\r
- EXPECT_EQ(m_params.sections[0].info.numPrbc, m_numPrbc);\r
- EXPECT_EQ(m_params.sections[0].info.numSymbol, m_numSymbol*m_occassionsInPrachSlot);\r
- EXPECT_EQ(m_params.sections[0].info.reMask, 0xfff);\r
- EXPECT_EQ(m_params.sections[0].info.beamId, m_beamId);\r
- EXPECT_EQ(m_params.sections[0].info.freqOffset, m_freqOffset);\r
- EXPECT_EQ(m_xran_dev_ctx.prach_last_symbol[m_ccId], m_prach_last_symbol);\r
- EXPECT_EQ(m_params.sections[0].info.ef, 0);\r
- EXPECT_EQ(m_params.sections[0].exDataSize, 0);\r
-\r
-}\r
-\r
-\r
-INSTANTIATE_TEST_CASE_P(UnitTest, PrachCheck,\r
- testing::ValuesIn(get_sequence(PrachCheck::get_number_of_cases("prach_functional"))));\r
-\r
+/******************************************************************************
+*
+* Copyright (c) 2019 Intel.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+*******************************************************************************/
+
+
+#include "common.hpp"
+#include "xran_common.h"
+#include "xran_fh_o_du.h"
+#include "ethernet.h"
+#include "xran_transport.h"
+#include "xran_cp_api.h"
+
+#include <stdint.h>
+
+
+const std::string module_name = "Prach_test";
+
+
+class PrachCheck : public KernelTests
+{
+private:
+ struct xran_section_gen_info *m_pSectResult = NULL;
+
+protected:
+ struct xran_fh_config *m_xranConf;
+ struct xran_device_ctx m_xran_dev_ctx;
+ struct xran_prach_config *m_pPRACHConfig;
+ struct xran_ru_config *m_pRUConfig;
+ struct xran_prach_cp_config *m_pPrachCPConfig;
+
+ struct xran_section_gen_info *m_pSectGenInfo = NULL;
+ int m_maxSections = 8; /* not used */
+ int lastsymbol;
+
+ struct rte_mbuf *m_pTestBuffer;
+
+ struct xran_cp_gen_params m_params;
+ struct xran_recv_packet_info m_pktInfo;
+ struct xran_cp_gen_params m_result;
+
+ uint8_t m_dir;
+ std::string m_dirStr;
+ uint8_t m_sectionType;
+
+ uint8_t m_ccId, m_antId;
+ uint8_t m_seqId;
+ uint8_t m_frameId, m_subframeId, m_slotId;
+ uint8_t m_symStart, m_symNum;
+ uint16_t *m_prbStart = NULL, *m_prbNum = NULL;
+
+ uint8_t m_iqWidth, m_compMethod;
+ uint16_t m_beamId;
+ uint16_t m_reMask = 0xfff;
+ uint16_t m_sectionId;
+ uint8_t m_filterIndex;
+ //uint16_t m_timeOffset;
+ uint8_t m_fftSize;
+
+ //define reference values
+ uint8_t m_startSymId;
+ uint8_t m_x;
+ uint8_t m_filterIdx;
+ uint16_t m_startPrbc;
+ uint8_t m_numPrbc;
+ uint8_t m_numSymbol;
+ uint16_t m_timeOffset;
+ int32_t m_freqOffset;
+ uint8_t m_nrofPrachInSlot;
+ uint8_t m_occassionsInPrachSlot;
+ uint8_t m_y[XRAN_PRACH_CANDIDATE_Y];
+ uint8_t m_isPRACHslot[XRAN_PRACH_CANDIDATE_SLOT];
+ int m_prach_start_symbol;
+ int m_prach_last_symbol;
+ uint8_t m_SlotNrNum;
+ uint16_t m_m_params_timeOffset;
+ uint16_t m_id;
+
+ void SetUp() override
+ {
+ init_test("prach_functional");
+ memset(&m_xran_dev_ctx, 0, sizeof(struct xran_device_ctx));
+ //modify
+ m_xranConf = &m_xran_dev_ctx.fh_cfg;
+
+ m_pPRACHConfig = &m_xranConf->prach_conf;
+ m_pRUConfig = &m_xranConf->ru_conf;
+ m_pPrachCPConfig = &m_xran_dev_ctx.PrachCPConfig;
+ //initialize input parameters
+ m_xranConf->frame_conf.nNumerology = get_input_parameter<uint8_t>("Numerology");
+ m_xranConf->frame_conf.nFrameDuplexType = get_input_parameter<uint8_t>("FrameDuplexType");
+ m_xranConf->log_level = get_input_parameter<uint32_t>("loglevel");
+ m_pPRACHConfig->nPrachConfIdx = get_input_parameter<uint8_t>("PrachConfIdx");
+ m_pPRACHConfig->nPrachFreqStart = get_input_parameter<uint16_t>("PrachFreqStart");
+ m_pPRACHConfig->nPrachFreqOffset = get_input_parameter<int32_t>("PrachFreqOffset");
+ m_pPRACHConfig->nPrachSubcSpacing = get_input_parameter<uint8_t>("PrachSubcSpacing");
+
+ m_pRUConfig->iqWidth = get_input_parameter<uint8_t>("iqWidth");
+ m_pRUConfig->compMeth = get_input_parameter<uint8_t>("compMeth");
+ m_pRUConfig->fftSize = get_input_parameter<uint8_t>("fftSize");
+
+ m_frameId = get_input_parameter<uint8_t>("frameId");
+ m_subframeId = get_input_parameter<uint8_t>("subframeId");
+ m_slotId = get_input_parameter<uint8_t>("slotId");
+ m_beamId = get_input_parameter<uint16_t>("beamId");
+ m_ccId = get_input_parameter<uint8_t>("ccId");
+ m_antId = get_input_parameter<uint8_t>("antId");
+
+ //initialize reference output
+ m_startSymId = get_reference_parameter<uint8_t>("startSymId");
+ m_x = get_reference_parameter<uint8_t>("x_value");
+
+ m_filterIdx = get_reference_parameter<uint8_t>("filterIdx");
+ m_startPrbc = get_reference_parameter<uint16_t>("startPrbc");
+ m_numPrbc = get_reference_parameter<uint8_t>("numPrbc");
+ m_timeOffset = get_reference_parameter<uint16_t>("timeOffset");
+ m_freqOffset = get_reference_parameter<uint32_t>("freqOffset");
+ m_nrofPrachInSlot = get_reference_parameter<uint8_t>("nrofPrachInSlot");
+ m_m_params_timeOffset = get_reference_parameter<uint16_t>("m_params_timeOffset");
+ m_id = get_reference_parameter<uint16_t>("id");
+ std::vector<uint8_t> y_vec = get_reference_parameter<std::vector<uint8_t>>("y_value");
+ for(int i=0; i < XRAN_PRACH_CANDIDATE_Y; i++) {
+ m_y[i] = y_vec[i];
+ }
+
+ m_numSymbol = get_reference_parameter<uint8_t>("numSymbol");
+ m_occassionsInPrachSlot = get_reference_parameter<uint8_t>("occassionsInPrachSlot");
+
+ std::vector<uint8_t> index_vec = get_reference_parameter<std::vector<uint8_t>>("isPRACHslot");
+ m_SlotNrNum = get_reference_parameter<uint8_t>("SlotNrNum");
+ for(int i = 0; i < XRAN_PRACH_CANDIDATE_SLOT; i++){
+ m_isPRACHslot[i]=0;
+ }
+ for(int i=0; i<m_SlotNrNum;i++){
+ m_isPRACHslot[index_vec[i]]=1;
+ }
+
+
+ m_prach_start_symbol = get_reference_parameter<int>("prach_start_symbol");
+ m_prach_last_symbol = get_reference_parameter<int>("prach_last_symbol");
+
+ /* allocate and prepare required data storage */
+ m_pSectGenInfo = new struct xran_section_gen_info[8];
+ ASSERT_NE(m_pSectGenInfo, nullptr);
+ m_params.sections = m_pSectGenInfo;
+
+ /* allocating an mbuf for packet generatrion */
+ m_pTestBuffer = (struct rte_mbuf*)rte_pktmbuf_alloc(_eth_mbuf_pool);
+ ASSERT_FALSE(m_pTestBuffer == NULL);
+
+ }
+
+ void TearDown() override
+ {
+ if(m_pTestBuffer != NULL)
+ rte_pktmbuf_free(m_pTestBuffer);
+ if(m_pSectGenInfo)
+ delete[] m_pSectGenInfo;
+ return;
+ }
+};
+
+
+TEST_P(PrachCheck, PacketGen)//TestCaseName TestName
+{
+ int ret;
+ int32_t i;
+ void *pHandle = NULL;
+
+ /* Preparing input data for prach config */
+ ret = xran_init_prach(m_xranConf, &m_xran_dev_ctx);
+ ASSERT_TRUE(ret == XRAN_STATUS_SUCCESS);
+
+ /* Verify the result */
+ EXPECT_EQ(m_pPrachCPConfig->filterIdx, m_filterIdx);
+ EXPECT_EQ(m_pPrachCPConfig->startSymId, m_startSymId);
+ EXPECT_EQ(m_pPrachCPConfig->startPrbc, m_startPrbc);
+ EXPECT_EQ(m_pPrachCPConfig->numPrbc, m_numPrbc);
+ EXPECT_EQ(m_pPrachCPConfig->timeOffset, m_timeOffset);
+ EXPECT_EQ(m_pPrachCPConfig->freqOffset, m_freqOffset);
+ EXPECT_EQ(m_pPrachCPConfig->x, m_x);
+ EXPECT_EQ(m_pPrachCPConfig->nrofPrachInSlot, m_nrofPrachInSlot);
+ EXPECT_EQ(m_pPrachCPConfig->y[0], m_y[0]);
+ EXPECT_EQ(m_pPrachCPConfig->y[1], m_y[1]);
+ EXPECT_EQ(m_pPrachCPConfig->numSymbol, m_numSymbol);
+ EXPECT_EQ(m_pPrachCPConfig->occassionsInPrachSlot, m_occassionsInPrachSlot);
+ for (i = 0; i < XRAN_PRACH_CANDIDATE_SLOT; i++){
+ EXPECT_EQ(m_pPrachCPConfig->isPRACHslot[i], m_isPRACHslot[i]);
+ }
+ for (i = 0; i < XRAN_MAX_SECTOR_NR; i++){
+ EXPECT_EQ(m_xran_dev_ctx.prach_start_symbol[i], m_prach_start_symbol);
+ EXPECT_EQ(m_xran_dev_ctx.prach_last_symbol[i], m_prach_last_symbol);
+ }
+
+ ret = xran_open(pHandle, m_xranConf);
+ ASSERT_TRUE(ret == XRAN_STATUS_SUCCESS);
+
+ ret = generate_cpmsg_prach(pHandle, &m_params, m_pSectGenInfo, m_pTestBuffer, &m_xran_dev_ctx,
+ m_frameId, m_subframeId, m_slotId,
+ m_beamId, m_ccId, m_antId, 0);
+ ASSERT_TRUE(ret == XRAN_STATUS_SUCCESS);
+ /* Verify the result */
+ EXPECT_EQ(m_params.sectionType, XRAN_CP_SECTIONTYPE_3);
+ EXPECT_EQ(m_params.dir, XRAN_DIR_UL);
+ EXPECT_EQ(m_params.hdr.filterIdx, m_filterIdx);
+ EXPECT_EQ(m_params.hdr.frameId, m_frameId);
+ EXPECT_EQ(m_params.hdr.subframeId, m_subframeId);
+ EXPECT_EQ(m_params.hdr.slotId, m_slotId);
+ EXPECT_EQ(m_params.hdr.startSymId, m_startSymId);
+ EXPECT_EQ(m_params.hdr.iqWidth, (m_pRUConfig->iqWidth==16)?0:m_pRUConfig->iqWidth);
+ EXPECT_EQ(m_params.hdr.compMeth,m_pRUConfig->compMeth );
+ EXPECT_EQ(m_params.hdr.timeOffset, m_m_params_timeOffset);
+ EXPECT_EQ(m_params.hdr.fftSize,m_pRUConfig->fftSize);
+ EXPECT_EQ(m_params.hdr.scs, m_pPRACHConfig->nPrachSubcSpacing);
+ EXPECT_EQ(m_params.hdr.cpLength, 0);
+ EXPECT_EQ(m_params.numSections, 1);
+
+ EXPECT_EQ(m_params.sections[0].info.type, XRAN_CP_SECTIONTYPE_3);
+ EXPECT_EQ(m_params.sections[0].info.startSymId, m_startSymId);
+ EXPECT_EQ(m_params.sections[0].info.iqWidth, (m_pRUConfig->iqWidth==16)?0:m_pRUConfig->iqWidth);
+ EXPECT_EQ(m_params.sections[0].info.compMeth, m_pRUConfig->compMeth);
+
+ EXPECT_EQ(m_params.sections[0].info.id, m_id);
+ EXPECT_EQ(m_params.sections[0].info.rb, XRAN_RBIND_EVERY);
+ EXPECT_EQ(m_params.sections[0].info.symInc, XRAN_SYMBOLNUMBER_NOTINC);
+ EXPECT_EQ(m_params.sections[0].info.startPrbc, m_startPrbc);
+ EXPECT_EQ(m_params.sections[0].info.numPrbc, m_numPrbc);
+ EXPECT_EQ(m_params.sections[0].info.numSymbol, m_numSymbol*m_occassionsInPrachSlot);
+ EXPECT_EQ(m_params.sections[0].info.reMask, 0xfff);
+ EXPECT_EQ(m_params.sections[0].info.beamId, m_beamId);
+ EXPECT_EQ(m_params.sections[0].info.freqOffset, m_freqOffset);
+ EXPECT_EQ(m_xran_dev_ctx.prach_last_symbol[m_ccId], m_prach_last_symbol);
+ EXPECT_EQ(m_params.sections[0].info.ef, 0);
+ EXPECT_EQ(m_params.sections[0].exDataSize, 0);
+
+}
+
+
+INSTANTIATE_TEST_CASE_P(UnitTest, PrachCheck,
+ testing::ValuesIn(get_sequence(PrachCheck::get_number_of_cases("prach_functional"))));
+
Code Review / o-du / phy.git / blobdiff