New function tests for ua_transport

src/ua_transport.c

@@ -482,6 +482,7 @@ UA_Int32 UA_SecureConversationMessageFooter_copy(const UA_SecureConversationMess
 	memcpy(dst, src, sizeof(UA_SecureConversationMessageFooter));
 	dst->padding = src->padding;
 	retval |= UA_Array_copy(&src->padding, src->paddingSize,&UA_.types[UA_BYTE],(void**)&dst->padding);
+	*(dst->padding) = *(src->padding);
 	return retval;
 }
 

tests/check_stack.c

@@ -438,6 +438,146 @@ START_TEST(validCreateSessionShallCreateSession) {
 }
 END_TEST
 
+START_TEST(UA_OPCUATcpMessageHeader_copyShallWorkOnInputExample) {
+	// given
+	UA_OPCUATcpMessageHeader src;
+	UA_OPCUATcpMessageHeader_init(&src);
+	src.isFinal = 2;
+	src.messageSize = 43;
+	src.messageType = UA_MESSAGETYPE_MSG;
+	const UA_OPCUATcpMessageHeader srcConst = src;
+
+	UA_OPCUATcpMessageHeader dst;
+	UA_Int32 ret;
+
+	// when
+	ret = UA_OPCUATcpMessageHeader_copy(&srcConst, &dst);
+	// then
+	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(UA_MESSAGETYPE_MSG, dst.messageType);
+	ck_assert_int_eq(43, dst.messageSize);
+	ck_assert_int_eq(2, dst.isFinal);
+}
+END_TEST
+START_TEST(UA_AsymmetricAlgorithmSecurityHeader_copyShallWorkOnInputExample) {
+	// given
+	UA_AsymmetricAlgorithmSecurityHeader src;
+	UA_AsymmetricAlgorithmSecurityHeader_init(&src);
+	src.receiverCertificateThumbprint = (UA_String){10, (UA_Byte*)"thumbprint"};
+	src.securityPolicyUri = (UA_String){6, (UA_Byte*)"policy"};
+	src.senderCertificate = (UA_String){8, (UA_Byte*)"tEsT123!"};
+	src.requestId = 99;
+	const UA_AsymmetricAlgorithmSecurityHeader srcConst = src;
+
+	UA_AsymmetricAlgorithmSecurityHeader dst;
+	UA_Int32 ret;
+
+	// when
+	ret = UA_AsymmetricAlgorithmSecurityHeader_copy(&srcConst, &dst);
+	// then
+	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq('m', dst.receiverCertificateThumbprint.data[3]);
+	ck_assert_int_eq(10, dst.receiverCertificateThumbprint.length);
+	ck_assert_int_eq('o', dst.securityPolicyUri.data[1]);
+	ck_assert_int_eq(6, dst.securityPolicyUri.length);
+	ck_assert_int_eq('t', dst.senderCertificate.data[0]);
+	ck_assert_int_eq(8, dst.senderCertificate.length);
+	ck_assert_int_eq(99, dst.requestId);
+}
+END_TEST
+START_TEST(UA_SecureConversationMessageHeader_copyShallWorkOnInputExample) {
+	// given
+	UA_SecureConversationMessageHeader src;
+	UA_SecureConversationMessageHeader_init(&src);
+	src.secureChannelId = 84;
+	UA_OPCUATcpMessageHeader srcHeader;
+	UA_OPCUATcpMessageHeader_init(&srcHeader);
+	srcHeader.isFinal = 4;
+	srcHeader.messageSize = 765;
+	srcHeader.messageType = UA_MESSAGETYPE_CLO;
+	src.messageHeader = srcHeader;
+
+	const UA_SecureConversationMessageHeader srcConst = src;
+
+	UA_SecureConversationMessageHeader dst;
+	UA_Int32 ret;
+
+	// when
+	ret = UA_SecureConversationMessageHeader_copy(&srcConst, &dst);
+	// then
+	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(84, dst.secureChannelId);
+	ck_assert_int_eq(4, dst.messageHeader.isFinal);
+	ck_assert_int_eq(765, dst.messageHeader.messageSize);
+	ck_assert_int_eq(UA_MESSAGETYPE_CLO, dst.messageHeader.messageType);
+}
+END_TEST
+START_TEST(UA_SequenceHeader_copyShallWorkOnInputExample) {
+	// given
+	UA_SequenceHeader src;
+	UA_SequenceHeader_init(&src);
+	src.requestId = 84;
+	src.sequenceNumber = 1345;
+
+	const UA_SequenceHeader srcConst = src;
+
+	UA_SequenceHeader dst;
+	UA_Int32 ret;
+
+	// when
+	ret = UA_SequenceHeader_copy(&srcConst, &dst);
+	// then
+	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(84, dst.requestId);
+	ck_assert_int_eq(1345, dst.sequenceNumber);
+}
+END_TEST
+START_TEST(UA_SecureConversationMessageFooter_copyShallWorkOnInputExample) {
+	// given
+	UA_SecureConversationMessageFooter src;
+	UA_SecureConversationMessageFooter_init(&src);
+	UA_Byte srcByte = 84;
+	src.padding = &srcByte;
+	src.paddingSize = 1345;
+	src.signature = 5;
+
+	const UA_SecureConversationMessageFooter srcConst = src;
+
+	UA_SecureConversationMessageFooter dst;
+	UA_SecureConversationMessageFooter_init(&dst);
+	UA_Int32 ret;
+
+	// when
+	ret = UA_SecureConversationMessageFooter_copy(&srcConst, &dst);
+	// then
+	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(84, *(dst.padding));
+	ck_assert_int_eq(1345, dst.paddingSize);
+	ck_assert_int_eq(5, dst.signature);
+}
+END_TEST
+START_TEST(UA_SecureConversationMessageAbortBody_copyShallWorkOnInputExample) {
+	// given
+	UA_SecureConversationMessageAbortBody src;
+	UA_SecureConversationMessageAbortBody_init(&src);
+	src.error = 5478;
+	src.reason = (UA_String){6, (UA_Byte*)"reAson"};
+
+	const UA_SecureConversationMessageAbortBody srcConst = src;
+
+	UA_SecureConversationMessageAbortBody dst;
+	UA_Int32 ret;
+
+	// when
+	ret = UA_SecureConversationMessageAbortBody_copy(&srcConst, &dst);
+	// then
+	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(5478, dst.error);
+	ck_assert_int_eq('A', dst.reason.data[2]);
+	ck_assert_int_eq(6, dst.reason.length);
+}
+END_TEST
+
 Suite *testSuite() {
 	Suite *s = suite_create("Stack Test");
 	TCase *tc_core = tcase_create("Core");
@@ -447,6 +587,15 @@ Suite *testSuite() {
 	tcase_add_test(tc_core, validOpeningCloseSequence);
 	tcase_add_test(tc_core, validCreateSessionShallCreateSession);
 	suite_add_tcase(s, tc_core);
+
+	TCase *tc_transport = tcase_create("Transport");
+	tcase_add_test(tc_transport, UA_OPCUATcpMessageHeader_copyShallWorkOnInputExample);
+	tcase_add_test(tc_transport, UA_AsymmetricAlgorithmSecurityHeader_copyShallWorkOnInputExample);
+	tcase_add_test(tc_transport, UA_SecureConversationMessageHeader_copyShallWorkOnInputExample);
+	tcase_add_test(tc_transport, UA_SequenceHeader_copyShallWorkOnInputExample);
+	tcase_add_test(tc_transport, UA_SecureConversationMessageFooter_copyShallWorkOnInputExample);
+	tcase_add_test(tc_transport, UA_SecureConversationMessageAbortBody_copyShallWorkOnInputExample);
+	suite_add_tcase(s, tc_transport);
 	return s;
 }