5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor assert to TESTASSERT in unit test

Browse Source
master
David Rupprecht 4 years ago 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

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

@ -46,6 +46,7 @@ add_executable(timeout_test timeout_test.cc)
target_link_libraries(timeout_test srslte_phy ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries(timeout_test srslte_phy ${CMAKE_THREAD_LIBS_INIT})
add_executable(bcd_helpers_test bcd_helpers_test.cc) 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_executable(stack_procedure_test stack_procedure_test.cc)
add_test(stack_procedure_test stack_procedure_test) add_test(stack_procedure_test stack_procedure_test)

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -10,12 +10,11 @@
* *
*/ */
#include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "srslte/common/liblte_security.h" #include "srslte/common/liblte_security.h"
#include "srslte/common/test_common.h"
/* /*
* Prototypes * Prototypes
*/ */
@ -55,7 +54,7 @@ void arrprint(uint8_t const* const a, uint32 len)
* Functions * Functions
*/ */
void test_set_2() int test_set_2()
{ {
LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS; LIBLTE_ERROR_ENUM err_lte = LIBLTE_ERROR_INVALID_INPUTS;
int32 err_cmp = 0; int32 err_cmp = 0;
@ -69,17 +68,17 @@ void test_set_2()
uint8_t opc_o[16]; uint8_t opc_o[16];
err_lte = liblte_compute_opc(k, op, opc_o); 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)); 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}; 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)); err_cmp = arrcmp(opc_o, opc_a, sizeof(opc_o));
assert(err_cmp == 0); TESTASSERT(err_cmp == 0);
uint8_t mac_o[8]; uint8_t mac_o[8];
err_lte = liblte_security_milenage_f1(k, opc_o, rand, sqn, amf, mac_o); 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)); arrprint(mac_o, sizeof(mac_o));
@ -87,21 +86,21 @@ void test_set_2()
// compare mac a // compare mac a
err_cmp = arrcmp(mac_o, mac_a, sizeof(mac_a)); err_cmp = arrcmp(mac_o, mac_a, sizeof(mac_a));
assert(err_cmp == 0); TESTASSERT(err_cmp == 0);
// f1 star // f1 star
uint8_t mac_so[8]; uint8_t mac_so[8];
err_lte = liblte_security_milenage_f1_star(k, opc_o, rand, sqn, amf, mac_so); 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}; uint8_t mac_s[] = {0x01, 0xcf, 0xaf, 0x9e, 0xc4, 0xe8, 0x71, 0xe9};
arrprint(mac_so, sizeof(mac_so)); arrprint(mac_so, sizeof(mac_so));
err_cmp = arrcmp(mac_so, mac_s, sizeof(mac_s)); err_cmp = arrcmp(mac_so, mac_s, sizeof(mac_s));
assert(err_cmp == 0); TESTASSERT(err_cmp == 0);
// f2345 // f2345
uint8_t res_o[8]; 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); 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 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}; 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)); arrprint(res_o, sizeof(res_o));
err_cmp = arrcmp(res_o, res, sizeof(res)); err_cmp = arrcmp(res_o, res, sizeof(res));
assert(err_cmp == 0); TESTASSERT(err_cmp == 0);
// CK // CK
arrprint(ck_o, sizeof(ck_o)); arrprint(ck_o, sizeof(ck_o));
err_cmp = arrcmp(ck_o, ck, sizeof(ck)); err_cmp = arrcmp(ck_o, ck, sizeof(ck));
assert(err_cmp == 0); TESTASSERT(err_cmp == 0);
// IK // IK
arrprint(ik_o, sizeof(ik_o)); arrprint(ik_o, sizeof(ik_o));
err_cmp = arrcmp(ik_o, ik, sizeof(ik)); err_cmp = arrcmp(ik_o, ik, sizeof(ik));
assert(err_cmp == 0); TESTASSERT(err_cmp == 0);
// AK // AK
arrprint(ak_o, sizeof(ak_o)); arrprint(ak_o, sizeof(ak_o));
err_cmp = arrcmp(ak_o, ak, sizeof(ak)); err_cmp = arrcmp(ak_o, ak, sizeof(ak));
assert(err_cmp == 0); TESTASSERT(err_cmp == 0);
// f star // f star
uint8_t ak_star_o[6]; uint8_t ak_star_o[6];
err_lte = liblte_security_milenage_f5_star(k, opc_o, rand, ak_star_o); 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)); arrprint(ak_star_o, sizeof(ak_star_o));
uint8_t ak_star[] = {0x45, 0x1e, 0x8b, 0xec, 0xa4, 0x3b}; uint8_t ak_star[] = {0x45, 0x1e, 0x8b, 0xec, 0xa4, 0x3b};
err_cmp = arrcmp(ak_star_o, ak_star, sizeof(ak_star)); err_cmp = arrcmp(ak_star_o, ak_star, sizeof(ak_star));
assert(err_cmp == 0); TESTASSERT(err_cmp == 0);
return; return SRSLTE_SUCCESS;
;
} }
/* /*
@ -160,11 +160,6 @@ void test_set_2()
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
test_set_2(); TESTASSERT(test_set_2() == SRSLTE_SUCCESS);
/* return SRSLTE_SUCCESS;
test_set_3();
test_set_4();
test_set_5();
test_set_6();
*/
} }

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

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

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

@ -15,7 +15,6 @@
#include "srslte/common/test_common.h" #include "srslte/common/test_common.h"
#include "srslte/common/threads.h" #include "srslte/common/threads.h"
#include "srslte/upper/rlc_am_lte.h" #include "srslte/upper/rlc_am_lte.h"
#include <assert.h>
#include <iostream> #include <iostream>
#define NBUFS 5 #define NBUFS 5
#define HAVE_PCAP 0 #define HAVE_PCAP 0
@ -112,7 +111,7 @@ private:
bool running; 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 // 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])); 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) // Read 5 PDUs from RLC1 (1 byte each)
for (int i = 0; i < NBUFS; i++) { 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 uint32_t len = rlc->read_pdu(pdu_bufs[i].msg, 3); // 2 bytes for header + 1 byte payload
pdu_bufs[i].N_bytes = len; 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; rlc_am_tester tester;
timer_handler timers(8); timer_handler timers(8);
@ -147,7 +147,7 @@ bool basic_test()
rlc_am_lte rlc2(rrc_log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(rrc_log2, 1, &tester, &tester, &timers);
// before configuring entity // 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())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -164,14 +164,14 @@ bool basic_test()
rlc2.write_pdu(pdu_bufs[i].msg, pdu_bufs[i].N_bytes); 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 // Read status PDU from RLC2
byte_buffer_t status_buf; byte_buffer_t status_buf;
int len = rlc2.read_pdu(status_buf.msg, 2); int len = rlc2.read_pdu(status_buf.msg, 2);
status_buf.N_bytes = len; status_buf.N_bytes = len;
assert(0 == rlc2.get_buffer_state()); TESTASSERT(0 == rlc2.get_buffer_state());
// Assert status is correct // Assert status is correct
rlc_status_pdu_t status_check = {}; rlc_status_pdu_t status_check = {};
@ -182,8 +182,8 @@ bool basic_test()
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes); rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
for (int i = 0; i < tester.n_sdus; i++) { for (int i = 0; i < tester.n_sdus; i++) {
assert(tester.sdus[i]->N_bytes == 1); TESTASSERT(tester.sdus[i]->N_bytes == 1);
assert(*(tester.sdus[i]->msg) == i); TESTASSERT(*(tester.sdus[i]->msg) == i);
} }
// Check statistics // Check statistics
@ -192,7 +192,7 @@ bool basic_test()
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
bool concat_test() int concat_test()
{ {
rlc_am_tester tester; rlc_am_tester tester;
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
@ -218,14 +218,14 @@ bool concat_test()
rlc1.write_sdu(std::move(sdu_bufs[i])); 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 // Read 1 PDUs from RLC1 containing all 5 SDUs
byte_buffer_t pdu_buf; byte_buffer_t pdu_buf;
int len = rlc1.read_pdu(pdu_buf.msg, 13); // 8 bytes for header + payload int len = rlc1.read_pdu(pdu_buf.msg, 13); // 8 bytes for header + payload
pdu_buf.N_bytes = len; pdu_buf.N_bytes = len;
assert(0 == rlc1.get_buffer_state()); TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDU into RLC2 // Write PDU into RLC2
rlc2.write_pdu(pdu_buf.msg, pdu_buf.N_bytes); rlc2.write_pdu(pdu_buf.msg, pdu_buf.N_bytes);
@ -246,10 +246,10 @@ bool concat_test()
// Write status PDU to RLC1 // Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes); 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++) { for (int i = 0; i < tester.n_sdus; i++) {
assert(tester.sdus[i]->N_bytes == 1); TESTASSERT(tester.sdus[i]->N_bytes == 1);
assert(*(tester.sdus[i]->msg) == i); TESTASSERT(*(tester.sdus[i]->msg) == i);
} }
// Check statistics // Check statistics
@ -258,7 +258,7 @@ bool concat_test()
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
bool segment_test(bool in_seq_rx) int segment_test(bool in_seq_rx)
{ {
rlc_am_tester tester; rlc_am_tester tester;
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
@ -286,7 +286,7 @@ bool segment_test(bool in_seq_rx)
rlc1.write_sdu(std::move(sdu_bufs[i])); 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) // Read PDUs from RLC1 (force segmentation)
byte_buffer_t pdu_bufs[20]; byte_buffer_t pdu_bufs[20];
@ -296,7 +296,7 @@ bool segment_test(bool in_seq_rx)
pdu_bufs[n_pdus++].N_bytes = len; pdu_bufs[n_pdus++].N_bytes = len;
} }
assert(0 == rlc1.get_buffer_state()); TESTASSERT(0 == rlc1.get_buffer_state());
// Write PDUs into RLC2 // Write PDUs into RLC2
if (in_seq_rx) { 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 // 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 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) { if (in_seq_rx) {
assert(2 == rlc2.get_buffer_state()); TESTASSERT(2 == rlc2.get_buffer_state());
// Read status PDU from RLC2 // Read status PDU from RLC2
byte_buffer_t status_buf; 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); 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++) { 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++) for (int j = 0; j < 10; j++)
assert(tester.sdus[i]->msg[j] == j); TESTASSERT(tester.sdus[i]->msg[j] == j);
} }
// Check statistics // Check statistics
@ -345,7 +345,7 @@ bool segment_test(bool in_seq_rx)
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
bool retx_test() int retx_test()
{ {
rlc_am_tester tester; rlc_am_tester tester;
timer_handler timers(8); timer_handler timers(8);
@ -372,7 +372,7 @@ bool retx_test()
rlc1.write_sdu(std::move(sdu_bufs[i])); 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) // Read 5 PDUs from RLC1 (1 byte each)
byte_buffer_t pdu_bufs[NBUFS]; byte_buffer_t pdu_bufs[NBUFS];
@ -381,7 +381,7 @@ bool retx_test()
pdu_bufs[i].N_bytes = len; 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) // Write PDUs into RLC2 (skip SN 1)
for (int i = 0; i < NBUFS; i++) { 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) // 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(); 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 // Step timers until reordering timeout expires
for (int cnt = 0; cnt < 5; cnt++) { for (int cnt = 0; cnt < 5; cnt++) {
@ -399,7 +399,7 @@ bool retx_test()
} }
uint32_t buffer_state = rlc2.get_buffer_state(); uint32_t buffer_state = rlc2.get_buffer_state();
assert(4 == buffer_state); TESTASSERT(4 == buffer_state);
// Read status PDU from RLC2 // Read status PDU from RLC2
byte_buffer_t status_buf; byte_buffer_t status_buf;
@ -419,7 +419,7 @@ bool retx_test()
// Write status PDU to RLC1 // Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes); 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 // Read the retx PDU from RLC1
byte_buffer_t retx; byte_buffer_t retx;
@ -429,7 +429,7 @@ bool retx_test()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx.msg, retx.N_bytes); 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++) { for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 1) if (tester.sdus[i]->N_bytes != 1)
return -1; return -1;
@ -441,7 +441,7 @@ bool retx_test()
} }
// Purpose: test correct retx of lost segment and pollRetx timer expiration // Purpose: test correct retx of lost segment and pollRetx timer expiration
bool segment_retx_test() int segment_retx_test()
{ {
rlc_am_tester tester; rlc_am_tester tester;
timer_handler timers(8); timer_handler timers(8);
@ -544,7 +544,7 @@ bool segment_retx_test()
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
bool resegment_test_1() int resegment_test_1()
{ {
// SDUs: | 10 | 10 | 10 | 10 | 10 | // SDUs: | 10 | 10 | 10 | 10 | 10 |
// PDUs: | 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])); 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) // Read 5 PDUs from RLC1 (10 bytes each)
byte_buffer_t pdu_bufs[NBUFS]; byte_buffer_t pdu_bufs[NBUFS];
@ -585,7 +585,7 @@ bool resegment_test_1()
pdu_bufs[i].N_bytes = len; 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) // Write PDUs into RLC2 (skip SN 1)
for (int i = 0; i < NBUFS; i++) { for (int i = 0; i < NBUFS; i++) {
@ -599,7 +599,7 @@ bool resegment_test_1()
timers.step_all(); timers.step_all();
} }
assert(4 == rlc2.get_buffer_state()); TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2 // Read status PDU from RLC2
byte_buffer_t status_buf; byte_buffer_t status_buf;
@ -609,7 +609,7 @@ bool resegment_test_1()
// Write status PDU to RLC1 // Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes); 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 // Read the retx PDU from RLC1 and force resegmentation
byte_buffer_t retx1; byte_buffer_t retx1;
@ -619,7 +619,7 @@ bool resegment_test_1()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx1.msg, retx1.N_bytes); rlc2.write_pdu(retx1.msg, retx1.N_bytes);
assert(9 == rlc1.get_buffer_state()); TESTASSERT(9 == rlc1.get_buffer_state());
// Read the remaining segment // Read the remaining segment
byte_buffer_t retx2; byte_buffer_t retx2;
@ -629,7 +629,7 @@ bool resegment_test_1()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes); 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++) { for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 10) if (tester.sdus[i]->N_bytes != 10)
return -1; return -1;
@ -641,7 +641,7 @@ bool resegment_test_1()
return 0; return 0;
} }
bool resegment_test_2() int resegment_test_2()
{ {
// SDUs: | 10 | 10 | 10 | 10 | 10 | // SDUs: | 10 | 10 | 10 | 10 | 10 |
@ -674,7 +674,7 @@ bool resegment_test_2()
rlc1.write_sdu(std::move(sdu_bufs[i])); 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) // Read 5 PDUs from RLC1 (5 bytes, 10 bytes, 20 bytes, 10 bytes, 5 bytes)
byte_buffer_t pdu_bufs[NBUFS]; 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[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 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) // Write PDUs into RLC2 (skip SN 2)
for (int i = 0; i < NBUFS; i++) { for (int i = 0; i < NBUFS; i++) {
@ -698,7 +698,7 @@ bool resegment_test_2()
timers.step_all(); timers.step_all();
} }
assert(4 == rlc2.get_buffer_state()); TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2 // Read status PDU from RLC2
byte_buffer_t status_buf; byte_buffer_t status_buf;
@ -707,7 +707,7 @@ bool resegment_test_2()
// Write status PDU to RLC1 // Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes); 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 // Read the retx PDU from RLC1 and force resegmentation
byte_buffer_t retx1; byte_buffer_t retx1;
@ -716,7 +716,7 @@ bool resegment_test_2()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx1.msg, retx1.N_bytes); rlc2.write_pdu(retx1.msg, retx1.N_bytes);
assert(18 == rlc1.get_buffer_state()); TESTASSERT(18 == rlc1.get_buffer_state());
// Read the remaining segment // Read the remaining segment
byte_buffer_t retx2; byte_buffer_t retx2;
@ -725,7 +725,7 @@ bool resegment_test_2()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes); 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++) { for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 10) if (tester.sdus[i]->N_bytes != 10)
return -1; return -1;
@ -737,7 +737,7 @@ bool resegment_test_2()
return 0; return 0;
} }
bool resegment_test_3() int resegment_test_3()
{ {
// SDUs: | 10 | 10 | 10 | 10 | 10 | // SDUs: | 10 | 10 | 10 | 10 | 10 |
@ -769,7 +769,7 @@ bool resegment_test_3()
rlc1.write_sdu(std::move(sdu_bufs[i])); 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) // Read 5 PDUs from RLC1 (5 bytes, 5 bytes, 20 bytes, 10 bytes, 10 bytes)
byte_buffer_t pdu_bufs[NBUFS]; 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[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 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) // Write PDUs into RLC2 (skip SN 2)
for (int i = 0; i < NBUFS; i++) { for (int i = 0; i < NBUFS; i++) {
@ -793,7 +793,7 @@ bool resegment_test_3()
timers.step_all(); timers.step_all();
} }
assert(4 == rlc2.get_buffer_state()); TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2 // Read status PDU from RLC2
byte_buffer_t status_buf; byte_buffer_t status_buf;
@ -816,7 +816,7 @@ bool resegment_test_3()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes); 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++) { for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 10) if (tester.sdus[i]->N_bytes != 10)
return -1; return -1;
@ -828,7 +828,7 @@ bool resegment_test_3()
return 0; return 0;
} }
bool resegment_test_4() int resegment_test_4()
{ {
// SDUs: | 10 | 10 | 10 | 10 | 10 | // SDUs: | 10 | 10 | 10 | 10 | 10 |
// PDUs: | 5 | 5| 30 | 5 | 5| // PDUs: | 5 | 5| 30 | 5 | 5|
@ -859,7 +859,7 @@ bool resegment_test_4()
rlc1.write_sdu(std::move(sdu_bufs[i])); 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) // Read 5 PDUs from RLC1 (5 bytes, 5 bytes, 30 bytes, 5 bytes, 5 bytes)
byte_buffer_t pdu_bufs[NBUFS]; 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[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 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) // Write PDUs into RLC2 (skip SN 2)
for (int i = 0; i < NBUFS; i++) { for (int i = 0; i < NBUFS; i++) {
@ -883,7 +883,7 @@ bool resegment_test_4()
timers.step_all(); timers.step_all();
} }
assert(4 == rlc2.get_buffer_state()); TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2 // Read status PDU from RLC2
byte_buffer_t status_buf; byte_buffer_t status_buf;
@ -899,7 +899,7 @@ bool resegment_test_4()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx1.msg, retx1.N_bytes); rlc2.write_pdu(retx1.msg, retx1.N_bytes);
assert(23 == rlc1.get_buffer_state()); TESTASSERT(23 == rlc1.get_buffer_state());
// Read the remaining segment // Read the remaining segment
byte_buffer_t retx2; byte_buffer_t retx2;
@ -908,7 +908,7 @@ bool resegment_test_4()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes); 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++) { for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 10) if (tester.sdus[i]->N_bytes != 10)
return -1; return -1;
@ -920,7 +920,7 @@ bool resegment_test_4()
return 0; return 0;
} }
bool resegment_test_5() int resegment_test_5()
{ {
// SDUs: | 10 | 10 | 10 | 10 | 10 | // SDUs: | 10 | 10 | 10 | 10 | 10 |
// PDUs: |2|3| 40 |3|2| // PDUs: |2|3| 40 |3|2|
@ -951,7 +951,7 @@ bool resegment_test_5()
rlc1.write_sdu(std::move(sdu_bufs[i])); 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) // Read 5 PDUs from RLC1 (2 bytes, 3 bytes, 40 bytes, 3 bytes, 2 bytes)
byte_buffer_t pdu_bufs[NBUFS]; 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[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 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) // Write PDUs into RLC2 (skip SN 2)
for (int i = 0; i < NBUFS; i++) { for (int i = 0; i < NBUFS; i++) {
@ -975,7 +975,7 @@ bool resegment_test_5()
timers.step_all(); timers.step_all();
} }
assert(4 == rlc2.get_buffer_state()); TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2 // Read status PDU from RLC2
byte_buffer_t status_buf; byte_buffer_t status_buf;
@ -991,7 +991,7 @@ bool resegment_test_5()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx1.msg, retx1.N_bytes); rlc2.write_pdu(retx1.msg, retx1.N_bytes);
assert(31 == rlc1.get_buffer_state()); TESTASSERT(31 == rlc1.get_buffer_state());
// Read the remaining segment // Read the remaining segment
byte_buffer_t retx2; byte_buffer_t retx2;
@ -1000,7 +1000,7 @@ bool resegment_test_5()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes); 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++) { for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 10) if (tester.sdus[i]->N_bytes != 10)
return -1; return -1;
@ -1012,7 +1012,7 @@ bool resegment_test_5()
return 0; return 0;
} }
bool resegment_test_6() int resegment_test_6()
{ {
// SDUs: |10|10|10| 54 | 54 | 54 | 54 | 54 | 54 | // SDUs: |10|10|10| 54 | 54 | 54 | 54 | 54 | 54 |
// PDUs: |10|10|10| 270 | 54 | // PDUs: |10|10|10| 270 | 54 |
@ -1051,7 +1051,7 @@ bool resegment_test_6()
rlc1.write_sdu(std::move(sdu_bufs[i])); 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) // Read PDUs from RLC1 (10, 10, 10, 270, 54)
byte_buffer_t pdu_bufs[5]; byte_buffer_t pdu_bufs[5];
@ -1064,7 +1064,7 @@ bool resegment_test_6()
len = rlc1.read_pdu(pdu_bufs[4].msg, 56); len = rlc1.read_pdu(pdu_bufs[4].msg, 56);
pdu_bufs[4].N_bytes = len; 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) // Write PDUs into RLC2 (skip SN 3)
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
@ -1078,7 +1078,7 @@ bool resegment_test_6()
timers.step_all(); timers.step_all();
} }
assert(4 == rlc2.get_buffer_state()); TESTASSERT(4 == rlc2.get_buffer_state());
// Read status PDU from RLC2 // Read status PDU from RLC2
byte_buffer_t status_buf; byte_buffer_t status_buf;
@ -1088,7 +1088,7 @@ bool resegment_test_6()
// Write status PDU to RLC1 // Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes); 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 // Read the retx PDU from RLC1 and force resegmentation
byte_buffer_t retx1; byte_buffer_t retx1;
@ -1098,7 +1098,7 @@ bool resegment_test_6()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx1.msg, retx1.N_bytes); rlc2.write_pdu(retx1.msg, retx1.N_bytes);
assert(159 == rlc1.get_buffer_state()); TESTASSERT(159 == rlc1.get_buffer_state());
// Read the remaining segment // Read the remaining segment
byte_buffer_t retx2; byte_buffer_t retx2;
@ -1108,11 +1108,11 @@ bool resegment_test_6()
// Write the retx PDU to RLC2 // Write the retx PDU to RLC2
rlc2.write_pdu(retx2.msg, retx2.N_bytes); 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++) { 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++) 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++) { for (int i = 3; i < 9; i++) {
if (i >= tester.n_sdus) if (i >= tester.n_sdus)
@ -1129,7 +1129,7 @@ bool resegment_test_6()
} }
// Retransmission of PDU segments of the same size // Retransmission of PDU segments of the same size
bool resegment_test_7() int resegment_test_7()
{ {
// SDUs: | 30 | 30 | // SDUs: | 30 | 30 |
// PDUs: | 13 | 13 | 11 | 13 | 10 | // PDUs: | 13 | 13 | 11 | 13 | 10 |
@ -1172,13 +1172,13 @@ bool resegment_test_7()
rlc1.write_sdu(std::move(sdu_bufs[i])); 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) // Read PDUs from RLC1 (15 bytes each)
byte_buffer_t pdu_bufs[N_PDU_BUFS]; byte_buffer_t pdu_bufs[N_PDU_BUFS];
for (uint32_t i = 0; i < N_PDU_BUFS; i++) { 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 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 // 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 // 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 // Skip PDU with SN 2
for (uint32_t i = 0; i < N_PDU_BUFS; i++) { 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 // 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 // first round of retx, forcing resegmentation
byte_buffer_t retx[4]; byte_buffer_t retx[4];
for (uint32_t i = 0; i < 4; i++) { 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); 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 // Write the last two segments to RLC2
if (i > 1) { if (i > 1) {
@ -1226,7 +1226,7 @@ bool resegment_test_7()
} }
// Read status PDU from RLC2 // Read status PDU from RLC2
assert(rlc2.get_buffer_state()); TESTASSERT(rlc2.get_buffer_state());
byte_buffer_t status_buf; byte_buffer_t status_buf;
status_buf.N_bytes = rlc2.read_pdu(status_buf.msg, 10); // 10 bytes is enough to hold the status 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); pcap.write_ul_am_ccch(status_buf.msg, status_buf.N_bytes);
#endif #endif
assert(15 == rlc1.get_buffer_state()); TESTASSERT(15 == rlc1.get_buffer_state());
// second round of retx, forcing resegmentation // second round of retx, forcing resegmentation
byte_buffer_t retx2[4]; byte_buffer_t retx2[4];
for (uint32_t i = 0; i < 4; i++) { 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); 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); rlc2.write_pdu(retx2[i].msg, retx2[i].N_bytes);
#if HAVE_PCAP #if HAVE_PCAP
@ -1252,7 +1252,7 @@ bool resegment_test_7()
} }
// check buffer states // check buffer states
assert(0 == rlc1.get_buffer_state()); TESTASSERT(0 == rlc1.get_buffer_state());
// Step timers until poll_retx timeout expires // Step timers until poll_retx timeout expires
cnt = 5; cnt = 5;
@ -1261,7 +1261,7 @@ bool resegment_test_7()
} }
// Read status PDU from RLC2 // 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 status_buf.N_bytes = rlc2.read_pdu(status_buf.msg, 10); // 10 bytes is enough to hold the status
// Write status PDU to RLC1 // Write status PDU to RLC1
@ -1271,11 +1271,11 @@ bool resegment_test_7()
#endif #endif
// check status again // check status again
assert(0 == rlc1.get_buffer_state()); TESTASSERT(0 == rlc1.get_buffer_state());
assert(0 == rlc2.get_buffer_state()); TESTASSERT(0 == rlc2.get_buffer_state());
// Check number of SDUs and their content // 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++) { for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != sdu_size) if (tester.sdus[i]->N_bytes != sdu_size)
return -1; return -1;
@ -1293,7 +1293,7 @@ bool resegment_test_7()
} }
// Retransmission of PDU segments with different size // Retransmission of PDU segments with different size
bool resegment_test_8() int resegment_test_8()
{ {
// SDUs: | 30 | 30 | // SDUs: | 30 | 30 |
// PDUs: | 15 | 15 | 15 | 15 | 15 | // PDUs: | 15 | 15 | 15 | 15 | 15 |
@ -1336,16 +1336,16 @@ bool resegment_test_8()
rlc1.write_sdu(std::move(sdu_bufs[i])); 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) // Read PDUs from RLC1 (15 bytes each)
byte_buffer_t pdu_bufs[N_PDU_BUFS]; byte_buffer_t pdu_bufs[N_PDU_BUFS];
for (uint32_t i = 0; i < N_PDU_BUFS; i++) { 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 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 // Skip PDU one and two
for (uint32_t i = 0; i < N_PDU_BUFS; i++) { 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 // 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 // first round of retx, forcing resegmentation
byte_buffer_t retx[4]; byte_buffer_t retx[4];
for (uint32_t i = 0; i < 3; i++) { 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); 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 // Write the last two segments to RLC2
if (i > 1) { if (i > 1) {
@ -1389,7 +1389,7 @@ bool resegment_test_8()
} }
// Read status PDU from RLC2 // Read status PDU from RLC2
assert(rlc2.get_buffer_state()); TESTASSERT(rlc2.get_buffer_state());
byte_buffer_t status_buf; byte_buffer_t status_buf;
status_buf.N_bytes = rlc2.read_pdu(status_buf.msg, 10); // 10 bytes is enough to hold the status 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); pcap.write_ul_am_ccch(status_buf.msg, status_buf.N_bytes);
#endif #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 // second round of retx, reduce grant size to force different segment sizes
byte_buffer_t retx2[20]; byte_buffer_t retx2[20];
for (uint32_t i = 0; i < 7; i++) { 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); 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); rlc2.write_pdu(retx2[i].msg, retx2[i].N_bytes);
#if HAVE_PCAP #if HAVE_PCAP
pcap.write_dl_am_ccch(retx[i].msg, retx[i].N_bytes); 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 // 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++) { for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != sdu_size) if (tester.sdus[i]->N_bytes != sdu_size)
return -1; return -1;
@ -1585,7 +1585,7 @@ bool status_pdu_test()
rlc1.write_sdu(std::move(sdu_bufs[i])); 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) // Read 5 PDUs from RLC1 (1 byte each)
byte_buffer_t pdu_bufs[NBUFS]; byte_buffer_t pdu_bufs[NBUFS];
@ -1594,7 +1594,7 @@ bool status_pdu_test()
pdu_bufs[i].N_bytes = len; pdu_bufs[i].N_bytes = len;
} }
assert(0 == rlc1.get_buffer_state()); TESTASSERT(0 == rlc1.get_buffer_state());
// Only pass last PDUs to RLC2 // Only pass last PDUs to RLC2
for (int i = 0; i < NBUFS; i++) { for (int i = 0; i < NBUFS; i++) {
@ -1610,14 +1610,14 @@ bool status_pdu_test()
} }
uint32_t buffer_state = rlc2.get_buffer_state(); uint32_t buffer_state = rlc2.get_buffer_state();
assert(8 == buffer_state); TESTASSERT(8 == buffer_state);
// Read status PDU from RLC2 // Read status PDU from RLC2
byte_buffer_t status_buf; byte_buffer_t status_buf;
len = rlc2.read_pdu(status_buf.msg, 5); // provide only small grant len = rlc2.read_pdu(status_buf.msg, 5); // provide only small grant
status_buf.N_bytes = len; 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 // check status PDU doesn't contain ACK_SN in NACK list
rlc_status_pdu_t status_pdu = {}; rlc_status_pdu_t status_pdu = {};
@ -1629,7 +1629,7 @@ bool status_pdu_test()
// Write status PDU to RLC1 // Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes); 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 // Read the retx PDU from RLC1
byte_buffer_t retx; byte_buffer_t retx;
@ -1649,7 +1649,7 @@ bool status_pdu_test()
status_buf.clear(); status_buf.clear();
len = rlc2.read_pdu(status_buf.msg, 10); // big enough grant to fit full status PDU len = rlc2.read_pdu(status_buf.msg, 10); // big enough grant to fit full status PDU
status_buf.N_bytes = len; status_buf.N_bytes = len;
assert(status_buf.N_bytes != 0); TESTASSERT(status_buf.N_bytes != 0);
// Write status PDU to RLC1 // Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes); 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); 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++) { for (int i = 0; i < tester.n_sdus; i++) {
if (tester.sdus[i]->N_bytes != 1) if (tester.sdus[i]->N_bytes != 1)
return -1; return -1;

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

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

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

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

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

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

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

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

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

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

@ -14,6 +14,7 @@
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/common/logger_srslog_wrapper.h" #include "srslte/common/logger_srslog_wrapper.h"
#include "srslte/common/logmap.h" #include "srslte/common/logmap.h"
#include "srslte/common/test_common.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/srslog/srslog.h" #include "srslte/srslog/srslog.h"
#include "srslte/test/ue_test_interfaces.h" #include "srslte/test/ue_test_interfaces.h"
@ -26,7 +27,6 @@
#include "srsue/hdr/stack/upper/nas.h" #include "srsue/hdr/stack/upper/nas.h"
#include "srsue/hdr/stack/upper/usim.h" #include "srsue/hdr/stack/upper/usim.h"
#include "srsue/hdr/stack/upper/usim_base.h" #include "srsue/hdr/stack/upper/usim_base.h"
#include <assert.h>
#include <iostream> #include <iostream>
using namespace srsue; using namespace srsue;
@ -34,14 +34,6 @@ using namespace asn1::rrc;
#define LCID 1 #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, 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, 0x86, 0xfb, 0xe5, 0xce, 0x9b, 0x62, 0x5e, 0x10, 0x67, 0x57, 0xb3, 0xc2,
0xb9, 0x70, 0x90, 0x01, 0x0c, 0x72, 0x8a, 0x67, 0x57, 0x92, 0x52, 0xb8}; 0xb9, 0x70, 0x90, 0x01, 0x0c, 0x72, 0x8a, 0x67, 0x57, 0x92, 0x52, 0xb8};

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

@ -11,8 +11,8 @@
*/ */
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/common/test_common.h"
#include "srsue/hdr/stack/upper/usim.h" #include "srsue/hdr/stack/upper/usim.h"
#include <assert.h>
#include <iostream> #include <iostream>
using namespace srsue; using namespace srsue;
@ -69,5 +69,5 @@ int main(int argc, char** argv)
srsue::usim usim(&usim_log); srsue::usim usim(&usim_log);
usim.init(&args); 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);
} }

Write Preview
Loading…
Cancel
Save