void test_pwm_channel_period() {
pwm_reset_peripheral();
pwm_set_channel_period(PWM_CHANNEL_3, 1000);
TEST_ASSERT_EQUAL_UINT32(1000, pwm_get_channel_period(PWM_CHANNEL_3));
pwm_set_channel_period(PWM_CHANNEL_3, 65535);
TEST_ASSERT_EQUAL_UINT32(65535, pwm_get_channel_period(PWM_CHANNEL_3));
}
TEST(file_reopen_opened_file,
then_the_file_should_be_deleted_from_the_cache)
{
TEST_ASSERT_EQUAL_UINT32(fm_res, FM_SUCCESS);
TEST_ASSERT_EQUAL_UINT32((&fileCache[6])->lessRecent, 5);
TEST_ASSERT_EQUAL_UINT32((&fileCache[6])->moreRecent, 8);
}
void test_pwm_channel_prescaler() {
pwm_reset_peripheral();
pwm_set_channel_prescaler(PWM_CHANNEL_3, PWM_PRES_MCK_DIV_1024);
TEST_ASSERT_EQUAL_UINT32(PWM_PRES_MCK_DIV_1024,
pwm_get_channel_prescaler(PWM_CHANNEL_3));
pwm_set_channel_prescaler(PWM_CHANNEL_3, PWM_PRES_MCK_DIV_32);
TEST_ASSERT_EQUAL_UINT32(PWM_PRES_MCK_DIV_32,
pwm_get_channel_prescaler(PWM_CHANNEL_3));
}
void test_pwm_channel_duty_cycle() {
pwm_reset_peripheral();
pwm_set_channel_duty_cycle(PWM_CHANNEL_3, 50);
TEST_ASSERT_EQUAL_UINT32(50, pwm_read_channel(PWM_CHANNEL_3));
// change duty cycle when channel is enabled
pwm_enable_channel(PWM_CHANNEL_3);
pwm_set_channel_duty_cycle(PWM_CHANNEL_3, 60);
TEST_ASSERT_EQUAL_UINT32(60, pwm_read_channel(PWM_CHANNEL_3));
}
void test_pwm_set_frequency(){
pwm_reset_peripheral();
pwm_set_channel_alignment(PWM_CHANNEL_3, PWM_CHANNEL_ALIGN_LEFT);
pwm_set_channel_frequency(PWM_CHANNEL_3, 25000);
TEST_ASSERT_EQUAL_UINT32(0,
pwm_get_channel_prescaler(PWM_CHANNEL_3));
TEST_ASSERT_EQUAL_UINT32(3360,
pwm_get_channel_period(PWM_CHANNEL_3));
}
TEST(allocate_small_chunk, then_new_chunk_must_be_allocated)
{
MemoryChunk chunk = (MemoryChunk)((char*)mem_asc - MEM_CHUNK_SIZE);
TEST_ASSERT_NOT_NULL(mem_asc);
TEST_ASSERT_EQUAL_UINT32(chunk->memsetorchunk, mc_asc);
TEST_ASSERT_EQUAL_UINT32(chunk->size, 128);
TEST_ASSERT_EQUAL_UINT32(chunk->sizeRequested, 100);
}
void
test_controller_attr_private_connection_type(void) {
lagopus_result_t rc;
controller_attr_t *attr = NULL;
datastore_controller_connection_type_t actual_connection_type
= DATASTORE_CONTROLLER_ROLE_UNKNOWN;
const datastore_controller_connection_type_t expected_connection_type
= actual_connection_type;
datastore_controller_connection_type_t set_connection_type
= DATASTORE_CONTROLLER_ROLE_EQUAL;
datastore_controller_connection_type_t actual_set_connection_type
= DATASTORE_CONTROLLER_ROLE_UNKNOWN;
const datastore_controller_connection_type_t expected_set_connection_type
= set_connection_type;
controller_initialize();
rc = controller_attr_create(&attr);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_NOT_NULL_MESSAGE(attr, "attr_create() will create new controller");
// Normal case of getter
{
rc = controller_get_connection_type(attr, &actual_connection_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_UINT32(expected_connection_type, actual_connection_type);
}
// Abnormal case of getter
{
rc = controller_get_connection_type(NULL, &actual_connection_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = controller_get_connection_type(attr, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
// Normal case of setter
{
rc = controller_set_connection_type(attr, set_connection_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
rc = controller_get_connection_type(attr, &actual_set_connection_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_UINT32(expected_set_connection_type,
actual_set_connection_type);
}
// Abnormal case of setter
{
rc = controller_set_connection_type(NULL, set_connection_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
controller_attr_destroy(attr);
controller_finalize();
}
TEST(file_cache_realloc, then_minimal_items_should_be_allocated)
{
TEST_ASSERT_EQUAL_UINT32(fileCacheCount, 32);
TEST_ASSERT_EQUAL_UINT32(fileCache[0].nextFree, 1);
for (i = 1; i < 30; i++)
TEST_ASSERT_EQUAL_UINT32(fileCache[i].nextFree, i + 1);
TEST_ASSERT_EQUAL_UINT32(fileCache[31].nextFree, 0);
}
void test_pwm_set_clkx() {
pwm_reset_peripheral();
// For CLKA
pwm_set_clkx(PWM_CLK_ID_CLKA, PWM_PRES_MCK_DIV_1024, 255);
TEST_ASSERT_EQUAL_UINT32(0xA00, (PWM->PWM_CLK & PWM_CLK_PREA_MASK ));
TEST_ASSERT_EQUAL_UINT32(0xFF, (PWM->PWM_CLK & PWM_CLK_DIVA_MASK ));
// For CLKB
pwm_set_clkx(PWM_CLK_ID_CLKB, PWM_PRES_MCK_DIV_32, 128);
TEST_ASSERT_EQUAL_UINT32(0x5000000, (PWM->PWM_CLK & PWM_CLK_PREB_MASK ));
TEST_ASSERT_EQUAL_UINT32(0x800000, (PWM->PWM_CLK & PWM_CLK_DIVB_MASK));
}
TEST(file_cache_insert,
then_the_item_should_be_added_to_the_ring)
{
FCacheEl theHead = &fileCache[0];
int theLessRecentInd = theHead->lessRecent;
FCacheEl theLessRecent = &fileCache[theLessRecentInd];
TEST_ASSERT_EQUAL_UINT32(theHead->lessRecent, 1);
TEST_ASSERT_EQUAL_UINT32(theHead->moreRecent, 1);
TEST_ASSERT_EQUAL_UINT32(theLessRecent->lessRecent, 0);
TEST_ASSERT_EQUAL_UINT32(theLessRecent->moreRecent, 0);
}
TEST(relrow_tests, att_align)
{
int align_i1 = ATT_ALIGN(11, 'i');
int align_i2 = ATT_ALIGN(9, 'i');
int align_d1 = ATT_ALIGN(22, 'd');
int align_d2 = ATT_ALIGN(17, 'd');
int align_s1 = ATT_ALIGN(12, 's');
int align_s2 = ATT_ALIGN(11, 's');
int align_s3 = ATT_ALIGN(9, 's');
int align_o = ATT_ALIGN(12, 'o');
TEST_ASSERT_EQUAL_UINT32(align_i1, 12);
TEST_ASSERT_EQUAL_UINT32(align_i2, 12);
TEST_ASSERT_EQUAL_UINT32(align_d1, 24);
TEST_ASSERT_EQUAL_UINT32(align_d2, 24);
TEST_ASSERT_EQUAL_UINT32(align_s1, 12);
TEST_ASSERT_EQUAL_UINT32(align_s2, 12);
TEST_ASSERT_EQUAL_UINT32(align_s3, 10);
TEST_ASSERT_EQUAL_UINT32(align_o, 12);
}
void test_keyExpansion_given_128_bit_cipher_key(void){
printf("No7.0 - keyExpansion 128-bit cipher key\n");
int i = 0;
char* key = malloc(sizeof(char)*17);
uint8_t cipcherkey[] = { 0x2b,0x7e,0x15,0x16,0x28,0xae,0xd2,0xa6,0xab,0xf7,0x15,0x88,0x09,0xcf,0x4f,0x3c};
for(i = 0; i < 16 ; i++){
key[i] = cipcherkey[i];
}
//printf("key = %.*x\n",8,key[i]);
uint32_t word[44];
keyExpansion(key,word,4,10);
TEST_ASSERT_EQUAL_UINT32(0xb6630ca6,word[43]);
TEST_ASSERT_EQUAL_UINT32(0xac7766f3,word[36]);
TEST_ASSERT_EQUAL_UINT32(0x110b3efd,word[25]);
}
TEST(insert_many_ids_into_same_list, then_only_few_mallocs_must_be_called)
{
int i;
int expectedMallocCalls = 1000 / 36 + 1;
uint expectedMemLen = AlignDefault(sizeof(SHashItem))
+ AlignDefault(sizeof(int))
+ AlignDefault(34);
TEST_ASSERT_TRUE(fakeMemStorageCount > 0);
TEST_ASSERT_EQUAL_UINT32(fakeMemStorageCount, expectedMallocCalls);
for (i = 0; i < expectedMallocCalls; i++)
{
TEST_ASSERT_EQUAL_UINT32(fakeMemStorage[i].memLen, expectedMemLen * 36);
}
}
void test_pwm_channel_polarity() {
pwm_reset_peripheral();
pwm_set_channel_polarity(PWM_CHANNEL_3, PWM_CHANNEL_POLARITY_HIGH);
TEST_ASSERT_EQUAL_UINT32(512, (PWM->PWM_CMR3 & PWM_CMRx_CPOL_MASK ));
pwm_set_channel_polarity(PWM_CHANNEL_3, PWM_CHANNEL_POLARITY_LOW);
TEST_ASSERT_EQUAL_HEX32(0x0, (PWM->PWM_CMR3 & PWM_CMRx_CPOL_MASK ));
}
static void test_find_zero_blocks_null(void)
{
uint64_t offset = 0;
uint32_t len = 0;
find_zero_blocks(NULL, &offset, &len);
TEST_ASSERT_EQUAL_UINT64(0, offset);
TEST_ASSERT_EQUAL_UINT32(0, len);
}
void test_subWord_given_0xcf4f3c09_expected_0x8a84eb01(void){
printf("No5.0 - subWord\n");
uint32_t expect0 = 0x8a << 24 | 0x84 << 16 | 0xeb << 8 | 0x01 << 0;
uint32_t temp = 0xcf << 24 | 0x4f << 16 | 0x3c << 8 | 0x09 << 0;
temp = subWord(temp);
printf("%x %x",expect0,temp);
TEST_ASSERT_EQUAL_UINT32(expect0,temp);
}
void test_subWord_given_0x6c76052a_expected_0x50386be5(void){
printf("No6.0 - subWord\n");
uint32_t expect0 = 0x50 << 24 | 0x38 << 16 | 0x6b << 8 | 0xe5 << 0;
uint32_t temp = 0x6c << 24 | 0x76 << 16 | 0x05 << 8 | 0x2a << 0;
temp = subWord(temp);
printf("%x %x",expect0,temp);
TEST_ASSERT_EQUAL_UINT32(expect0,temp);
}
static void test_countOnesInBitMask(void)
{
unsigned int i = 0;
for (i = 0; i < 32; i++)
{
TEST_ASSERT_EQUAL_UINT32(i, countOnes(makeBitmask(i, 0)));
}
}
void test_keyExpansion_given_256_bit_cipher_key(void){
printf("No9.0 - keyExpansion 256-bit cipher key\n");
int i = 0;
char* key = malloc(sizeof(char)*33);
uint8_t cipcherkey[] = { 0x60,0x3d,0xeb,0x10,0x15,0xca,0x71,0xbe,0x2b,0x73,0xae,0xf0,\
0x85,0x7d,0x77,0x81,0x1f,0x35,0x2c,0x07,0x3b,0x61,0x08,0xd7,\
0x2d,0x98,0x10,0xa3,0x09,0x14,0xdf,0xf4};
for(i = 0; i < 32 ; i++){
key[i] = cipcherkey[i];
}
uint32_t word[60];
keyExpansion(key,word,8,14);
TEST_ASSERT_EQUAL_UINT32(0x9ba35411,word[8]);
TEST_ASSERT_EQUAL_UINT32(0x98312229,word[22]);
TEST_ASSERT_EQUAL_UINT32(0xde136967,word[40]);
TEST_ASSERT_EQUAL_UINT32(0x706c631e,word[59]);
}
void test_rotWord_given_0x7359f67f_and_expected_0x59f67f73(void){
printf("No4.0 - rotWord\n");
uint32_t expect0 = 0x59 << 24 | 0xf6 << 16 | 0x7f << 8 | 0x73 << 0;
uint32_t temp = 0x73 << 24 | 0x59 << 16 | 0xf6 << 8 | 0x7f << 0;
temp = rotWord(temp);
printf("%x %x",expect0,temp);
TEST_ASSERT_EQUAL_UINT32(expect0,temp);
}
/*
----- -----
--->| 31 | | 34 |
| ----- -----
| | 32 | rotWord | 31 |
| ----- ------> -----
| | 33 | | 32 |
| ----- -----
----| 34 | | 33 |
----- -----
*/
void test_rotWord_given_0x31323334_and_expected_0x34313233(void){
printf("No2.0 - rotWord\n");
uint32_t expect0 = '2' << 24 | '3' << 16 | '4' << 8 | '1' << 0;
uint32_t temp = '1' << 24 | '2' << 16 | '3' << 8 | '4' << 0;
temp = rotWord(temp);
printf("%x %x",expect0,temp);
TEST_ASSERT_EQUAL_UINT32(expect0,temp);
}
void test_rotWord_given_0x2a6c7605_and_expected_0x6c76052a(void){
printf("No3.0 - rotWord\n");
uint32_t expect0 = 0x6c << 24 | 0x76 << 16 | 0x05 << 8 | 0x2a << 0;
uint32_t temp = 0x2a << 24 | 0x6c << 16 | 0x76 << 8 | 0x05 << 0;
temp = rotWord(temp);
printf("%x %x",expect0,temp);
TEST_ASSERT_EQUAL_UINT32(expect0,temp);
}
void
test_controller_role_to_enum(void) {
lagopus_result_t rc;
datastore_controller_role_t actual_type;
// Normal case
{
rc = controller_role_to_enum("unknown", &actual_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_UINT32(DATASTORE_CONTROLLER_ROLE_UNKNOWN, actual_type);
rc = controller_role_to_enum("master", &actual_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_UINT32(DATASTORE_CONTROLLER_ROLE_MASTER, actual_type);
rc = controller_role_to_enum("slave", &actual_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_UINT32(DATASTORE_CONTROLLER_ROLE_SLAVE, actual_type);
rc = controller_role_to_enum("equal", &actual_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_UINT32(DATASTORE_CONTROLLER_ROLE_EQUAL, actual_type);
rc = controller_role_to_enum("UNKNWON", &actual_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = controller_role_to_enum("MASTER", &actual_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = controller_role_to_enum("SLAVE", &actual_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = controller_role_to_enum("EQUAL", &actual_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
// Abnormal case
{
rc = controller_role_to_enum(NULL, &actual_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = controller_role_to_enum("equal", NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
}
static void test_find_zero_blocks_4095(void)
{
const uint8_t buf[4095] = {0};
uint64_t offset = 0;
uint32_t len = 4095;
find_zero_blocks(buf, &offset, &len);
TEST_ASSERT_EQUAL_UINT64(0, offset);
TEST_ASSERT_EQUAL_UINT32(4095, len);
}
TEST(insert_many_ids_into_same_list, then_hash_list_must_be_filled)
{
int listId = 11111111 & tbl->lowMask;
int sNum = listId >> tbl->segmShift;
int sInd = listId & (tbl->segmSize - 1);
HashItem listPtr = tbl->segments[sNum][sInd];
int numItems = 0;
int key = -1;
while (listPtr != NULL)
{
key = *(int*)GET_HASH_KEY(listPtr);
TEST_ASSERT_EQUAL_UINT32(key, numItems++);
listPtr = listPtr->next;
}
TEST_ASSERT_EQUAL_UINT32(numItems, 1000);
}
/** \brief test function write single register
**
** this function test modbus master write single register
** with callback
**
**/
void test_ciaaModbus_masterCmd0x06WriteSingleRegister_01(void)
{
int32_t hModbusMaster;
uint8_t slaveIdRecv;
uint8_t pduRecv[256];
uint8_t pdu[256] =
{
0X06,
0x00,
0x01,
0X00,
0x03,
};
uint32_t sizeRecv;
/* open modbus master */
hModbusMaster = ciaaModbus_masterOpen();
/* request write single register */
ciaaModbus_masterCmd0x06WriteSingleRegister(
hModbusMaster,
0x0001,
0x0003,
SLAVE_ID,
modbusMaster_cbEndOfComm);
/* perform task modbus master */
ciaaModbus_masterTask(hModbusMaster);
/* receive pdu from master */
ciaaModbus_masterRecvMsg(
hModbusMaster,
&slaveIdRecv,
pduRecv,
&sizeRecv);
/* send message to master */
ciaaModbus_masterSendMsg(
hModbusMaster,
SLAVE_ID,
pdu,
5);
/* verify */
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, slaveIdRecv);
TEST_ASSERT_EQUAL_UINT8_ARRAY(pdu, pduRecv, 5);
TEST_ASSERT_EQUAL_UINT32(5, sizeRecv);
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, callBackData_slaveId);
TEST_ASSERT_EQUAL_UINT8(0x06, callBackData_numFunc);
TEST_ASSERT_EQUAL_UINT8(0x00, callBackData_exceptioncode);
}
static void test_find_zero_blocks_8K_zero_zero(void)
{
const uint8_t buf[BLOCK_SIZE * 2] = {0};
uint64_t offset = 0;
uint32_t len = BLOCK_SIZE * 2;
find_zero_blocks(buf, &offset, &len);
TEST_ASSERT_EQUAL_UINT64(BLOCK_SIZE * 2, offset);
TEST_ASSERT_EQUAL_UINT32(0, len);
}
TEST(create_hashtable, then_name_must_be_set_only_with_one_malloc)
{
uint expectedMemLen = sizeof(SHashtable) + strlen("testTable123") + 1;
TEST_ASSERT_EQUAL_STRING(tbl->name, "testTable123");
TEST_ASSERT_TRUE(fakeMemStorageCount > 0);
TEST_ASSERT_EQUAL_UINT32(fakeMemStorage[0].memLen, expectedMemLen);
}
static void test_find_zero_blocks_4097_zero_offset_1(void)
{
const uint8_t buf[BLOCK_SIZE + 1] = {0};
uint64_t offset = 1;
uint32_t len = BLOCK_SIZE;
find_zero_blocks(buf, &offset, &len);
TEST_ASSERT_EQUAL_UINT64(BLOCK_SIZE, offset);
TEST_ASSERT_EQUAL_UINT32(1, len);
}
TEST(checksum, calc_32bit)
{
uint32_t array[] = {
0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555, 0x66666666, 0x77777777, 0x88888888,
0x99999999, 0xAAAAAAAA, 0xBBBBBBBB, 0xCCCCCCCC, 0xDDDDDDDD, 0xEEEEEEEE, 0xFFFFFFFF, 0x00000000
};
size_t len = sizeof(array) / sizeof(array[0]);
uint32_t expects = 0xFFFFFFF8; /* 0x7FFFFFFF8 */
TEST_ASSERT_EQUAL_UINT32( expects, checksum_calc_32bit(array, len) );
}