/** \brief test memcpy
**
** test the function ciaaPOSIX_memcpy
**
**/
void test_ciaaPOSIX_memcpy(void) {
char * from = "hello world";
char to[1000];
void * ret;
uint32_t loopi;
for(loopi = 0; loopi < sizeof(to); loopi++)
{
to[loopi] = 0;
}
ret = ciaaPOSIX_memcpy((void*)to, (void*)from, 4);
TEST_ASSERT_TRUE(0 == strncmp(from, to, 4));
TEST_ASSERT_TRUE(0 != strncmp(from, to, 5));
TEST_ASSERT_TRUE(to == ret);
ret = ciaaPOSIX_memcpy((void*)to, (void*)from, strlen(from)+1);
TEST_ASSERT_TRUE(0 == strcmp(from, to));
TEST_ASSERT_TRUE(to == ret);
}
extern size_t ciaaLibs_circBufGet(ciaaLibs_CircBufType * cbuf, void * data, size_t nbytes)
{
size_t rawCount;
/* the tail of the circular buffer my be changed, therefore it has to be
* read only once */
size_t tail = cbuf->tail;
/* if the users tries to read to much data, only available data will be
* provided */
if (nbytes > ciaaLibs_circBufCount(cbuf, tail))
{
nbytes = ciaaLibs_circBufCount(cbuf, tail);
}
/* check if data to be read */
if (nbytes > 0)
{
rawCount = ciaaLibs_circBufRawCount(cbuf, tail);
/* check if all data can be read without wrapping */
if (nbytes <= rawCount)
{
ciaaPOSIX_memcpy(data, ciaaLibs_circBufReadPos(cbuf), nbytes);
}
else
{
ciaaPOSIX_memcpy(data, ciaaLibs_circBufReadPos(cbuf), rawCount);
ciaaPOSIX_memcpy((void*)((intptr_t)data + rawCount), (void*)(&cbuf->buf[0]), nbytes-rawCount);
}
/* calculates new head position */
ciaaLibs_circBufUpdateHead(cbuf, nbytes);
}
return nbytes;
} /* end ciaaLibs_circBufGet */
extern size_t ciaaLibs_circBufPut(ciaaLibs_CircBufType * cbuf, void const * data, size_t nbytes)
{
size_t ret = 0;
size_t rawSpace;
/* the head of the circular buffer may be changed, therefore it has to be
* read only once */
size_t head = cbuf->head;
/* check that is enough place */
if (ciaaLibs_circBufSpace(cbuf, head) >= nbytes)
{
rawSpace = ciaaLibs_circBufRawSpace(cbuf, head);
/* check if wrapping is needed */
if (rawSpace >= nbytes)
{
ciaaPOSIX_memcpy(ciaaLibs_circBufWritePos(cbuf), data, nbytes);
}
else
{
ciaaPOSIX_memcpy((void*)(&cbuf->buf[cbuf->tail]), data, rawSpace);
ciaaPOSIX_memcpy((void*)(&cbuf->buf[0]),
(void*)((intptr_t)data + rawSpace),
nbytes-rawSpace);
}
/* calculate new tail position */
ciaaLibs_circBufUpdateTail(cbuf, nbytes);
/* set return value */
ret = nbytes;
}
return ret;
} /* end ciaaLibs_circBufPut */
/*==================[internal functions definition]==========================*/
static int32_t UPDT_slaveSendResponse(
UPDT_slaveType *slave,
const uint8_t* payload,
size_t payload_size,
uint8_t response_type)
{
uint8_t *buffer;
ciaaPOSIX_assert(NULL != slave);
ciaaPOSIX_assert(NULL != payload);
buffer = slave->send_buffer;
UPDT_protocolSetHeader(buffer, response_type, slave->sequence_number, payload_size);
ciaaPOSIX_memcpy(buffer + UPDT_PROTOCOL_HEADER_SIZE, payload, payload_size);
return UPDT_protocolSend(slave->transport, buffer, UPDT_PROTOCOL_HEADER_SIZE + payload_size);
}
extern ssize_t ciaaDriverAio_read(ciaaDevices_deviceType const * const device, uint8_t * const buffer, size_t const size)
{
size_t ret = size;
/* receive the data and forward to upper layer */
ciaaDriverAio_uartType * uart = device->layer;
if (size > uart->rxBuffer.length)
{
ret = uart->rxBuffer.length;
}
/* copy received bytes to upper layer */
ciaaPOSIX_memcpy(buffer, &uart->rxBuffer.buffer[0], ret);
return ret;
}
extern ssize_t ciaaDriverAio_write(ciaaDevices_deviceType const * const device, uint8_t const * const buffer, size_t const size)
{
size_t ret = 0;
/* write data */
ciaaDriverAio_uartType * uart = device->layer;
if (0 == uart->txBuffer.length)
{
/* copy data */
ciaaPOSIX_memcpy(&uart->txBuffer.buffer, buffer, size);
/* return lenght and set 0 for the next */
ret = size;
/* set length of the buffer */
uart->txBuffer.length = size;
}
return ret;
}
