PentHertz
/
srsLTE
mirror of https://github.com/PentHertz/srsLTE.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor assert to TESTASSERT in unit test

This commit is contained in:
David Rupprecht 2021-01-26 19:15:28 +01:00 committed by Andre Puschmann
parent 1420c23863
commit 99c3aa9ba2
17 changed files with 411 additions and 381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/test/common/CMakeLists.txt
View File

@ -46,6 +46,7 @@ add_executable(timeout_test timeout_test.cc)
target_link_libraries(timeout_test srslte_phy ${CMAKE_THREAD_LIBS_INIT})
add_executable(bcd_helpers_test bcd_helpers_test.cc)
target_link_libraries(bcd_helpers_test srslte_common)
add_executable(stack_procedure_test stack_procedure_test.cc)
add_test(stack_procedure_test stack_procedure_test)

27
lib/test/common/bcd_helpers_test.cc
View File

@ -11,7 +11,7 @@
*/
#include "srslte/common/bcd_helpers.h"
#include <assert.h>
#include "srslte/common/test_common.h"
using namespace srslte;
@ -24,15 +24,15 @@ int main(int argc, char** argv)
// String to code
assert(string_to_mcc(mcc_str, &mcc));
assert(mcc == 0xF001);
TESTASSERT(string_to_mcc(mcc_str, &mcc));
TESTASSERT(mcc == 0xF001);
assert(string_to_mnc(mnc_str, &mnc));
assert(mnc == 0xF001);
TESTASSERT(string_to_mnc(mnc_str, &mnc));
TESTASSERT(mnc == 0xF001);
mnc_str = "01";
assert(string_to_mnc(mnc_str, &mnc));
assert(mnc == 0xFF01);
TESTASSERT(string_to_mnc(mnc_str, &mnc));
TESTASSERT(mnc == 0xFF01);
// Code to string
@ -41,13 +41,14 @@ int main(int argc, char** argv)
mcc = 0xF001;
mnc = 0xF001;
assert(mcc_to_string(mcc, &mcc_str));
assert(mcc_str.compare("001") == 0);
TESTASSERT(mcc_to_string(mcc, &mcc_str));
TESTASSERT(mcc_str.compare("001") == 0);
assert(mnc_to_string(mnc, &mnc_str));
assert(mnc_str.compare("001") == 0);
TESTASSERT(mnc_to_string(mnc, &mnc_str));
TESTASSERT(mnc_str.compare("001") == 0);
mnc = 0xFF01;
assert(mnc_to_string(mnc, &mnc_str));
assert(mnc_str.compare("01") == 0);
TESTASSERT(mnc_to_string(mnc, &mnc_str));
TESTASSERT(mnc_str.compare("01") == 0);
return SRSLTE_SUCCESS;
}

107
lib/test/common/test_eea1.cc
View File

@ -10,12 +10,12 @@
*
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include "srslte/common/liblte_security.h"
#include "srslte/common/test_common.h"
#include "srslte/srslte.h"
/*
@ -42,7 +42,7 @@ int32 arrcmp(uint8_t const* const a, uint8_t const* const b, uint32 len)
* Integrity Algorithms UEA2 & UIA2 D4 v1.0
*/
void test_set_1()
int test_set_1()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -61,24 +61,25 @@ void test_set_1()
// encryption
err_lte = liblte_security_encryption_eea1(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea1(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
void test_set_2()
int test_set_2()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -105,24 +106,25 @@ void test_set_2()
// encryption
err_lte = liblte_security_encryption_eea1(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea1(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
void test_set_3()
int test_set_3()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -143,24 +145,25 @@ void test_set_3()
// encryption
err_lte = liblte_security_encryption_eea1(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea1(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
void test_set_4()
int test_set_4()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -191,24 +194,25 @@ void test_set_4()
// encryption
err_lte = liblte_security_encryption_eea1(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea1(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
void test_set_5()
int test_set_5()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -243,24 +247,25 @@ void test_set_5()
// encryption
err_lte = liblte_security_encryption_eea1(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea1(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
void test_set_6()
int test_set_6()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -336,11 +341,11 @@ void test_set_6()
get_time_interval(t);
printf(
"encryption: %u bits, t=%d us, rate=%.1f Mbps/s\n", len_bits, (int)t[0].tv_usec, (float)len_bits / t[0].tv_usec);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
gettimeofday(&t[1], NULL);
@ -349,17 +354,18 @@ void test_set_6()
get_time_interval(t);
printf(
"decryption: %u bits, t=%d us, rate=%.1f Mbps/s\n", len_bits, (int)t[0].tv_usec, (float)len_bits / t[0].tv_usec);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
// set len_bitsgth to multiple of 8 respectively 128
void test_set_1_block_size()
int test_set_1_block_size()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -378,25 +384,26 @@ void test_set_1_block_size()
// encryption
err_lte = liblte_security_encryption_eea1(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea1(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
// inserted bit flip in msg[0]
void test_set_1_invalid()
int test_set_1_invalid()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -415,21 +422,22 @@ void test_set_1_invalid()
// encryption
err_lte = liblte_security_encryption_eea1(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp != 0);
TESTASSERT(err_cmp != 0);
// decryption
err_lte = liblte_security_decryption_eea1(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp != 0);
TESTASSERT(err_cmp != 0);
free(out);
return SRSLTE_SUCCESS;
}
/*
@ -438,12 +446,13 @@ void test_set_1_invalid()
int main(int argc, char* argv[])
{
test_set_1();
test_set_2();
test_set_3();
test_set_4();
test_set_5();
test_set_6();
test_set_1_block_size();
test_set_1_invalid();
TESTASSERT(test_set_1() == SRSLTE_SUCCESS);
TESTASSERT(test_set_2() == SRSLTE_SUCCESS);
TESTASSERT(test_set_3() == SRSLTE_SUCCESS);
TESTASSERT(test_set_4() == SRSLTE_SUCCESS);
TESTASSERT(test_set_5() == SRSLTE_SUCCESS);
TESTASSERT(test_set_6() == SRSLTE_SUCCESS);
TESTASSERT(test_set_1_block_size() == SRSLTE_SUCCESS);
TESTASSERT(test_set_1_invalid() == SRSLTE_SUCCESS);
return SRSLTE_SUCCESS;
}

105
lib/test/common/test_eea2.cc
View File

@ -15,6 +15,7 @@
#include <stdlib.h>
#include "srslte/common/liblte_security.h"
#include "srslte/common/test_common.h"
#include "srslte/srslte.h"
/*
@ -39,7 +40,7 @@ int32 arrcmp(uint8_t const* const a, uint8_t const* const b, uint32 len)
* Document Reference: 33.401 V13.1.0 Annex C.1
*/
void test_set_1()
int test_set_1()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -58,24 +59,25 @@ void test_set_1()
// encryption
err_lte = liblte_security_encryption_eea2(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea2(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
void test_set_2()
int test_set_2()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -102,24 +104,25 @@ void test_set_2()
// encryption
err_lte = liblte_security_encryption_eea2(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea2(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
void test_set_3()
int test_set_3()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -140,24 +143,25 @@ void test_set_3()
// encryption
err_lte = liblte_security_encryption_eea2(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea2(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
void test_set_4()
int test_set_4()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -188,24 +192,25 @@ void test_set_4()
// encryption
err_lte = liblte_security_encryption_eea2(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea2(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
void test_set_5()
int test_set_5()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -240,24 +245,25 @@ void test_set_5()
// encryption
err_lte = liblte_security_encryption_eea2(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea2(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
void test_set_6()
int test_set_6()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -337,11 +343,11 @@ void test_set_6()
len_bits,
(int)t[0].tv_usec / 100,
(float)100 * len_bits / t[0].tv_usec);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
gettimeofday(&t[1], NULL);
@ -354,17 +360,18 @@ void test_set_6()
len_bits,
(int)t[0].tv_usec / 100,
(float)100 * len_bits / t[0].tv_usec);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
// set len_bitsgth to multiple of 8 respectively 128
void test_set_1_block_size()
int test_set_1_block_size()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -383,25 +390,26 @@ void test_set_1_block_size()
// encryption
err_lte = liblte_security_encryption_eea2(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea2(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
free(out);
return SRSLTE_SUCCESS;
}
// inserted bit flip in msg[0]
void test_set_1_invalid()
int test_set_1_invalid()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -420,21 +428,22 @@ void test_set_1_invalid()
// encryption
err_lte = liblte_security_encryption_eea2(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
assert(err_cmp != 0);
TESTASSERT(err_cmp != 0);
// decryption
err_lte = liblte_security_decryption_eea2(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp != 0);
TESTASSERT(err_cmp != 0);
free(out);
return SRSLTE_SUCCESS;
}
/*
@ -443,12 +452,12 @@ void test_set_1_invalid()
int main(int argc, char* argv[])
{
test_set_1();
test_set_2();
test_set_3();
test_set_4();
test_set_5();
test_set_6();
test_set_1_block_size();
test_set_1_invalid();
TESTASSERT(test_set_1() == SRSLTE_SUCCESS);
TESTASSERT(test_set_2() == SRSLTE_SUCCESS);
TESTASSERT(test_set_3() == SRSLTE_SUCCESS);
TESTASSERT(test_set_4() == SRSLTE_SUCCESS);
TESTASSERT(test_set_5() == SRSLTE_SUCCESS);
TESTASSERT(test_set_6() == SRSLTE_SUCCESS);
TESTASSERT(test_set_1_block_size() == SRSLTE_SUCCESS);
TESTASSERT(test_set_1_invalid() == SRSLTE_SUCCESS);
}

67
lib/test/common/test_eea3.cc
View File

@ -10,11 +10,11 @@
*
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "srslte/common/liblte_security.h"
#include "srslte/common/test_common.h"
#include "srslte/srslte.h"
int32 arrcmp(uint8_t const* const a, uint8_t const* const b, uint32 len)
@ -37,7 +37,7 @@ int32 arrcmp(uint8_t const* const a, uint8_t const* const b, uint32 len)
*
*/
void test_set_1()
int test_set_1()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -59,7 +59,7 @@ void test_set_1()
// encryption
err_lte = liblte_security_encryption_eea3(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
@ -70,15 +70,15 @@ void test_set_1()
printf("Test Set 1 Encryption: Failed\n");
}
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea3(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
if (err_cmp == 0) {
printf("Test Set 1 Decryption: Success\n");
@ -87,9 +87,10 @@ void test_set_1()
}
free(out);
return SRSLTE_SUCCESS;
}
void test_set_2()
int test_set_2()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -119,7 +120,7 @@ void test_set_2()
// encryption
err_lte = liblte_security_encryption_eea3(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
@ -129,15 +130,15 @@ void test_set_2()
printf("Test Set 2 Encryption: Failed\n");
}
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea3(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
if (err_cmp == 0) {
printf("Test Set 2 Decryption: Success\n");
@ -146,9 +147,10 @@ void test_set_2()
}
free(out);
return SRSLTE_SUCCESS;
}
void test_set_3()
int test_set_3()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -190,7 +192,7 @@ void test_set_3()
// encryption
err_lte = liblte_security_encryption_eea3(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
int i;
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
@ -201,15 +203,15 @@ void test_set_3()
printf("Test Set 3 Encryption: Failed\n");
}
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea3(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
if (err_cmp == 0) {
printf("Test Set 3 Decryption: Success\n");
@ -218,9 +220,10 @@ void test_set_3()
}
free(out);
return SRSLTE_SUCCESS;
}
void test_set_4()
int test_set_4()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -278,7 +281,7 @@ void test_set_4()
// encryption
err_lte = liblte_security_encryption_eea3(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
int i;
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
@ -289,15 +292,15 @@ void test_set_4()
printf("Test Set 4 Encryption: Failed\n");
}
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea3(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
if (err_cmp == 0) {
printf("Test Set 4 Decryption: Success\n");
@ -306,9 +309,10 @@ void test_set_4()
}
free(out);
return SRSLTE_SUCCESS;
}
void test_set_5()
int test_set_5()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -382,7 +386,7 @@ void test_set_5()
// encryption
err_lte = liblte_security_encryption_eea3(key, count, bearer, direction, msg, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
int i;
// compare cipher text
err_cmp = arrcmp(ct, out, len_bytes);
@ -393,15 +397,15 @@ void test_set_5()
printf("Test Set 5 Encryption: Failed\n");
}
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// decryption
err_lte = liblte_security_decryption_eea3(key, count, bearer, direction, ct, len_bits, out);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
// compare cipher text
err_cmp = arrcmp(msg, out, len_bytes);
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
if (err_cmp == 0) {
printf("Test Set 5 Decryption: Success\n");
@ -410,13 +414,14 @@ void test_set_5()
}
free(out);
return SRSLTE_SUCCESS;
}
int main(int argc, char* argv[])
{
test_set_1();
test_set_2();
test_set_3();
test_set_4();
test_set_5();
TESTASSERT(test_set_1() == SRSLTE_SUCCESS);
TESTASSERT(test_set_2() == SRSLTE_SUCCESS);
TESTASSERT(test_set_3() == SRSLTE_SUCCESS);
TESTASSERT(test_set_4() == SRSLTE_SUCCESS);
TESTASSERT(test_set_5() == SRSLTE_SUCCESS);
}

23
lib/test/common/test_eia1.cc
View File

@ -16,6 +16,7 @@
#include <sys/time.h>
#include "srslte/common/security.h"
#include "srslte/common/test_common.h"
#include "srslte/srslte.h"
/*
@ -25,7 +26,7 @@
*
*/
void test_set_1()
int test_set_1()
{
uint8_t key[] = {0x2b, 0xd6, 0x45, 0x9f, 0x82, 0xc5, 0xb3, 0x00, 0x95, 0x2c, 0x49, 0x10, 0x48, 0x81, 0xff, 0x48};
uint32_t count = 0x38a6f056;
@ -41,11 +42,12 @@ void test_set_1()
srslte::security_128_eia1(key, count, bearer, direction, msg, len_bytes, mac);
for (int i = 0; i < 4; i++) {
assert(mac[i] == mt[i]);
TESTASSERT(mac[i] == mt[i]);
}
return SRSLTE_SUCCESS;
}
void test_set_4()
int test_set_4()
{
uint8_t key[] = {0x83, 0xfd, 0x23, 0xa2, 0x44, 0xa7, 0x4c, 0xf3, 0x58, 0xda, 0x30, 0x19, 0xf1, 0x72, 0x26, 0x35};
uint32_t count = 0x36af6144;
@ -66,11 +68,12 @@ void test_set_4()
srslte::security_128_eia1(key, count, bearer, direction, msg, len_bytes, mac);
for (int i = 0; i < 4; i++) {
assert(mac[i] == mt[i]);
TESTASSERT(mac[i] == mt[i]);
}
return SRSLTE_SUCCESS;
}
void test_set_7()
int test_set_7()
{
uint8_t key[] = {0xb3, 0x12, 0x0f, 0xfd, 0xb2, 0xcf, 0x6a, 0xf4, 0xe7, 0x3e, 0xaf, 0x2e, 0xf4, 0xeb, 0xec, 0x69};
uint32_t count = 0x296f393c;
@ -197,8 +200,9 @@ void test_set_7()
srslte::security_128_eia1(key, count, bearer, direction, msg, len_bytes, mac);
for (int i = 0; i < 4; i++) {
assert(mac[i] == mt[i]);
TESTASSERT(mac[i] == mt[i]);
}
return SRSLTE_SUCCESS;
}
/*
* Functions
@ -206,7 +210,8 @@ void test_set_7()
int main(int argc, char* argv[])
{
test_set_1();
test_set_4();
test_set_7();
TESTASSERT(test_set_1() == SRSLTE_SUCCESS);
TESTASSERT(test_set_4() == SRSLTE_SUCCESS);
TESTASSERT(test_set_7() == SRSLTE_SUCCESS);
return SRSLTE_SUCCESS;
}

38
lib/test/common/test_eia3.cc
View File

@ -10,13 +10,13 @@
*
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include "srslte/common/liblte_security.h"
#include "srslte/common/security.h"
#include "srslte/common/test_common.h"
#include "srslte/srslte.h"
/*
@ -27,7 +27,7 @@
*
*/
void test_set_1()
int test_set_1()
{
uint8_t key[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
uint32_t count = 0x0;
@ -48,16 +48,17 @@ void test_set_1()
if (mac[i] != expected_mac[i]) {
failed = true;
}
assert(mac[i] == expected_mac[i]);
TESTASSERT(mac[i] == expected_mac[i]);
}
if (failed == true) {
printf("Test Set 1: Failed\n");
} else {
printf("Test Set 1: Success\n");
}
return SRSLTE_SUCCESS;
}
void test_set_2()
int test_set_2()
{
uint8_t key[] = {0x47, 0x05, 0x41, 0x25, 0x56, 0x1e, 0xb2, 0xdd, 0xa9, 0x40, 0x59, 0xda, 0x05, 0x09, 0x78, 0x50};
uint32_t count = 0x561eb2dd;
@ -78,16 +79,17 @@ void test_set_2()
if (mac[i] != expected_mac[i]) {
failed = true;
}
assert(mac[i] == expected_mac[i]);
TESTASSERT(mac[i] == expected_mac[i]);
}
if (failed == true) {
printf("Test Set 2: Failed\n");
} else {
printf("Test Set 2: Success\n");
}
return SRSLTE_SUCCESS;
}
void test_set_3()
int test_set_3()
{
uint8_t key[] = {0xc9, 0xe6, 0xce, 0xc4, 0x60, 0x7c, 0x72, 0xdb, 0x00, 0x0a, 0xef, 0xa8, 0x83, 0x85, 0xab, 0x0a};
uint32_t count = 0xa94059da;
@ -112,16 +114,17 @@ void test_set_3()
if (mac[i] != expected_mac[i]) {
failed = true;
}
assert(mac[i] == expected_mac[i]);
TESTASSERT(mac[i] == expected_mac[i]);
}
if (failed == true) {
printf("Test Set 3: Failed\n");
} else {
printf("Test Set 3: Success\n");
}
return SRSLTE_SUCCESS;
}
void test_set_4()
int test_set_4()
{
uint8_t key[] = {0xc8, 0xa4, 0x82, 0x62, 0xd0, 0xc2, 0xe2, 0xba, 0xc4, 0xb9, 0x6e, 0xf7, 0x7e, 0x80, 0xca, 0x59};
uint32_t count = 0x05097850;
@ -156,16 +159,17 @@ void test_set_4()
if (mac[i] != expected_mac[i]) {
failed = true;
}
assert(mac[i] == expected_mac[i]);
TESTASSERT(mac[i] == expected_mac[i]);
}
if (failed == true) {
printf("Test Set 4: Failed\n");
} else {
printf("Test Set 4: Success\n");
}
return SRSLTE_SUCCESS;
}
void test_set_5()
int test_set_5()
{
uint8_t key[] = {0x6b, 0x8b, 0x08, 0xee, 0x79, 0xe0, 0xb5, 0x98, 0x2d, 0x6d, 0x12, 0x8e, 0xa9, 0xf2, 0x20, 0xcb};
uint32_t count = 0x561eb2dd;
@ -225,20 +229,22 @@ void test_set_5()
if (mac[i] != expected_mac[i]) {
failed = true;
}
assert(mac[i] == expected_mac[i]);
TESTASSERT(mac[i] == expected_mac[i]);
}
if (failed == true) {
printf("Test Set 5: Failed\n");
} else {
printf("Test Set 5: Success\n");
}
return SRSLTE_SUCCESS;
}
int main(int argc, char* argv[])
{
test_set_1();
test_set_2();
test_set_3();
test_set_4();
test_set_5();
TESTASSERT(test_set_1() == SRSLTE_SUCCESS);
TESTASSERT(test_set_2() == SRSLTE_SUCCESS);
TESTASSERT(test_set_3() == SRSLTE_SUCCESS);
TESTASSERT(test_set_4() == SRSLTE_SUCCESS);
TESTASSERT(test_set_5() == SRSLTE_SUCCESS);
return SRSLTE_SUCCESS;
}

43
lib/test/common/test_f12345.cc
View File

@ -10,12 +10,11 @@
*
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "srslte/common/liblte_security.h"
#include "srslte/common/test_common.h"
/*
* Prototypes
*/
@ -55,7 +54,7 @@ void arrprint(uint8_t const* const a, uint32 len)
* Functions
*/
void test_set_2()
int test_set_2()
{
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0;
@ -69,17 +68,17 @@ void test_set_2()
uint8_t opc_o[16];
err_lte = liblte_compute_opc(k, op, opc_o);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
arrprint(opc_o, sizeof(opc_o));
uint8_t opc_a[] = {0xcd, 0x63, 0xcb, 0x71, 0x95, 0x4a, 0x9f, 0x4e, 0x48, 0xa5, 0x99, 0x4e, 0x37, 0xa0, 0x2b, 0xaf};
err_cmp = arrcmp(opc_o, opc_a, sizeof(opc_o));
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
uint8_t mac_o[8];
err_lte = liblte_security_milenage_f1(k, opc_o, rand, sqn, amf, mac_o);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
arrprint(mac_o, sizeof(mac_o));
@ -87,21 +86,21 @@ void test_set_2()
// compare mac a
err_cmp = arrcmp(mac_o, mac_a, sizeof(mac_a));
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// f1 star
uint8_t mac_so[8];
err_lte = liblte_security_milenage_f1_star(k, opc_o, rand, sqn, amf, mac_so);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
uint8_t mac_s[] = {0x01, 0xcf, 0xaf, 0x9e, 0xc4, 0xe8, 0x71, 0xe9};
arrprint(mac_so, sizeof(mac_so));
err_cmp = arrcmp(mac_so, mac_s, sizeof(mac_s));
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// f2345
uint8_t res_o[8];
@ -111,7 +110,7 @@ void test_set_2()
err_lte = liblte_security_milenage_f2345(k, opc_o, rand, res_o, ck_o, ik_o, ak_o);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
uint8_t res[] = {0xa5, 0x42, 0x11, 0xd5, 0xe3, 0xba, 0x50, 0xbf};
uint8_t ck[] = {0xb4, 0x0b, 0xa9, 0xa3, 0xc5, 0x8b, 0x2a, 0x05, 0xbb, 0xf0, 0xd9, 0x87, 0xb2, 0x1b, 0xf8, 0xcb};
@ -122,35 +121,36 @@ void test_set_2()
arrprint(res_o, sizeof(res_o));
err_cmp = arrcmp(res_o, res, sizeof(res));
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// CK
arrprint(ck_o, sizeof(ck_o));
err_cmp = arrcmp(ck_o, ck, sizeof(ck));
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// IK
arrprint(ik_o, sizeof(ik_o));
err_cmp = arrcmp(ik_o, ik, sizeof(ik));
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// AK
arrprint(ak_o, sizeof(ak_o));
err_cmp = arrcmp(ak_o, ak, sizeof(ak));
assert(err_cmp == 0);
TESTASSERT(err_cmp == 0);
// f star
uint8_t ak_star_o[6];
err_lte = liblte_security_milenage_f5_star(k, opc_o, rand, ak_star_o);
assert(err_lte == LIBLTE_SUCCESS);
TESTASSERT(err_lte == LIBLTE_SUCCESS);
arrprint(ak_star_o, sizeof(ak_star_o));
uint8_t ak_star[] = {0x45, 0x1e, 0x8b, 0xec, 0xa4, 0x3b};
err_cmp = arrcmp(ak_star_o, ak_star, sizeof(ak_star));
assert(err_cmp == 0);
return;
TESTASSERT(err_cmp == 0);
return SRSLTE_SUCCESS;
;
}
/*
@ -160,11 +160,6 @@ void test_set_2()
int main(int argc, char* argv[])
{
test_set_2();
/*
test_set_3();
test_set_4();
test_set_5();
test_set_6();
*/
TESTASSERT(test_set_2() == SRSLTE_SUCCESS);
return SRSLTE_SUCCESS;
}

117
lib/test/upper/rlc_am_data_test.cc
View File

@ -10,8 +10,8 @@
*
*/
#include "srslte/common/test_common.h"
#include "srslte/upper/rlc_am_lte.h"
#include <assert.h>
#include <iostream>
// Fixed header only
@ -42,7 +42,7 @@ uint32_t PDU4_LEN = 5;
using namespace srslte;
void test1()
int test1()
{
srslte::rlc_amd_pdu_header_t h;
srslte::byte_buffer_t b1, b2;
@ -50,21 +50,22 @@ void test1()
memcpy(b1.msg, &pdu1[0], PDU1_LEN);
b1.N_bytes = PDU1_LEN;
rlc_am_read_data_pdu_header(&b1, &h);
assert(RLC_DC_FIELD_DATA_PDU == h.dc);
assert(0x01 == h.fi);
assert(0 == h.N_li);
assert(0 == h.lsf);
assert(0 == h.p);
assert(0 == h.rf);
assert(0 == h.so);
assert(6 == h.sn);
TESTASSERT(RLC_DC_FIELD_DATA_PDU == h.dc);
TESTASSERT(0x01 == h.fi);
TESTASSERT(0 == h.N_li);
TESTASSERT(0 == h.lsf);
TESTASSERT(0 == h.p);
TESTASSERT(0 == h.rf);
TESTASSERT(0 == h.so);
TESTASSERT(6 == h.sn);
rlc_am_write_data_pdu_header(&h, &b2);
assert(b2.N_bytes == PDU1_LEN);
TESTASSERT(b2.N_bytes == PDU1_LEN);
for (uint32_t i = 0; i < b2.N_bytes; i++)
assert(b2.msg[i] == b1.msg[i]);
TESTASSERT(b2.msg[i] == b1.msg[i]);
return SRSLTE_SUCCESS;
}
void test2()
int test2()
{
srslte::rlc_amd_pdu_header_t h;
srslte::byte_buffer_t b1, b2;
@ -72,23 +73,24 @@ void test2()
memcpy(b1.msg, &pdu2[0], PDU2_LEN);
b1.N_bytes = PDU2_LEN;
rlc_am_read_data_pdu_header(&b1, &h);
assert(RLC_DC_FIELD_DATA_PDU == h.dc);
assert(0x01 == h.fi);
assert(2 == h.N_li);
assert(1500 == h.li[0]);
assert(1500 == h.li[1]);
assert(0 == h.lsf);
assert(0 == h.p);
assert(0 == h.rf);
assert(0 == h.so);
assert(0 == h.sn);
TESTASSERT(RLC_DC_FIELD_DATA_PDU == h.dc);
TESTASSERT(0x01 == h.fi);
TESTASSERT(2 == h.N_li);
TESTASSERT(1500 == h.li[0]);
TESTASSERT(1500 == h.li[1]);
TESTASSERT(0 == h.lsf);
TESTASSERT(0 == h.p);
TESTASSERT(0 == h.rf);
TESTASSERT(0 == h.so);
TESTASSERT(0 == h.sn);
rlc_am_write_data_pdu_header(&h, &b2);
assert(b2.N_bytes == PDU2_LEN);
TESTASSERT(b2.N_bytes == PDU2_LEN);
for (uint32_t i = 0; i < b2.N_bytes; i++)
assert(b2.msg[i] == b1.msg[i]);
TESTASSERT(b2.msg[i] == b1.msg[i]);
return SRSLTE_SUCCESS;
}
void test3()
int test3()
{
srslte::rlc_amd_pdu_header_t h;
srslte::byte_buffer_t b1, b2;
@ -96,24 +98,25 @@ void test3()
memcpy(b1.msg, &pdu3[0], PDU3_LEN);
b1.N_bytes = PDU3_LEN;
rlc_am_read_data_pdu_header(&b1, &h);
assert(RLC_DC_FIELD_DATA_PDU == h.dc);
assert(0x01 == h.fi);
assert(3 == h.N_li);
assert(1500 == h.li[0]);
assert(1500 == h.li[1]);
assert(1500 == h.li[2]);
assert(0 == h.lsf);
assert(0 == h.p);
assert(0 == h.rf);
assert(0 == h.so);
assert(0 == h.sn);
TESTASSERT(RLC_DC_FIELD_DATA_PDU == h.dc);
TESTASSERT(0x01 == h.fi);
TESTASSERT(3 == h.N_li);
TESTASSERT(1500 == h.li[0]);
TESTASSERT(1500 == h.li[1]);
TESTASSERT(1500 == h.li[2]);
TESTASSERT(0 == h.lsf);
TESTASSERT(0 == h.p);
TESTASSERT(0 == h.rf);
TESTASSERT(0 == h.so);
TESTASSERT(0 == h.sn);
rlc_am_write_data_pdu_header(&h, &b2);
assert(b2.N_bytes == PDU3_LEN);
TESTASSERT(b2.N_bytes == PDU3_LEN);
for (uint32_t i = 0; i < b2.N_bytes; i++)
assert(b2.msg[i] == b1.msg[i]);
TESTASSERT(b2.msg[i] == b1.msg[i]);
return SRSLTE_SUCCESS;
}
void test4()
int test4()
{
srslte::rlc_amd_pdu_header_t h;
srslte::byte_buffer_t b1, b2;
@ -121,26 +124,28 @@ void test4()
memcpy(b1.msg, &pdu4[0], PDU4_LEN);
b1.N_bytes = PDU4_LEN;
rlc_am_read_data_pdu_header(&b1, &h);
assert(RLC_DC_FIELD_DATA_PDU == h.dc);
assert(0x03 == h.fi);
assert(2 == h.N_li);
assert(1342 == h.li[0]);
assert(1500 == h.li[1]);
assert(0 == h.lsf);
assert(0 == h.p);
assert(0 == h.rf);
assert(0 == h.so);
assert(2 == h.sn);
TESTASSERT(RLC_DC_FIELD_DATA_PDU == h.dc);
TESTASSERT(0x03 == h.fi);
TESTASSERT(2 == h.N_li);
TESTASSERT(1342 == h.li[0]);
TESTASSERT(1500 == h.li[1]);
TESTASSERT(0 == h.lsf);
TESTASSERT(0 == h.p);
TESTASSERT(0 == h.rf);
TESTASSERT(0 == h.so);
TESTASSERT(2 == h.sn);
rlc_am_write_data_pdu_header(&h, &b2);
assert(b2.N_bytes == PDU4_LEN);
TESTASSERT(b2.N_bytes == PDU4_LEN);
for (uint32_t i = 0; i < b2.N_bytes; i++)
assert(b2.msg[i] == b1.msg[i]);
TESTASSERT(b2.msg[i] == b1.msg[i]);
return SRSLTE_SUCCESS;
}
int main(int argc, char** argv)
{
test1();
test2();
test3();
test4();
TESTASSERT(test1() == SRSLTE_SUCCESS);
TESTASSERT(test2() == SRSLTE_SUCCESS);
TESTASSERT(test3() == SRSLTE_SUCCESS);
TESTASSERT(test4() == SRSLTE_SUCCESS);
return SRSLTE_SUCCESS;
}

216
lib/test/upper/rlc_am_test.cc
View File

@ -15,7 +15,6 @@
#include "srslte/common/test_common.h"
#include "srslte/common/threads.h"
#include "srslte/upper/rlc_am_lte.h"
#include <assert.h>
#include <iostream>
#define NBUFS 5
#define HAVE_PCAP 0
@ -112,7 +111,7 @@ private:
bool running;
};
void basic_test_tx(rlc_am_lte* rlc, byte_buffer_t pdu_bufs[NBUFS])
int basic_test_tx(rlc_am_lte* rlc, byte_buffer_t pdu_bufs[NBUFS])
{
// Push 5 SDUs into RLC1
@ -125,19 +124,20 @@ void basic_test_tx(rlc_am_lte* rlc, byte_buffer_t pdu_bufs[NBUFS])
rlc->write_sdu(std::move(sdu_bufs[i]));
}
assert(13 == rlc->get_buffer_state()); // 2 Bytes for fixed header + 6 for LIs + 5 for payload
TESTASSERT(13 == rlc->get_buffer_state()); // 2 Bytes for fixed header + 6 for LIs + 5 for payload
// Read 5 PDUs from RLC1 (1 byte each)
for (int i = 0; i < NBUFS; i++) {
uint32_t len = rlc->read_pdu(pdu_bufs[i].msg, 3); // 2 bytes for header + 1 byte payload
pdu_bufs[i].N_bytes = len;
assert(3 == len);
TESTASSERT(3 == len);
}
assert(0 == rlc->get_buffer_state());
TESTASSERT(0 == rlc->get_buffer_state());
return SRSLTE_SUCCESS;
}
bool basic_test()
int basic_test()
{
rlc_am_tester tester;
timer_handler timers(8);
@ -147,7 +147,7 @@ bool basic_test()
rlc_am_lte rlc2(rrc_log2, 1, &tester, &tester, &timers);
// before configuring entity
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1;
@ -164,14 +164,14 @@ bool basic_test()
rlc2.write_pdu(pdu_bufs[i].msg, pdu_bufs[i].N_bytes);
}
assert(2 == rlc2.get_buffer_state());
TESTASSERT(2 == rlc2.get_buffer_state());
// Read status PDU from RLC2
byte_buffer_t status_buf;
int len = rlc2.read_pdu(status_buf.msg, 2);
status_buf.N_bytes = len;
assert(0 == rlc2.get_buffer_state());
TESTASSERT(0 == rlc2.get_buffer_state());
// Assert status is correct
rlc_status_pdu_t status_check = {};
@ -182,8 +182,8 @@ bool basic_test()
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
for (int i = 0; i < tester.n_sdus; i++) {
assert(tester.sdus[i]->N_bytes == 1);
assert(*(tester.sdus[i]->msg) == i);
TESTASSERT(tester.sdus[i]->N_bytes == 1);
TESTASSERT(*(tester.sdus[i]->msg) == i);
}
// Check statistics
@ -192,7 +192,7 @@ bool basic_test()
return SRSLTE_SUCCESS;
}
bool concat_test()
int concat_test()
{
rlc_am_tester tester;
srslte::timer_handler timers(8);
@ -218,14 +218,14 @@ bool concat_test()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(13 == rlc1.get_buffer_state()); // 2 Bytes for fixed header + 6 for LIs + 5 for payload
TESTASSERT(13 == rlc1.get_buffer_state()); // 2 Bytes for fixed header + 6 for LIs + 5 for payload
// Read 1 PDUs from RLC1 containing all 5 SDUs
byte_buffer_t pdu_buf;
int len = rlc1.read_pdu(pdu_buf.msg, 13); // 8 bytes for header + payload
pdu_buf.N_bytes = len;
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDU into RLC2
rlc2.write_pdu(pdu_buf.msg, pdu_buf.N_bytes);
@ -246,10 +246,10 @@ bool concat_test()
// Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
assert(tester.n_sdus == 5);
TESTASSERT(tester.n_sdus == 5);
for (int i = 0; i < tester.n_sdus; i++) {
assert(tester.sdus[i]->N_bytes == 1);
assert(*(tester.sdus[i]->msg) == i);
TESTASSERT(tester.sdus[i]->N_bytes == 1);
TESTASSERT(*(tester.sdus[i]->msg) == i);
}
// Check statistics
@ -258,7 +258,7 @@ bool concat_test()
return SRSLTE_SUCCESS;
}
bool segment_test(bool in_seq_rx)
int segment_test(bool in_seq_rx)
{
rlc_am_tester tester;
srslte::timer_handler timers(8);
@ -286,7 +286,7 @@ bool segment_test(bool in_seq_rx)
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(58 == rlc1.get_buffer_state()); // 2 bytes for header + 6 bytes for LI + 50 bytes for payload
TESTASSERT(58 == rlc1.get_buffer_state()); // 2 bytes for header + 6 bytes for LI + 50 bytes for payload
// Read PDUs from RLC1 (force segmentation)
byte_buffer_t pdu_bufs[20];
@ -296,7 +296,7 @@ bool segment_test(bool in_seq_rx)
pdu_bufs[n_pdus++].N_bytes = len;
}
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDUs into RLC2
if (in_seq_rx) {
@ -314,7 +314,7 @@ bool segment_test(bool in_seq_rx)
// Receiver will only generate status PDU if they arrive in order
// If SN=7 arrives first, but the Rx expects SN=0, status reporting will be delayed, see TS 36.322 v10 Section 5.2.3
if (in_seq_rx) {
assert(2 == rlc2.get_buffer_state());
TESTASSERT(2 == rlc2.get_buffer_state());
// Read status PDU from RLC2
byte_buffer_t status_buf;
@ -330,13 +330,13 @@ bool segment_test(bool in_seq_rx)
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
}
assert(0 == rlc2.get_buffer_state());
TESTASSERT(0 == rlc2.get_buffer_state());
assert(tester.n_sdus == 5);
TESTASSERT(tester.n_sdus == 5);
for (int i = 0; i < tester.n_sdus; i++) {
assert(tester.sdus[i]->N_bytes == 10);
TESTASSERT(tester.sdus[i]->N_bytes == 10);
for (int j = 0; j < 10; j++)
assert(tester.sdus[i]->msg[j] == j);
TESTASSERT(tester.sdus[i]->msg[j] == j);
}
// Check statistics
@ -345,7 +345,7 @@ bool segment_test(bool in_seq_rx)
return SRSLTE_SUCCESS;
}
bool retx_test()
int retx_test()
{
rlc_am_tester tester;
timer_handler timers(8);
@ -372,7 +372,7 @@ bool retx_test()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(13 == rlc1.get_buffer_state());
TESTASSERT(13 == rlc1.get_buffer_state());
// Read 5 PDUs from RLC1 (1 byte each)
byte_buffer_t pdu_bufs[NBUFS];
@ -381,7 +381,7 @@ bool retx_test()
pdu_bufs[i].N_bytes = len;
}
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDUs into RLC2 (skip SN 1)
for (int i = 0; i < NBUFS; i++) {
@ -391,7 +391,7 @@ bool retx_test()
// check buffered bytes at receiver, 3 PDUs with one 1 B each (SN=0 has been delivered already)
rlc_bearer_metrics_t metrics = rlc2.get_metrics();
assert(metrics.rx_buffered_bytes == 3);
TESTASSERT(metrics.rx_buffered_bytes == 3);
// Step timers until reordering timeout expires
for (int cnt = 0; cnt < 5; cnt++) {
@ -399,7 +399,7 @@ bool retx_test()
}
uint32_t buffer_state = rlc2.get_buffer_state();
assert(4 == buffer_state);
TESTASSERT(4 == buffer_state);
// Read status PDU from RLC2
byte_buffer_t status_buf;
@ -419,7 +419,7 @@ bool retx_test()
// Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
assert(3 == rlc1.get_buffer_state()); // 2 byte header + 1 byte payload
TESTASSERT(3 == rlc1.get_buffer_state()); // 2 byte header + 1 byte payload
// Read the retx PDU from RLC1
byte_buffer_t retx;
@ -429,7 +429,7 @@ bool retx_test()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx.msg, retx.N_bytes);
assert(tester.n_sdus == 5);
TESTASSERT(tester.n_sdus == 5);
for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 1)
return -1;
@ -441,7 +441,7 @@ bool retx_test()
}
// Purpose: test correct retx of lost segment and pollRetx timer expiration
bool segment_retx_test()
int segment_retx_test()
{
rlc_am_tester tester;
timer_handler timers(8);
@ -544,7 +544,7 @@ bool segment_retx_test()
return SRSLTE_SUCCESS;
}
bool resegment_test_1()
int resegment_test_1()
{
// SDUs: | 10 | 10 | 10 | 10 | 10 |
// PDUs: | 10 | 10 | 10 | 10 | 10 |
@ -576,7 +576,7 @@ bool resegment_test_1()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(58 == rlc1.get_buffer_state()); // 2 bytes for fixed header, 6 bytes for LIs, 50 bytes for data
TESTASSERT(58 == rlc1.get_buffer_state()); // 2 bytes for fixed header, 6 bytes for LIs, 50 bytes for data
// Read 5 PDUs from RLC1 (10 bytes each)
byte_buffer_t pdu_bufs[NBUFS];
@ -585,7 +585,7 @@ bool resegment_test_1()
pdu_bufs[i].N_bytes = len;
}
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDUs into RLC2 (skip SN 1)
for (int i = 0; i < NBUFS; i++) {
@ -599,7 +599,7 @@ bool resegment_test_1()
timers.step_all();
}
assert(4 == rlc2.get_buffer_state());
TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2
byte_buffer_t status_buf;
@ -609,7 +609,7 @@ bool resegment_test_1()
// Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
assert(12 == rlc1.get_buffer_state()); // 2 byte header + 10 data
TESTASSERT(12 == rlc1.get_buffer_state()); // 2 byte header + 10 data
// Read the retx PDU from RLC1 and force resegmentation
byte_buffer_t retx1;
@ -619,7 +619,7 @@ bool resegment_test_1()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx1.msg, retx1.N_bytes);
assert(9 == rlc1.get_buffer_state());
TESTASSERT(9 == rlc1.get_buffer_state());
// Read the remaining segment
byte_buffer_t retx2;
@ -629,7 +629,7 @@ bool resegment_test_1()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes);
assert(tester.n_sdus == 5);
TESTASSERT(tester.n_sdus == 5);
for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 10)
return -1;
@ -641,7 +641,7 @@ bool resegment_test_1()
return 0;
}
bool resegment_test_2()
int resegment_test_2()
{
// SDUs: | 10 | 10 | 10 | 10 | 10 |
@ -674,7 +674,7 @@ bool resegment_test_2()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(58 == rlc1.get_buffer_state());
TESTASSERT(58 == rlc1.get_buffer_state());
// Read 5 PDUs from RLC1 (5 bytes, 10 bytes, 20 bytes, 10 bytes, 5 bytes)
byte_buffer_t pdu_bufs[NBUFS];
@ -684,7 +684,7 @@ bool resegment_test_2()
pdu_bufs[3].N_bytes = rlc1.read_pdu(pdu_bufs[3].msg, 14); // 4 byte header + 10 byte payload
pdu_bufs[4].N_bytes = rlc1.read_pdu(pdu_bufs[4].msg, 7); // 2 byte header + 5 byte payload
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDUs into RLC2 (skip SN 2)
for (int i = 0; i < NBUFS; i++) {
@ -698,7 +698,7 @@ bool resegment_test_2()
timers.step_all();
}
assert(4 == rlc2.get_buffer_state());
TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2
byte_buffer_t status_buf;
@ -707,7 +707,7 @@ bool resegment_test_2()
// Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
assert(25 == rlc1.get_buffer_state()); // 4 byte header + 20 data
TESTASSERT(25 == rlc1.get_buffer_state()); // 4 byte header + 20 data
// Read the retx PDU from RLC1 and force resegmentation
byte_buffer_t retx1;
@ -716,7 +716,7 @@ bool resegment_test_2()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx1.msg, retx1.N_bytes);
assert(18 == rlc1.get_buffer_state());
TESTASSERT(18 == rlc1.get_buffer_state());
// Read the remaining segment
byte_buffer_t retx2;
@ -725,7 +725,7 @@ bool resegment_test_2()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes);
assert(tester.n_sdus == 5);
TESTASSERT(tester.n_sdus == 5);
for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 10)
return -1;
@ -737,7 +737,7 @@ bool resegment_test_2()
return 0;
}
bool resegment_test_3()
int resegment_test_3()
{
// SDUs: | 10 | 10 | 10 | 10 | 10 |
@ -769,7 +769,7 @@ bool resegment_test_3()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(58 == rlc1.get_buffer_state());
TESTASSERT(58 == rlc1.get_buffer_state());
// Read 5 PDUs from RLC1 (5 bytes, 5 bytes, 20 bytes, 10 bytes, 10 bytes)
byte_buffer_t pdu_bufs[NBUFS];
@ -779,7 +779,7 @@ bool resegment_test_3()
pdu_bufs[3].N_bytes = rlc1.read_pdu(pdu_bufs[3].msg, 12); // 2 byte header + 10 byte payload
pdu_bufs[4].N_bytes = rlc1.read_pdu(pdu_bufs[4].msg, 12); // 2 byte header + 10 byte payload
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDUs into RLC2 (skip SN 2)
for (int i = 0; i < NBUFS; i++) {
@ -793,7 +793,7 @@ bool resegment_test_3()
timers.step_all();
}
assert(4 == rlc2.get_buffer_state());
TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2
byte_buffer_t status_buf;
@ -816,7 +816,7 @@ bool resegment_test_3()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes);
assert(tester.n_sdus == 5);
TESTASSERT(tester.n_sdus == 5);
for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 10)
return -1;
@ -828,7 +828,7 @@ bool resegment_test_3()
return 0;
}
bool resegment_test_4()
int resegment_test_4()
{
// SDUs: | 10 | 10 | 10 | 10 | 10 |
// PDUs: | 5 | 5| 30 | 5 | 5|
@ -859,7 +859,7 @@ bool resegment_test_4()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(58 == rlc1.get_buffer_state());
TESTASSERT(58 == rlc1.get_buffer_state());
// Read 5 PDUs from RLC1 (5 bytes, 5 bytes, 30 bytes, 5 bytes, 5 bytes)
byte_buffer_t pdu_bufs[NBUFS];
@ -869,7 +869,7 @@ bool resegment_test_4()
pdu_bufs[3].N_bytes = rlc1.read_pdu(pdu_bufs[3].msg, 7); // 2 byte header + 5 byte payload
pdu_bufs[4].N_bytes = rlc1.read_pdu(pdu_bufs[4].msg, 7); // 2 byte header + 5 byte payload
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDUs into RLC2 (skip SN 2)
for (int i = 0; i < NBUFS; i++) {
@ -883,7 +883,7 @@ bool resegment_test_4()
timers.step_all();
}
assert(4 == rlc2.get_buffer_state());
TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2
byte_buffer_t status_buf;
@ -899,7 +899,7 @@ bool resegment_test_4()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx1.msg, retx1.N_bytes);
assert(23 == rlc1.get_buffer_state());
TESTASSERT(23 == rlc1.get_buffer_state());
// Read the remaining segment
byte_buffer_t retx2;
@ -908,7 +908,7 @@ bool resegment_test_4()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes);
assert(tester.n_sdus == 5);
TESTASSERT(tester.n_sdus == 5);
for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 10)
return -1;
@ -920,7 +920,7 @@ bool resegment_test_4()
return 0;
}
bool resegment_test_5()
int resegment_test_5()
{
// SDUs: | 10 | 10 | 10 | 10 | 10 |
// PDUs: |2|3| 40 |3|2|
@ -951,7 +951,7 @@ bool resegment_test_5()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(58 == rlc1.get_buffer_state());
TESTASSERT(58 == rlc1.get_buffer_state());
// Read 5 PDUs from RLC1 (2 bytes, 3 bytes, 40 bytes, 3 bytes, 2 bytes)
byte_buffer_t pdu_bufs[NBUFS];
@ -961,7 +961,7 @@ bool resegment_test_5()
pdu_bufs[3].N_bytes = rlc1.read_pdu(pdu_bufs[3].msg, 5); // 2 byte header + 3 byte payload
pdu_bufs[4].N_bytes = rlc1.read_pdu(pdu_bufs[4].msg, 4); // 2 byte header + 2 byte payload
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDUs into RLC2 (skip SN 2)
for (int i = 0; i < NBUFS; i++) {
@ -975,7 +975,7 @@ bool resegment_test_5()
timers.step_all();
}
assert(4 == rlc2.get_buffer_state());
TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2
byte_buffer_t status_buf;
@ -991,7 +991,7 @@ bool resegment_test_5()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx1.msg, retx1.N_bytes);
assert(31 == rlc1.get_buffer_state());
TESTASSERT(31 == rlc1.get_buffer_state());
// Read the remaining segment
byte_buffer_t retx2;
@ -1000,7 +1000,7 @@ bool resegment_test_5()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes);
assert(tester.n_sdus == 5);
TESTASSERT(tester.n_sdus == 5);
for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 10)
return -1;
@ -1012,7 +1012,7 @@ bool resegment_test_5()
return 0;
}
bool resegment_test_6()
int resegment_test_6()
{
// SDUs: |10|10|10| 54 | 54 | 54 | 54 | 54 | 54 |
// PDUs: |10|10|10| 270 | 54 |
@ -1051,7 +1051,7 @@ bool resegment_test_6()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(368 == rlc1.get_buffer_state());
TESTASSERT(368 == rlc1.get_buffer_state());
// Read PDUs from RLC1 (10, 10, 10, 270, 54)
byte_buffer_t pdu_bufs[5];
@ -1064,7 +1064,7 @@ bool resegment_test_6()
len = rlc1.read_pdu(pdu_bufs[4].msg, 56);
pdu_bufs[4].N_bytes = len;
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDUs into RLC2 (skip SN 3)
for (int i = 0; i < 5; i++) {
@ -1078,7 +1078,7 @@ bool resegment_test_6()
timers.step_all();
}
assert(4 == rlc2.get_buffer_state());
TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2
byte_buffer_t status_buf;
@ -1088,7 +1088,7 @@ bool resegment_test_6()
// Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
assert(278 == rlc1.get_buffer_state());
TESTASSERT(278 == rlc1.get_buffer_state());
// Read the retx PDU from RLC1 and force resegmentation
byte_buffer_t retx1;
@ -1098,7 +1098,7 @@ bool resegment_test_6()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx1.msg, retx1.N_bytes);
assert(159 == rlc1.get_buffer_state());
TESTASSERT(159 == rlc1.get_buffer_state());
// Read the remaining segment
byte_buffer_t retx2;
@ -1108,11 +1108,11 @@ bool resegment_test_6()
// Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes);
assert(tester.n_sdus == 9);
TESTASSERT(tester.n_sdus == 9);
for (int i = 0; i < 3; i++) {
assert(tester.sdus[i]->N_bytes == 10);
TESTASSERT(tester.sdus[i]->N_bytes == 10);
for (int j = 0; j < 10; j++)
assert(tester.sdus[i]->msg[j] == j);
TESTASSERT(tester.sdus[i]->msg[j] == j);
}
for (int i = 3; i < 9; i++) {
if (i >= tester.n_sdus)
@ -1129,7 +1129,7 @@ bool resegment_test_6()
}
// Retransmission of PDU segments of the same size
bool resegment_test_7()
int resegment_test_7()
{
// SDUs: | 30 | 30 |
// PDUs: | 13 | 13 | 11 | 13 | 10 |
@ -1172,13 +1172,13 @@ bool resegment_test_7()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(64 == rlc1.get_buffer_state());
TESTASSERT(64 == rlc1.get_buffer_state());
// Read PDUs from RLC1 (15 bytes each)
byte_buffer_t pdu_bufs[N_PDU_BUFS];
for (uint32_t i = 0; i < N_PDU_BUFS; i++) {
pdu_bufs[i].N_bytes = rlc1.read_pdu(pdu_bufs[i].msg, 15); // 2 bytes for header + 12 B payload
assert(pdu_bufs[i].N_bytes);
TESTASSERT(pdu_bufs[i].N_bytes);
}
// Step timers until poll_retx timeout expires
@ -1188,7 +1188,7 @@ bool resegment_test_7()
}
// RLC should try to retx a random PDU because it needs to request a status from the receiver
assert(0 != rlc1.get_buffer_state());
TESTASSERT(0 != rlc1.get_buffer_state());
// Skip PDU with SN 2
for (uint32_t i = 0; i < N_PDU_BUFS; i++) {
@ -1207,14 +1207,14 @@ bool resegment_test_7()
}
// RLC should try to retransmit a random PDU because it needs to re-request a status PDU from the receiver
assert(0 != rlc1.get_buffer_state());
TESTASSERT(0 != rlc1.get_buffer_state());
// first round of retx, forcing resegmentation
byte_buffer_t retx[4];
for (uint32_t i = 0; i < 4; i++) {
assert(0 != rlc1.get_buffer_state());
TESTASSERT(0 != rlc1.get_buffer_state());
retx[i].N_bytes = rlc1.read_pdu(retx[i].msg, 7);
assert(retx[i].N_bytes);
TESTASSERT(retx[i].N_bytes);
// Write the last two segments to RLC2
if (i > 1) {
@ -1226,7 +1226,7 @@ bool resegment_test_7()
}
// Read status PDU from RLC2
assert(rlc2.get_buffer_state());
TESTASSERT(rlc2.get_buffer_state());
byte_buffer_t status_buf;
status_buf.N_bytes = rlc2.read_pdu(status_buf.msg, 10); // 10 bytes is enough to hold the status
@ -1236,14 +1236,14 @@ bool resegment_test_7()
pcap.write_ul_am_ccch(status_buf.msg, status_buf.N_bytes);
#endif
assert(15 == rlc1.get_buffer_state());
TESTASSERT(15 == rlc1.get_buffer_state());
// second round of retx, forcing resegmentation
byte_buffer_t retx2[4];
for (uint32_t i = 0; i < 4; i++) {
assert(rlc1.get_buffer_state() != 0);
TESTASSERT(rlc1.get_buffer_state() != 0);
retx2[i].N_bytes = rlc1.read_pdu(retx2[i].msg, 9);
assert(retx2[i].N_bytes != 0);
TESTASSERT(retx2[i].N_bytes != 0);
rlc2.write_pdu(retx2[i].msg, retx2[i].N_bytes);
#if HAVE_PCAP
@ -1252,7 +1252,7 @@ bool resegment_test_7()
}
// check buffer states
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Step timers until poll_retx timeout expires
cnt = 5;
@ -1261,7 +1261,7 @@ bool resegment_test_7()
}
// Read status PDU from RLC2
assert(rlc2.get_buffer_state());
TESTASSERT(rlc2.get_buffer_state());
status_buf.N_bytes = rlc2.read_pdu(status_buf.msg, 10); // 10 bytes is enough to hold the status
// Write status PDU to RLC1
@ -1271,11 +1271,11 @@ bool resegment_test_7()
#endif
// check status again
assert(0 == rlc1.get_buffer_state());
assert(0 == rlc2.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc2.get_buffer_state());
// Check number of SDUs and their content
assert(tester.n_sdus == N_SDU_BUFS);
TESTASSERT(tester.n_sdus == N_SDU_BUFS);
for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != sdu_size)
return -1;
@ -1293,7 +1293,7 @@ bool resegment_test_7()
}
// Retransmission of PDU segments with different size
bool resegment_test_8()
int resegment_test_8()
{
// SDUs: | 30 | 30 |
// PDUs: | 15 | 15 | 15 | 15 | 15 |
@ -1336,16 +1336,16 @@ bool resegment_test_8()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(64 == rlc1.get_buffer_state());
TESTASSERT(64 == rlc1.get_buffer_state());
// Read PDUs from RLC1 (15 bytes each)
byte_buffer_t pdu_bufs[N_PDU_BUFS];
for (uint32_t i = 0; i < N_PDU_BUFS; i++) {
pdu_bufs[i].N_bytes = rlc1.read_pdu(pdu_bufs[i].msg, 15); // 12 bytes for header + payload
assert(pdu_bufs[i].N_bytes);
TESTASSERT(pdu_bufs[i].N_bytes);
}
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Skip PDU one and two
for (uint32_t i = 0; i < N_PDU_BUFS; i++) {
@ -1364,14 +1364,14 @@ bool resegment_test_8()
}
// what PDU to retransmit is random but it must not be zero
assert(0 != rlc1.get_buffer_state());
TESTASSERT(0 != rlc1.get_buffer_state());
// first round of retx, forcing resegmentation
byte_buffer_t retx[4];
for (uint32_t i = 0; i < 3; i++) {
assert(rlc1.get_buffer_state());
TESTASSERT(rlc1.get_buffer_state());
retx[i].N_bytes = rlc1.read_pdu(retx[i].msg, 8);
assert(retx[i].N_bytes);
TESTASSERT(retx[i].N_bytes);
// Write the last two segments to RLC2
if (i > 1) {
@ -1389,7 +1389,7 @@ bool resegment_test_8()
}
// Read status PDU from RLC2
assert(rlc2.get_buffer_state());
TESTASSERT(rlc2.get_buffer_state());
byte_buffer_t status_buf;
status_buf.N_bytes = rlc2.read_pdu(status_buf.msg, 10); // 10 bytes is enough to hold the status
@ -1399,14 +1399,14 @@ bool resegment_test_8()
pcap.write_ul_am_ccch(status_buf.msg, status_buf.N_bytes);
#endif
assert(15 == rlc1.get_buffer_state());
TESTASSERT(15 == rlc1.get_buffer_state());
// second round of retx, reduce grant size to force different segment sizes
byte_buffer_t retx2[20];
for (uint32_t i = 0; i < 7; i++) {
assert(rlc1.get_buffer_state() != 0);
TESTASSERT(rlc1.get_buffer_state() != 0);
retx2[i].N_bytes = rlc1.read_pdu(retx2[i].msg, 9);
assert(retx2[i].N_bytes != 0);
TESTASSERT(retx2[i].N_bytes != 0);
rlc2.write_pdu(retx2[i].msg, retx2[i].N_bytes);
#if HAVE_PCAP
pcap.write_dl_am_ccch(retx[i].msg, retx[i].N_bytes);
@ -1431,7 +1431,7 @@ bool resegment_test_8()
};
// Check number of SDUs and their content
assert(tester.n_sdus == N_SDU_BUFS);
TESTASSERT(tester.n_sdus == N_SDU_BUFS);
for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != sdu_size)
return -1;
@ -1585,7 +1585,7 @@ bool status_pdu_test()
rlc1.write_sdu(std::move(sdu_bufs[i]));
}
assert(13 == rlc1.get_buffer_state());
TESTASSERT(13 == rlc1.get_buffer_state());
// Read 5 PDUs from RLC1 (1 byte each)
byte_buffer_t pdu_bufs[NBUFS];
@ -1594,7 +1594,7 @@ bool status_pdu_test()
pdu_bufs[i].N_bytes = len;
}
assert(0 == rlc1.get_buffer_state());
TESTASSERT(0 == rlc1.get_buffer_state());
// Only pass last PDUs to RLC2
for (int i = 0; i < NBUFS; i++) {
@ -1610,14 +1610,14 @@ bool status_pdu_test()
}
uint32_t buffer_state = rlc2.get_buffer_state();
assert(8 == buffer_state);
TESTASSERT(8 == buffer_state);
// Read status PDU from RLC2
byte_buffer_t status_buf;
len = rlc2.read_pdu(status_buf.msg, 5); // provide only small grant
status_buf.N_bytes = len;
assert(status_buf.N_bytes != 0);
TESTASSERT(status_buf.N_bytes != 0);
// check status PDU doesn't contain ACK_SN in NACK list
rlc_status_pdu_t status_pdu = {};
@ -1629,7 +1629,7 @@ bool status_pdu_test()
// Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
assert(3 == rlc1.get_buffer_state()); // 2 byte header + 1 byte payload
TESTASSERT(3 == rlc1.get_buffer_state()); // 2 byte header + 1 byte payload
// Read the retx PDU from RLC1
byte_buffer_t retx;
@ -1649,7 +1649,7 @@ bool status_pdu_test()
status_buf.clear();
len = rlc2.read_pdu(status_buf.msg, 10); // big enough grant to fit full status PDU
status_buf.N_bytes = len;
assert(status_buf.N_bytes != 0);
TESTASSERT(status_buf.N_bytes != 0);
// Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
@ -1664,7 +1664,7 @@ bool status_pdu_test()
rlc2.write_pdu(retx.msg, retx.N_bytes);
}
assert(tester.n_sdus == NBUFS);
TESTASSERT(tester.n_sdus == NBUFS);
for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 1)
return -1;

1
lib/test/upper/rlc_stress_test.cc
View File

@ -13,6 +13,7 @@
#include "srslte/common/crash_handler.h"
#include "srslte/common/log_filter.h"
#include "srslte/common/rlc_pcap.h"
#include "srslte/common/test_common.h"
#include "srslte/common/threads.h"
#include "srslte/upper/rlc.h"
#include <boost/program_options.hpp>

24
lib/test/upper/rlc_um_data_test.cc
View File

@ -10,8 +10,8 @@
*
*/
#include "srslte/common/test_common.h"
#include "srslte/upper/rlc_um_lte.h"
#include <assert.h>
#include <iostream>
// Fixed header only
@ -30,13 +30,13 @@ int main(int argc, char** argv)
memcpy(b1.msg, &pdu1[0], PDU1_LEN);
b1.N_bytes = PDU1_LEN;
rlc_um_read_data_pdu_header(&b1, srslte::rlc_umd_sn_size_t::size10bits, &h);
assert(0x03 == h.fi);
assert(0 == h.N_li);
assert(226 == h.sn);
TESTASSERT(0x03 == h.fi);
TESTASSERT(0 == h.N_li);
TESTASSERT(226 == h.sn);
rlc_um_write_data_pdu_header(&h, &b2);
assert(b2.N_bytes == PDU1_LEN);
TESTASSERT(b2.N_bytes == PDU1_LEN);
for (uint32_t i = 0; i < b2.N_bytes; i++)
assert(b2.msg[i] == b1.msg[i]);
TESTASSERT(b2.msg[i] == b1.msg[i]);
b1.clear();
b2.clear();
@ -45,12 +45,12 @@ int main(int argc, char** argv)
memcpy(b1.msg, &pdu2[0], PDU2_LEN);
b1.N_bytes = PDU2_LEN;
rlc_um_read_data_pdu_header(&b1, srslte::rlc_umd_sn_size_t::size10bits, &h);
assert(0x03 == h.fi);
assert(225 == h.sn);
assert(1 == h.N_li);
assert(104 == h.li[0]);
TESTASSERT(0x03 == h.fi);
TESTASSERT(225 == h.sn);
TESTASSERT(1 == h.N_li);
TESTASSERT(104 == h.li[0]);
rlc_um_write_data_pdu_header(&h, &b2);
assert(b2.N_bytes == PDU2_LEN);
TESTASSERT(b2.N_bytes == PDU2_LEN);
for (uint32_t i = 0; i < b2.N_bytes; i++)
assert(b2.msg[i] == b1.msg[i]);
TESTASSERT(b2.msg[i] == b1.msg[i]);
}

1
srsue/test/mac_test.cc
View File

@ -19,7 +19,6 @@
#include "srslte/test/ue_test_interfaces.h"
#include "srsue/hdr/stack/mac/mac.h"
#include "srsue/hdr/stack/mac/mux.h"
#include <assert.h>
#include <iostream>
#include <string.h>

1
srsue/test/ttcn3/test/CMakeLists.txt
View File

@ -9,6 +9,7 @@
include_directories(${PROJECT_SOURCE_DIR}/srsue/test/ttcn3/hdr)
add_executable(rapidjson_test rapidjson_test.cc)
target_link_libraries(rapidjson_test srslte_common)
add_test(rapidjson_test rapidjson_test)
add_executable(ttcn3_if_handler_test ttcn3_if_handler_test.cc)

7
srsue/test/ttcn3/test/rapidjson_test.cc
View File

@ -10,8 +10,8 @@
*
*/
#include "srslte/common/test_common.h"
#include "ttcn3_helpers.h"
#include <assert.h>
#include <iostream>
#include <srsue/test/ttcn3/hdr/ttcn3_helpers.h>
#include <stdio.h>
@ -64,20 +64,21 @@ int SYSTEM_CTRL_CNF_test()
return 0;
}
void pretty_print(std::string json)
int pretty_print(std::string json)
{
Document document;
if (document.Parse((char*)json.c_str()).HasParseError()) {
fprintf(stderr, "Error parsing incoming data. Exiting\n");
exit(-1);
}
assert(document.IsObject());
TESTASSERT(document.IsObject() == true);
// Pretty-print
StringBuffer buffer;
PrettyWriter<StringBuffer> writer(buffer);
document.Accept(writer);
printf("%s\n", (char*)buffer.GetString());
return SRSLTE_SUCCESS;
}
// UDP v4 test

10
srsue/test/upper/nas_test.cc
View File

@ -14,6 +14,7 @@
#include "srslte/common/log_filter.h"
#include "srslte/common/logger_srslog_wrapper.h"
#include "srslte/common/logmap.h"
#include "srslte/common/test_common.h"
#include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h"
#include "srslte/test/ue_test_interfaces.h"
@ -26,7 +27,6 @@
#include "srsue/hdr/stack/upper/nas.h"
#include "srsue/hdr/stack/upper/usim.h"
#include "srsue/hdr/stack/upper/usim_base.h"
#include <assert.h>
#include <iostream>
using namespace srsue;
@ -34,14 +34,6 @@ using namespace asn1::rrc;
#define LCID 1
#define TESTASSERT(cond) \
{ \
if (!(cond)) { \
std::cout << "[" << __FUNCTION__ << "][Line " << __LINE__ << "]: FAIL at " << (#cond) << std::endl; \
return -1; \
} \
}
uint8_t auth_request_pdu[] = {0x07, 0x52, 0x01, 0x0c, 0x63, 0xa8, 0x54, 0x13, 0xe6, 0xa4, 0xce, 0xd9,
0x86, 0xfb, 0xe5, 0xce, 0x9b, 0x62, 0x5e, 0x10, 0x67, 0x57, 0xb3, 0xc2,
0xb9, 0x70, 0x90, 0x01, 0x0c, 0x72, 0x8a, 0x67, 0x57, 0x92, 0x52, 0xb8};

4
srsue/test/upper/usim_test.cc
View File

@ -11,8 +11,8 @@
*/
#include "srslte/common/log_filter.h"
#include "srslte/common/test_common.h"
#include "srsue/hdr/stack/upper/usim.h"
#include <assert.h>
#include <iostream>
using namespace srsue;
@ -69,5 +69,5 @@ int main(int argc, char** argv)
srsue::usim usim(&usim_log);
usim.init(&args);
assert(usim.generate_authentication_response(rand_enb, autn_enb, mcc, mnc, res, &res_len, k_asme) == AUTH_OK);
TESTASSERT(usim.generate_authentication_response(rand_enb, autn_enb, mcc, mnc, res, &res_len, k_asme) == AUTH_OK);
}