niklas/cyclonedds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Multi Process Testing framework

Browse source 
Signed-off-by: Martin Bremmer <martin.bremmer@adlinktech.com>
This commit is contained in:
Martin Bremmer 2019-04-10 17:57:29 +02:00
parent 0269774a60
commit 17f9c361ea
30 changed files with 2934 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

19
src/mpt/tests/CMakeLists.txt Normal file
View file

@ -0,0 +1,19 @@
#
# Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
#
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License v. 2.0 which is available at
# http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
# v. 1.0 which is available at
# http://www.eclipse.org/org/documents/edl-v10.php.
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
cmake_minimum_required(VERSION 3.7)
if(MPT_ENABLE_SELFTEST)
add_subdirectory(self)
endif()
add_subdirectory(basic)

23
src/mpt/tests/basic/CMakeLists.txt Normal file
View file

@ -0,0 +1,23 @@
#
# Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
#
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License v. 2.0 which is available at
# http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
# v. 1.0 which is available at
# http://www.eclipse.org/org/documents/edl-v10.php.
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
include(${MPT_CMAKE})
set(sources
"procs/hello.c"
"helloworld.c"
"multi.c")
add_mpt_executable(mpt_basic ${sources})
idlc_generate(mpt_basic_helloworlddata_lib "procs/helloworlddata.idl")
target_link_libraries(mpt_basic PRIVATE mpt_basic_helloworlddata_lib)

30
src/mpt/tests/basic/etc/config_any.xml Normal file
View file

@ -0,0 +1,30 @@
<!--
Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
This program and the accompanying materials are made available under the
terms of the Eclipse Public License v. 2.0 which is available at
http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
v. 1.0 which is available at
http://www.eclipse.org/org/documents/edl-v10.php.
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
-->
<CycloneDDS>
<Domain>
<Id>any</Id>
</Domain>
<DDSI2E>
<General>
<NetworkInterfaceAddress>auto</NetworkInterfaceAddress>
<AllowMulticast>true</AllowMulticast>
<EnableMulticastLoopback>true</EnableMulticastLoopback>
</General>
<Compatibility>
<StandardsConformance>lax</StandardsConformance>
</Compatibility>
<!--Tracing>
<Verbosity>finest</Verbosity>
<OutputFile>ddsi_${MPT_PROCESS_NAME}.log</OutputFile>
</Tracing-->
</DDSI2E>
</CycloneDDS>

30
src/mpt/tests/basic/etc/config_specific.xml Normal file
View file

@ -0,0 +1,30 @@
<!--
Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
This program and the accompanying materials are made available under the
terms of the Eclipse Public License v. 2.0 which is available at
http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
v. 1.0 which is available at
http://www.eclipse.org/org/documents/edl-v10.php.
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
-->
<CycloneDDS>
<Domain>
<Id>${DOMAIN_ID}</Id>
</Domain>
<DDSI2E>
<General>
<NetworkInterfaceAddress>auto</NetworkInterfaceAddress>
<AllowMulticast>true</AllowMulticast>
<EnableMulticastLoopback>true</EnableMulticastLoopback>
</General>
<Compatibility>
<StandardsConformance>lax</StandardsConformance>
</Compatibility>
<!--Tracing>
<Verbosity>finest</Verbosity>
<OutputFile>ddsi_${MPT_PROCESS_NAME}.log</OutputFile>
</Tracing-->
</DDSI2E>
</CycloneDDS>

63
src/mpt/tests/basic/helloworld.c Normal file
View file

@ -0,0 +1,63 @@
#include "dds/dds.h"
#include "mpt/mpt.h"
#include "mpt/resource.h" /* MPT_SOURCE_ROOT_DIR */
#include "procs/hello.h" /* publisher and subscriber entry points. */
/*
* Tests to check simple communication between a publisher and subscriber.
* The published text should be received by the subscriber.
*/
/* Environments */
static mpt_env_t environment_any[] = {
{ "ETC_DIR", MPT_SOURCE_ROOT_DIR"/tests/basic/etc" },
{ "CYCLONEDDS_URI", "file://${ETC_DIR}/config_any.xml" },
{ NULL, NULL }
};
static mpt_env_t environment_42[] = {
{ "ETC_DIR", MPT_SOURCE_ROOT_DIR"/tests/basic/etc" },
{ "DOMAIN_ID", "42" },
{ "CYCLONEDDS_URI", "file://${ETC_DIR}/config_specific.xml" },
{ NULL, NULL }
};
/**********************************************************************
* No CYCLONEDDS_URI set.
**********************************************************************/
#define TEST_ARGS MPT_ArgValues(DDS_DOMAIN_DEFAULT, "hello_def", 1, "No environment set")
MPT_TestProcess(helloworld, default, pub, hello_publisher, TEST_ARGS);
MPT_TestProcess(helloworld, default, sub, hello_subscriber, TEST_ARGS);
MPT_Test(helloworld, default, .init=hello_init, .fini=hello_fini);
#undef TEST_ARGS
/**********************************************************************
* Config domain is any. Test domain is default.
**********************************************************************/
#define TEST_ARGS MPT_ArgValues(DDS_DOMAIN_DEFAULT, "hello_any", 1, "Some nice text over any domain")
MPT_TestProcess(helloworld, domain_any, pub, hello_publisher, TEST_ARGS);
MPT_TestProcess(helloworld, domain_any, sub, hello_subscriber, TEST_ARGS);
MPT_Test(helloworld, domain_any, .init=hello_init, .fini=hello_fini, .environment=environment_any);
#undef TEST_ARGS
/**********************************************************************
* Pub: Config domain is any. Test domain is 42.
* Sub: Config domain is 42 (through DOMAIN_ID env). Test domain is default.
**********************************************************************/
#define TEST_PUB_ARGS MPT_ArgValues(42, "hello_42", 1, "Now domain 42 is used")
#define TEST_SUB_ARGS MPT_ArgValues(DDS_DOMAIN_DEFAULT, "hello_42", 1, "Now domain 42 is used")
MPT_TestProcess(helloworld, domain_42, pub, hello_publisher, TEST_PUB_ARGS, .environment=environment_any);
MPT_TestProcess(helloworld, domain_42, sub, hello_subscriber, TEST_SUB_ARGS, .environment=environment_42);
MPT_Test(helloworld, domain_42, .init=hello_init, .fini=hello_fini);
#undef TEST_SUB_ARGS
#undef TEST_PUB_ARGS

50
src/mpt/tests/basic/multi.c Normal file
View file

@ -0,0 +1,50 @@
#include "mpt/mpt.h"
#include "procs/hello.h"
/*
* Tests to check communication between multiple publisher(s) and subscriber(s).
*/
/*
* The publisher expects 2 publication matched.
* The subscribers expect 1 sample each.
*/
#define TEST_PUB_ARGS MPT_ArgValues(DDS_DOMAIN_DEFAULT, "multi_pubsubsub", 2, "pubsubsub")
#define TEST_SUB_ARGS MPT_ArgValues(DDS_DOMAIN_DEFAULT, "multi_pubsubsub", 1, "pubsubsub")
MPT_TestProcess(multi, pubsubsub, pub, hello_publisher, TEST_PUB_ARGS);
MPT_TestProcess(multi, pubsubsub, sub1, hello_subscriber, TEST_SUB_ARGS);
MPT_TestProcess(multi, pubsubsub, sub2, hello_subscriber, TEST_SUB_ARGS);
MPT_Test(multi, pubsubsub, .init=hello_init, .fini=hello_fini);
#undef TEST_SUB_ARGS
#undef TEST_PUB_ARGS
/*
* The publishers expect 1 publication matched each.
* The subscriber expects 2 samples.
*/
#define TEST_PUB_ARGS MPT_ArgValues(DDS_DOMAIN_DEFAULT, "multi_pubpubsub", 1, "pubpubsub")
#define TEST_SUB_ARGS MPT_ArgValues(DDS_DOMAIN_DEFAULT, "multi_pubpubsub", 2, "pubpubsub")
MPT_TestProcess(multi, pubpubsub, pub1, hello_publisher, TEST_PUB_ARGS);
MPT_TestProcess(multi, pubpubsub, pub2, hello_publisher, TEST_PUB_ARGS);
MPT_TestProcess(multi, pubpubsub, sub, hello_subscriber, TEST_SUB_ARGS);
MPT_Test(multi, pubpubsub, .init=hello_init, .fini=hello_fini);
#undef TEST_SUB_ARGS
#undef TEST_PUB_ARGS
/*
* The publishers expect 2 publication matched each.
* The subscribers expect 2 samples each.
*/
#define TEST_PUB_ARGS MPT_ArgValues(DDS_DOMAIN_DEFAULT, "multi_pubpubsubsub", 2, "pubpubsubsub")
#define TEST_SUB_ARGS MPT_ArgValues(DDS_DOMAIN_DEFAULT, "multi_pubpubsubsub", 2, "pubpubsubsub")
MPT_TestProcess(multi, pubpubsubsub, pub1, hello_publisher, TEST_PUB_ARGS);
MPT_TestProcess(multi, pubpubsubsub, pub2, hello_publisher, TEST_PUB_ARGS);
MPT_TestProcess(multi, pubpubsubsub, sub1, hello_subscriber, TEST_SUB_ARGS);
MPT_TestProcess(multi, pubpubsubsub, sub2, hello_subscriber, TEST_SUB_ARGS);
MPT_Test(multi, pubpubsubsub, .init=hello_init, .fini=hello_fini);
#undef TEST_SUB_ARGS
#undef TEST_PUB_ARGS

239
src/mpt/tests/basic/procs/hello.c Normal file
View file

@ -0,0 +1,239 @@
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "mpt/mpt.h"
#include "dds/dds.h"
#include "helloworlddata.h"
#include "dds/ddsrt/time.h"
#include "dds/ddsrt/strtol.h"
#include "dds/ddsrt/process.h"
#include "dds/ddsrt/environ.h"
#include "dds/ddsrt/cdtors.h"
#include "dds/ddsrt/sync.h"
/* An array of one message (aka sample in dds terms) will be used. */
#define MAX_SAMPLES 1
static int g_publication_matched_count = 0;
static ddsrt_mutex_t g_mutex;
static ddsrt_cond_t g_cond;
static void
publication_matched_cb(
dds_entity_t writer,
const dds_publication_matched_status_t status,
void* arg)
{
(void)arg;
(void)writer;
ddsrt_mutex_lock(&g_mutex);
g_publication_matched_count = (int)status.current_count;
ddsrt_cond_broadcast(&g_cond);
ddsrt_mutex_unlock(&g_mutex);
}
static void
data_available_cb(
dds_entity_t reader,
void* arg)
{
(void)arg;
(void)reader;
ddsrt_mutex_lock(&g_mutex);
ddsrt_cond_broadcast(&g_cond);
ddsrt_mutex_unlock(&g_mutex);
}
void
hello_init(void)
{
ddsrt_init();
ddsrt_mutex_init(&g_mutex);
ddsrt_cond_init(&g_cond);
}
void
hello_fini(void)
{
ddsrt_cond_destroy(&g_cond);
ddsrt_mutex_destroy(&g_mutex);
ddsrt_fini();
}
/*
* The HelloWorld publisher.
* It waits for a publication matched, and then writes a sample.
* It quits when the publication matched has been reset again.
*/
MPT_ProcessEntry(hello_publisher,
MPT_Args(dds_domainid_t domainid,
const char *topic_name,
int sub_cnt,
const char *text))
{
HelloWorldData_Msg msg;
dds_listener_t *listener;
dds_entity_t participant;
dds_entity_t topic;
dds_entity_t writer;
dds_return_t rc;
dds_qos_t *qos;
int id = (int)ddsrt_getpid();
assert(topic_name);
assert(text);
printf("=== [Publisher(%d)] Start(%d) ...\n", id, domainid);
/*
* A reliable volatile sample, written after publication matched, can still
* be lost when the subscriber wasn't able to match its subscription yet.
* Use transient_local reliable to make sure the sample is received.
*/
qos = dds_create_qos();
dds_qset_durability(qos, DDS_DURABILITY_TRANSIENT_LOCAL);
dds_qset_reliability(qos, DDS_RELIABILITY_RELIABLE, DDS_SECS(10));
/* Use listener to get number of publications matched. */
listener = dds_create_listener(NULL);
MPT_ASSERT_FATAL_NOT_NULL(listener, "Could not create listener");
dds_lset_publication_matched(listener, publication_matched_cb);
/* Create a Writer. */
participant = dds_create_participant (domainid, NULL, NULL);
MPT_ASSERT_FATAL_GT(participant, 0, "Could not create participant: %s\n", dds_strretcode(-participant));
topic = dds_create_topic (
participant, &HelloWorldData_Msg_desc, topic_name, qos, NULL);
MPT_ASSERT_FATAL_GT(topic, 0, "Could not create topic: %s\n", dds_strretcode(-topic));
writer = dds_create_writer (participant, topic, qos, listener);
MPT_ASSERT_FATAL_GT(writer, 0, "Could not create writer: %s\n", dds_strretcode(-writer));
/* Wait for expected nr of subscriber(s). */
ddsrt_mutex_lock(&g_mutex);
while (g_publication_matched_count != sub_cnt) {
ddsrt_cond_waitfor(&g_cond, &g_mutex, DDS_INFINITY);
}
ddsrt_mutex_unlock(&g_mutex);
/* Write sample. */
msg.userID = (int32_t)id;
msg.message = (char*)text;
printf("=== [Publisher(%d)] Send: { %d, %s }\n", id, msg.userID, msg.message);
rc = dds_write (writer, &msg);
MPT_ASSERT_EQ(rc, DDS_RETCODE_OK, "Could not write sample\n");
/* Wait for subscriber(s) to have finished. */
ddsrt_mutex_lock(&g_mutex);
while (g_publication_matched_count != 0) {
ddsrt_cond_waitfor(&g_cond, &g_mutex, DDS_INFINITY);
}
ddsrt_mutex_unlock(&g_mutex);
rc = dds_delete (participant);
MPT_ASSERT_EQ(rc, DDS_RETCODE_OK, "Teardown failed\n");
dds_delete_listener(listener);
dds_delete_qos(qos);
printf("=== [Publisher(%d)] Done\n", id);
}
/*
* The HelloWorld subscriber.
* It waits for sample(s) and checks the content.
*/
MPT_ProcessEntry(hello_subscriber,
MPT_Args(dds_domainid_t domainid,
const char *topic_name,
int sample_cnt,
const char *text))
{
HelloWorldData_Msg *msg;
void *samples[MAX_SAMPLES];
dds_sample_info_t infos[MAX_SAMPLES];
dds_listener_t *listener;
dds_entity_t participant;
dds_entity_t topic;
dds_entity_t reader;
dds_return_t rc;
dds_qos_t *qos;
int recv_cnt;
int id = (int)ddsrt_getpid();
assert(topic_name);
assert(text);
printf("--- [Subscriber(%d)] Start(%d) ...\n", id, domainid);
/*
* A reliable volatile sample, written after publication matched, can still
* be lost when the subscriber wasn't able to match its subscription yet.
* Use transient_local reliable to make sure the sample is received.
*/
qos = dds_create_qos();
dds_qset_durability(qos, DDS_DURABILITY_TRANSIENT_LOCAL);
dds_qset_reliability(qos, DDS_RELIABILITY_RELIABLE, DDS_SECS(10));
/* Use listener to get data available trigger. */
listener = dds_create_listener(NULL);
MPT_ASSERT_FATAL_NOT_NULL(listener, "Could not create listener");
dds_lset_data_available(listener, data_available_cb);
/* Create a Reader. */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
MPT_ASSERT_FATAL_GT(participant, 0, "Could not create participant: %s\n", dds_strretcode(-participant));
topic = dds_create_topic (
participant, &HelloWorldData_Msg_desc, topic_name, qos, NULL);
MPT_ASSERT_FATAL_GT(topic, 0, "Could not create topic: %s\n", dds_strretcode(-topic));
reader = dds_create_reader (participant, topic, qos, listener);
MPT_ASSERT_FATAL_GT(reader, 0, "Could not create reader: %s\n", dds_strretcode(-reader));
printf("--- [Subscriber(%d)] Waiting for %d sample(s) ...\n", id, sample_cnt);
/* Initialize sample buffer, by pointing the void pointer within
* the buffer array to a valid sample memory location. */
samples[0] = HelloWorldData_Msg__alloc ();
/* Wait until expected nr of samples have been taken. */
ddsrt_mutex_lock(&g_mutex);
recv_cnt = 0;
while (recv_cnt < sample_cnt) {
/* Use a take with mask to work around the #146 issue. */
rc = dds_take_mask(reader, samples, infos, MAX_SAMPLES, MAX_SAMPLES, DDS_NEW_VIEW_STATE);
MPT_ASSERT_GEQ(rc, 0, "Could not read: %s\n", dds_strretcode(-rc));
/* Check if we read some data and it is valid. */
if ((rc > 0) && (infos[0].valid_data)) {
/* Print Message. */
msg = (HelloWorldData_Msg*)samples[0];
printf("--- [Subscriber(%d)] Received: { %d, %s }\n", id,
msg->userID, msg->message);
MPT_ASSERT_STR_EQ(msg->message, text,
"Messages do not match: \"%s\" vs \"%s\"\n",
msg->message, text);
recv_cnt++;
} else {
ddsrt_cond_waitfor(&g_cond, &g_mutex, DDS_INFINITY);
}
}
ddsrt_mutex_unlock(&g_mutex);
/* Free the data location. */
HelloWorldData_Msg_free (samples[0], DDS_FREE_ALL);
rc = dds_delete (participant);
MPT_ASSERT_EQ(rc, DDS_RETCODE_OK, "Teardown failed\n");
dds_delete_listener(listener);
dds_delete_qos(qos);
printf("--- [Subscriber(%d)] Done\n", id);
}

52
src/mpt/tests/basic/procs/hello.h Normal file
View file

@ -0,0 +1,52 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
/** @file
*
* @brief DDS C Communication Status API
*
* This header file defines the public API of the Communication Status in the
* Eclipse Cyclone DDS C language binding.
*/
#ifndef MPT_BASIC_PROCS_HELLO_H
#define MPT_BASIC_PROCS_HELLO_H
#include <stdio.h>
#include <string.h>
#include "dds/dds.h"
#include "mpt/mpt.h"
#if defined (__cplusplus)
extern "C" {
#endif
void hello_init(void);
void hello_fini(void);
MPT_ProcessEntry(hello_publisher,
MPT_Args(dds_domainid_t domainid,
const char *topic_name,
int sub_cnt,
const char *text));
MPT_ProcessEntry(hello_subscriber,
MPT_Args(dds_domainid_t domainid,
const char *topic_name,
int sample_cnt,
const char *text));
#if defined (__cplusplus)
}
#endif
#endif /* MPT_BASIC_PROCS_HELLO_H */

9
src/mpt/tests/basic/procs/helloworlddata.idl Normal file
View file

@ -0,0 +1,9 @@
module HelloWorldData
{
struct Msg
{
long userID;
string message;
};
#pragma keylist Msg userID
};

25
src/mpt/tests/self/CMakeLists.txt Normal file
View file

@ -0,0 +1,25 @@
#
# Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
#
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License v. 2.0 which is available at
# http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
# v. 1.0 which is available at
# http://www.eclipse.org/org/documents/edl-v10.php.
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
include(${MPT_CMAKE})
message(STATUS "MPT selftest enabled: some test will fail deliberately")
set(sources
"asserts.c"
"environments.c"
"fixtures.c"
"ipc.c"
"resources.c"
"usage.c")
add_mpt_executable(mpt_self ${sources})

711
src/mpt/tests/self/asserts.c Normal file
View file

@ -0,0 +1,711 @@
#include <stdio.h>
#include <assert.h>
#include "mpt/mpt.h"
#include "dds/ddsrt/time.h"
static int dummy;
/************************************************************
* Test MPT_ASSERT
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT, MPT_Args(const char *exp, int cond))
{
assert(exp);
MPT_ASSERT(cond, "MPT_ASSERT(%d), 1st, expect: %s", cond, exp);
MPT_ASSERT(cond, "MPT_ASSERT(%d), 2nd, expect: %s", cond, exp);
}
MPT_TestProcess(MPT_ASSERT, pass, id, proc_MPT_ASSERT, MPT_ArgValues("PASS", 1));
MPT_TestProcess(MPT_ASSERT, fail, id, proc_MPT_ASSERT, MPT_ArgValues("FAIL", 0));
MPT_Test(MPT_ASSERT, pass, .xfail=false);
MPT_Test(MPT_ASSERT, fail, .xfail=true);
/************************************************************
* Test MPT_ASSERT_FAIL
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FAIL, MPT_NoArgs())
{
MPT_ASSERT_FAIL("MPT_ASSERT_FAIL(), 1st, expect a fail, always");
MPT_ASSERT_FAIL("MPT_ASSERT_FAIL(), 2nd, expect a fail, always");
}
MPT_TestProcess(MPT_ASSERT_FAIL, call, id, proc_MPT_ASSERT_FAIL, MPT_NoArgValues());
MPT_Test(MPT_ASSERT_FAIL, call, .xfail=true);
/************************************************************
* Test MPT_ASSERT_EQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_EQ_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_EQ(val1, val2, "MPT_ASSERT_EQ(%d, %d), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_EQ(val1, val2, "MPT_ASSERT_EQ(%d, %d), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_EQ_int, eq, id, proc_MPT_ASSERT_EQ_int, MPT_ArgValues("PASS", 1, 1));
MPT_TestProcess(MPT_ASSERT_EQ_int, lt, id, proc_MPT_ASSERT_EQ_int, MPT_ArgValues("FAIL", 1, 2));
MPT_TestProcess(MPT_ASSERT_EQ_int, gt, id, proc_MPT_ASSERT_EQ_int, MPT_ArgValues("FAIL", 3, 2));
MPT_Test(MPT_ASSERT_EQ_int, eq, .xfail=false);
MPT_Test(MPT_ASSERT_EQ_int, lt, .xfail=true);
MPT_Test(MPT_ASSERT_EQ_int, gt, .xfail=true);
MPT_ProcessEntry(proc_MPT_ASSERT_EQ_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_EQ(val1, val2, "MPT_ASSERT_EQ(%f, %f), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_EQ(val1, val2, "MPT_ASSERT_EQ(%f, %f), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_EQ_double, eq, id, proc_MPT_ASSERT_EQ_double, MPT_ArgValues("PASS", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_EQ_double, lt, id, proc_MPT_ASSERT_EQ_double, MPT_ArgValues("FAIL", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_EQ_double, gt, id, proc_MPT_ASSERT_EQ_double, MPT_ArgValues("FAIL", 1.3, 1.2));
MPT_Test(MPT_ASSERT_EQ_double, eq, .xfail=false);
MPT_Test(MPT_ASSERT_EQ_double, lt, .xfail=true);
MPT_Test(MPT_ASSERT_EQ_double, gt, .xfail=true);
/************************************************************
* Test MPT_ASSERT_NEQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_NEQ_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_NEQ(val1, val2, "MPT_ASSERT_NEQ(%d, %d), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_NEQ(val1, val2, "MPT_ASSERT_NEQ(%d, %d), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_NEQ_int, eq, id, proc_MPT_ASSERT_NEQ_int, MPT_ArgValues("FAIL", 1, 1));
MPT_TestProcess(MPT_ASSERT_NEQ_int, lt, id, proc_MPT_ASSERT_NEQ_int, MPT_ArgValues("PASS", 1, 2));
MPT_TestProcess(MPT_ASSERT_NEQ_int, gt, id, proc_MPT_ASSERT_NEQ_int, MPT_ArgValues("PASS", 3, 2));
MPT_Test(MPT_ASSERT_NEQ_int, eq, .xfail=true);
MPT_Test(MPT_ASSERT_NEQ_int, lt, .xfail=false);
MPT_Test(MPT_ASSERT_NEQ_int, gt, .xfail=false);
MPT_ProcessEntry(proc_MPT_ASSERT_NEQ_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_NEQ(val1, val2, "MPT_ASSERT_NEQ(%f, %f), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_NEQ(val1, val2, "MPT_ASSERT_NEQ(%f, %f), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_NEQ_double, eq, id, proc_MPT_ASSERT_NEQ_double, MPT_ArgValues("FAIL", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_NEQ_double, lt, id, proc_MPT_ASSERT_NEQ_double, MPT_ArgValues("PASS", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_NEQ_double, gt, id, proc_MPT_ASSERT_NEQ_double, MPT_ArgValues("PASS", 1.3, 1.2));
MPT_Test(MPT_ASSERT_NEQ_double, eq, .xfail=true);
MPT_Test(MPT_ASSERT_NEQ_double, lt, .xfail=false);
MPT_Test(MPT_ASSERT_NEQ_double, gt, .xfail=false);
/************************************************************
* Test MPT_ASSERT_LEQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_LEQ_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_LEQ(val1, val2, "MPT_ASSERT_LEQ(%d, %d), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_LEQ(val1, val2, "MPT_ASSERT_LEQ(%d, %d), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_LEQ_int, eq, id, proc_MPT_ASSERT_LEQ_int, MPT_ArgValues("PASS", 1, 1));
MPT_TestProcess(MPT_ASSERT_LEQ_int, lt, id, proc_MPT_ASSERT_LEQ_int, MPT_ArgValues("PASS", 1, 2));
MPT_TestProcess(MPT_ASSERT_LEQ_int, gt, id, proc_MPT_ASSERT_LEQ_int, MPT_ArgValues("FAIL", 3, 2));
MPT_Test(MPT_ASSERT_LEQ_int, eq, .xfail=false);
MPT_Test(MPT_ASSERT_LEQ_int, lt, .xfail=false);
MPT_Test(MPT_ASSERT_LEQ_int, gt, .xfail=true);
MPT_ProcessEntry(proc_MPT_ASSERT_LEQ_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_LEQ(val1, val2, "MPT_ASSERT_LEQ(%f, %f), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_LEQ(val1, val2, "MPT_ASSERT_LEQ(%f, %f), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_LEQ_double, eq, id, proc_MPT_ASSERT_LEQ_double, MPT_ArgValues("PASS", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_LEQ_double, lt, id, proc_MPT_ASSERT_LEQ_double, MPT_ArgValues("PASS", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_LEQ_double, gt, id, proc_MPT_ASSERT_LEQ_double, MPT_ArgValues("FAIL", 1.3, 1.2));
MPT_Test(MPT_ASSERT_LEQ_double, eq, .xfail=false);
MPT_Test(MPT_ASSERT_LEQ_double, lt, .xfail=false);
MPT_Test(MPT_ASSERT_LEQ_double, gt, .xfail=true);
/************************************************************
* Test MPT_ASSERT_GEQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_GEQ_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_GEQ(val1, val2, "MPT_ASSERT_GEQ(%d, %d), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_GEQ(val1, val2, "MPT_ASSERT_GEQ(%d, %d), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_GEQ_int, eq, id, proc_MPT_ASSERT_GEQ_int, MPT_ArgValues("PASS", 1, 1));
MPT_TestProcess(MPT_ASSERT_GEQ_int, lt, id, proc_MPT_ASSERT_GEQ_int, MPT_ArgValues("FAIL", 1, 2));
MPT_TestProcess(MPT_ASSERT_GEQ_int, gt, id, proc_MPT_ASSERT_GEQ_int, MPT_ArgValues("PASS", 3, 2));
MPT_Test(MPT_ASSERT_GEQ_int, eq, .xfail=false);
MPT_Test(MPT_ASSERT_GEQ_int, lt, .xfail=true);
MPT_Test(MPT_ASSERT_GEQ_int, gt, .xfail=false);
MPT_ProcessEntry(proc_MPT_ASSERT_GEQ_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_GEQ(val1, val2, "MPT_ASSERT_GEQ(%f, %f), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_GEQ(val1, val2, "MPT_ASSERT_GEQ(%f, %f), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_GEQ_double, eq, id, proc_MPT_ASSERT_GEQ_double, MPT_ArgValues("PASS", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_GEQ_double, lt, id, proc_MPT_ASSERT_GEQ_double, MPT_ArgValues("FAIL", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_GEQ_double, gt, id, proc_MPT_ASSERT_GEQ_double, MPT_ArgValues("PASS", 1.3, 1.2));
MPT_Test(MPT_ASSERT_GEQ_double, eq, .xfail=false);
MPT_Test(MPT_ASSERT_GEQ_double, lt, .xfail=true);
MPT_Test(MPT_ASSERT_GEQ_double, gt, .xfail=false);
/************************************************************
* Test MPT_ASSERT_LT
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_LT_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_LT(val1, val2, "MPT_ASSERT_LT(%d, %d), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_LT(val1, val2, "MPT_ASSERT_LT(%d, %d), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_LT_int, eq, id, proc_MPT_ASSERT_LT_int, MPT_ArgValues("FAIL", 1, 1));
MPT_TestProcess(MPT_ASSERT_LT_int, lt, id, proc_MPT_ASSERT_LT_int, MPT_ArgValues("PASS", 1, 2));
MPT_TestProcess(MPT_ASSERT_LT_int, gt, id, proc_MPT_ASSERT_LT_int, MPT_ArgValues("FAIL", 3, 2));
MPT_Test(MPT_ASSERT_LT_int, eq, .xfail=true);
MPT_Test(MPT_ASSERT_LT_int, lt, .xfail=false);
MPT_Test(MPT_ASSERT_LT_int, gt, .xfail=true);
MPT_ProcessEntry(proc_MPT_ASSERT_LT_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_LT(val1, val2, "MPT_ASSERT_LT(%f, %f), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_LT(val1, val2, "MPT_ASSERT_LT(%f, %f), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_LT_double, eq, id, proc_MPT_ASSERT_LT_double, MPT_ArgValues("FAIL", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_LT_double, lt, id, proc_MPT_ASSERT_LT_double, MPT_ArgValues("PASS", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_LT_double, gt, id, proc_MPT_ASSERT_LT_double, MPT_ArgValues("FAIL", 1.3, 1.2));
MPT_Test(MPT_ASSERT_LT_double, eq, .xfail=true);
MPT_Test(MPT_ASSERT_LT_double, lt, .xfail=false);
MPT_Test(MPT_ASSERT_LT_double, gt, .xfail=true);
/************************************************************
* Test MPT_ASSERT_GT
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_GT_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_GT(val1, val2, "MPT_ASSERT_GT(%d, %d), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_GT(val1, val2, "MPT_ASSERT_GT(%d, %d), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_GT_int, eq, id, proc_MPT_ASSERT_GT_int, MPT_ArgValues("FAIL", 1, 1));
MPT_TestProcess(MPT_ASSERT_GT_int, lt, id, proc_MPT_ASSERT_GT_int, MPT_ArgValues("FAIL", 1, 2));
MPT_TestProcess(MPT_ASSERT_GT_int, gt, id, proc_MPT_ASSERT_GT_int, MPT_ArgValues("PASS", 3, 2));
MPT_Test(MPT_ASSERT_GT_int, eq, .xfail=true);
MPT_Test(MPT_ASSERT_GT_int, lt, .xfail=true);
MPT_Test(MPT_ASSERT_GT_int, gt, .xfail=false);
MPT_ProcessEntry(proc_MPT_ASSERT_GT_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_GT(val1, val2, "MPT_ASSERT_GT(%f, %f), 1st expect: %s", val1, val2, exp);
MPT_ASSERT_GT(val1, val2, "MPT_ASSERT_GT(%f, %f), 2nd expect: %s", val1, val2, exp);
}
MPT_TestProcess(MPT_ASSERT_GT_double, eq, id, proc_MPT_ASSERT_GT_double, MPT_ArgValues("FAIL", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_GT_double, lt, id, proc_MPT_ASSERT_GT_double, MPT_ArgValues("FAIL", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_GT_double, gt, id, proc_MPT_ASSERT_GT_double, MPT_ArgValues("PASS", 1.3, 1.2));
MPT_Test(MPT_ASSERT_GT_double, eq, .xfail=true);
MPT_Test(MPT_ASSERT_GT_double, lt, .xfail=true);
MPT_Test(MPT_ASSERT_GT_double, gt, .xfail=false);
/************************************************************
* Test MPT_ASSERT_NULL
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_NULL, MPT_Args(const char *exp, const void* ptr))
{
assert(exp);
MPT_ASSERT_NULL(ptr, "MPT_ASSERT_NULL(%p), expect: %s", ptr, exp);
}
MPT_TestProcess(MPT_ASSERT_NULL, addr, id, proc_MPT_ASSERT_NULL, MPT_ArgValues("FAIL", &dummy));
MPT_TestProcess(MPT_ASSERT_NULL, null, id, proc_MPT_ASSERT_NULL, MPT_ArgValues("PASS", NULL));
MPT_Test(MPT_ASSERT_NULL, addr, .xfail=true);
MPT_Test(MPT_ASSERT_NULL, null, .xfail=false);
/************************************************************
* Test MPT_ASSERT_NOT_NULL
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_NOT_NULL, MPT_Args(const char *exp, const void* ptr))
{
assert(exp);
MPT_ASSERT_NOT_NULL(ptr, "MPT_ASSERT_NOT_NULL(%p), expect: %s", ptr, exp);
}
MPT_TestProcess(MPT_ASSERT_NOT_NULL, addr, id, proc_MPT_ASSERT_NOT_NULL, MPT_ArgValues("PASS", &dummy));
MPT_TestProcess(MPT_ASSERT_NOT_NULL, null, id, proc_MPT_ASSERT_NOT_NULL, MPT_ArgValues("FAIL", NULL));
MPT_Test(MPT_ASSERT_NOT_NULL, addr, .xfail=false);
MPT_Test(MPT_ASSERT_NOT_NULL, null, .xfail=true);
/************************************************************
* Test MPT_ASSERT_STR_EQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_STR_EQ, MPT_Args(const char *exp, const char* val1, const char* val2))
{
assert(exp);
MPT_ASSERT_STR_EQ(val1, val2, "MPT_ASSERT_STR_EQ(%s, %s), expect: %s",
val1 ? val1 : "<null>",
val2 ? val2 : "<null>",
exp);
}
MPT_TestProcess(MPT_ASSERT_STR_EQ, eq, id, proc_MPT_ASSERT_STR_EQ, MPT_ArgValues("PASS", "foo", "foo"));
MPT_TestProcess(MPT_ASSERT_STR_EQ, neq, id, proc_MPT_ASSERT_STR_EQ, MPT_ArgValues("FAIL", "foo", "bar"));
MPT_TestProcess(MPT_ASSERT_STR_EQ, null1, id, proc_MPT_ASSERT_STR_EQ, MPT_ArgValues("FAIL", NULL, "foo"));
MPT_TestProcess(MPT_ASSERT_STR_EQ, null2, id, proc_MPT_ASSERT_STR_EQ, MPT_ArgValues("FAIL", "foo", NULL));
MPT_Test(MPT_ASSERT_STR_EQ, eq, .xfail=false);
MPT_Test(MPT_ASSERT_STR_EQ, neq, .xfail=true);
MPT_Test(MPT_ASSERT_STR_EQ, null1, .xfail=true);
MPT_Test(MPT_ASSERT_STR_EQ, null2, .xfail=true);
/************************************************************
* Test MPT_ASSERT_STR_NEQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_STR_NEQ, MPT_Args(const char *exp, const char* val1, const char* val2))
{
assert(exp);
MPT_ASSERT_STR_NEQ(val1, val2, "MPT_ASSERT_STR_NEQ(%s, %s), expect: %s",
val1 ? val1 : "<null>",
val2 ? val2 : "<null>",
exp);
}
MPT_TestProcess(MPT_ASSERT_STR_NEQ, eq, id, proc_MPT_ASSERT_STR_NEQ, MPT_ArgValues("FAIL", "foo", "foo"));
MPT_TestProcess(MPT_ASSERT_STR_NEQ, neq, id, proc_MPT_ASSERT_STR_NEQ, MPT_ArgValues("PASS", "foo", "bar"));
MPT_TestProcess(MPT_ASSERT_STR_NEQ, null1, id, proc_MPT_ASSERT_STR_NEQ, MPT_ArgValues("FAIL", NULL, "foo"));
MPT_TestProcess(MPT_ASSERT_STR_NEQ, null2, id, proc_MPT_ASSERT_STR_NEQ, MPT_ArgValues("FAIL", "foo", NULL));
MPT_Test(MPT_ASSERT_STR_NEQ, eq, .xfail=true);
MPT_Test(MPT_ASSERT_STR_NEQ, neq, .xfail=false);
MPT_Test(MPT_ASSERT_STR_NEQ, null1, .xfail=true);
MPT_Test(MPT_ASSERT_STR_NEQ, null2, .xfail=true);
/************************************************************
* Test MPT_ASSERT_STR_EMPTY
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_STR_EMPTY, MPT_Args(const char *exp, const char* val))
{
assert(exp);
MPT_ASSERT_STR_EMPTY(val, "MPT_ASSERT_STR_EMPTY(%s), expect: %s",
val ? val : "<null>",
exp);
}
MPT_TestProcess(MPT_ASSERT_STR_EMPTY, nempty, id, proc_MPT_ASSERT_STR_EMPTY, MPT_ArgValues("FAIL", "foo"));
MPT_TestProcess(MPT_ASSERT_STR_EMPTY, empty, id, proc_MPT_ASSERT_STR_EMPTY, MPT_ArgValues("PASS", ""));
MPT_TestProcess(MPT_ASSERT_STR_EMPTY, null, id, proc_MPT_ASSERT_STR_EMPTY, MPT_ArgValues("FAIL", NULL));
MPT_Test(MPT_ASSERT_STR_EMPTY, nempty, .xfail=true);
MPT_Test(MPT_ASSERT_STR_EMPTY, empty, .xfail=false);
MPT_Test(MPT_ASSERT_STR_EMPTY, null, .xfail=true);
/************************************************************
* Test MPT_ASSERT_STR_NOT_EMPTY
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_STR_NOT_EMPTY, MPT_Args(const char *exp, const char* val))
{
assert(exp);
MPT_ASSERT_STR_NOT_EMPTY(val, "MPT_ASSERT_STR_NOT_EMPTY(%s), expect: %s",
val ? val : "<null>",
exp);
}
MPT_TestProcess(MPT_ASSERT_STR_NOT_EMPTY, nempty, id, proc_MPT_ASSERT_STR_NOT_EMPTY, MPT_ArgValues("PASS", "foo"));
MPT_TestProcess(MPT_ASSERT_STR_NOT_EMPTY, empty, id, proc_MPT_ASSERT_STR_NOT_EMPTY, MPT_ArgValues("FAIL", ""));
MPT_TestProcess(MPT_ASSERT_STR_NOT_EMPTY, null, id, proc_MPT_ASSERT_STR_NOT_EMPTY, MPT_ArgValues("FAIL", NULL));
MPT_Test(MPT_ASSERT_STR_NOT_EMPTY, nempty, .xfail=false);
MPT_Test(MPT_ASSERT_STR_NOT_EMPTY, empty, .xfail=true);
MPT_Test(MPT_ASSERT_STR_NOT_EMPTY, null, .xfail=true);
/*****************************************************************************/
/************************************************************
* Test MPT_ASSERT_FATAL
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL, MPT_Args(const char *exp, int cond))
{
assert(exp);
MPT_ASSERT_FATAL(cond, "MPT_ASSERT_FATAL(%d), expect: %s", cond, exp);
MPT_ASSERT(cond, "MPT_ASSERT(%d) after a fatal", cond);
}
MPT_TestProcess(MPT_ASSERT_FATAL, pass, id, proc_MPT_ASSERT_FATAL, MPT_ArgValues("PASS", 1));
MPT_Test(MPT_ASSERT_FATAL, pass, .xfail=false);
MPT_TestProcess(MPT_ASSERT_FATAL, fail, id, proc_MPT_ASSERT_FATAL, MPT_ArgValues("FAIL", 0));
MPT_Test(MPT_ASSERT_FATAL, fail, .xfail=true);
/************************************************************
* Test MPT_ASSERT_FATAL_FAIL
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_FAIL, MPT_NoArgs())
{
MPT_ASSERT_FATAL_FAIL("MPT_ASSERT_FATAL_FAIL(), expect a fail, always");
MPT_ASSERT_FAIL("MPT_ASSERT_FAIL() after a fatal");
}
MPT_TestProcess(MPT_ASSERT_FATAL_FAIL, fail, id, proc_MPT_ASSERT_FATAL_FAIL, MPT_NoArgValues());
MPT_Test(MPT_ASSERT_FATAL_FAIL, fail, .xfail=true);
/************************************************************
* Test MPT_ASSERT_FATAL_EQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_EQ_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_FATAL_EQ(val1, val2, "MPT_ASSERT_FATAL_EQ(%d, %d), expect: %s", val1, val2, exp);
MPT_ASSERT_EQ(val1, val2, "MPT_ASSERT_EQ(%d, %d) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_EQ_int, eq, id, proc_MPT_ASSERT_FATAL_EQ_int, MPT_ArgValues("PASS", 1, 1));
MPT_TestProcess(MPT_ASSERT_FATAL_EQ_int, lt, id, proc_MPT_ASSERT_FATAL_EQ_int, MPT_ArgValues("FAIL", 1, 2));
MPT_TestProcess(MPT_ASSERT_FATAL_EQ_int, gt, id, proc_MPT_ASSERT_FATAL_EQ_int, MPT_ArgValues("FAIL", 3, 2));
MPT_Test(MPT_ASSERT_FATAL_EQ_int, eq, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_EQ_int, lt, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_EQ_int, gt, .xfail=true);
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_EQ_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_FATAL_EQ(val1, val2, "MPT_ASSERT_FATAL_EQ(%f, %f), expect: %s", val1, val2, exp);
MPT_ASSERT_EQ(val1, val2, "MPT_ASSERT_EQ(%f, %f) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_EQ_double, eq, id, proc_MPT_ASSERT_FATAL_EQ_double, MPT_ArgValues("PASS", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_FATAL_EQ_double, lt, id, proc_MPT_ASSERT_FATAL_EQ_double, MPT_ArgValues("FAIL", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_FATAL_EQ_double, gt, id, proc_MPT_ASSERT_FATAL_EQ_double, MPT_ArgValues("FAIL", 1.3, 1.2));
MPT_Test(MPT_ASSERT_FATAL_EQ_double, eq, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_EQ_double, lt, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_EQ_double, gt, .xfail=true);
/************************************************************
* Test MPT_ASSERT_FATAL_NEQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_NEQ_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_FATAL_NEQ(val1, val2, "MPT_ASSERT_FATAL_NEQ(%d, %d), expect: %s", val1, val2, exp);
MPT_ASSERT_NEQ(val1, val2, "MPT_ASSERT_NEQ(%d, %d) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_NEQ_int, eq, id, proc_MPT_ASSERT_FATAL_NEQ_int, MPT_ArgValues("FAIL", 1, 1));
MPT_TestProcess(MPT_ASSERT_FATAL_NEQ_int, lt, id, proc_MPT_ASSERT_FATAL_NEQ_int, MPT_ArgValues("PASS", 1, 2));
MPT_TestProcess(MPT_ASSERT_FATAL_NEQ_int, gt, id, proc_MPT_ASSERT_FATAL_NEQ_int, MPT_ArgValues("PASS", 3, 2));
MPT_Test(MPT_ASSERT_FATAL_NEQ_int, eq, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_NEQ_int, lt, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_NEQ_int, gt, .xfail=false);
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_NEQ_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_FATAL_NEQ(val1, val2, "MPT_ASSERT_FATAL_NEQ(%f, %f), expect: %s", val1, val2, exp);
MPT_ASSERT_NEQ(val1, val2, "MPT_ASSERT_NEQ(%f, %f) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_NEQ_double, eq, id, proc_MPT_ASSERT_FATAL_NEQ_double, MPT_ArgValues("FAIL", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_FATAL_NEQ_double, lt, id, proc_MPT_ASSERT_FATAL_NEQ_double, MPT_ArgValues("PASS", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_FATAL_NEQ_double, gt, id, proc_MPT_ASSERT_FATAL_NEQ_double, MPT_ArgValues("PASS", 1.3, 1.2));
MPT_Test(MPT_ASSERT_FATAL_NEQ_double, eq, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_NEQ_double, lt, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_NEQ_double, gt, .xfail=false);
/************************************************************
* Test MPT_ASSERT_FATAL_LEQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_LEQ_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_FATAL_LEQ(val1, val2, "MPT_ASSERT_FATAL_LEQ(%d, %d), expect: %s", val1, val2, exp);
MPT_ASSERT_LEQ(val1, val2, "MPT_ASSERT_LEQ(%d, %d) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_LEQ_int, eq, id, proc_MPT_ASSERT_FATAL_LEQ_int, MPT_ArgValues("PASS", 1, 1));
MPT_TestProcess(MPT_ASSERT_FATAL_LEQ_int, lt, id, proc_MPT_ASSERT_FATAL_LEQ_int, MPT_ArgValues("PASS", 1, 2));
MPT_TestProcess(MPT_ASSERT_FATAL_LEQ_int, gt, id, proc_MPT_ASSERT_FATAL_LEQ_int, MPT_ArgValues("FAIL", 3, 2));
MPT_Test(MPT_ASSERT_FATAL_LEQ_int, eq, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_LEQ_int, lt, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_LEQ_int, gt, .xfail=true);
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_LEQ_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_FATAL_LEQ(val1, val2, "MPT_ASSERT_FATAL_LEQ(%f, %f), expect: %s", val1, val2, exp);
MPT_ASSERT_LEQ(val1, val2, "MPT_ASSERT_LEQ(%f, %f) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_LEQ_double, eq, id, proc_MPT_ASSERT_FATAL_LEQ_double, MPT_ArgValues("PASS", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_FATAL_LEQ_double, lt, id, proc_MPT_ASSERT_FATAL_LEQ_double, MPT_ArgValues("PASS", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_FATAL_LEQ_double, gt, id, proc_MPT_ASSERT_FATAL_LEQ_double, MPT_ArgValues("FAIL", 1.3, 1.2));
MPT_Test(MPT_ASSERT_FATAL_LEQ_double, eq, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_LEQ_double, lt, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_LEQ_double, gt, .xfail=true);
/************************************************************
* Test MPT_ASSERT_FATAL_GEQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_GEQ_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_FATAL_GEQ(val1, val2, "MPT_ASSERT_FATAL_GEQ(%d, %d), expect: %s", val1, val2, exp);
MPT_ASSERT_GEQ(val1, val2, "MPT_ASSERT_GEQ(%d, %d) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_GEQ_int, eq, id, proc_MPT_ASSERT_FATAL_GEQ_int, MPT_ArgValues("PASS", 1, 1));
MPT_TestProcess(MPT_ASSERT_FATAL_GEQ_int, lt, id, proc_MPT_ASSERT_FATAL_GEQ_int, MPT_ArgValues("FAIL", 1, 2));
MPT_TestProcess(MPT_ASSERT_FATAL_GEQ_int, gt, id, proc_MPT_ASSERT_FATAL_GEQ_int, MPT_ArgValues("PASS", 3, 2));
MPT_Test(MPT_ASSERT_FATAL_GEQ_int, eq, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_GEQ_int, lt, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_GEQ_int, gt, .xfail=false);
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_GEQ_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_FATAL_GEQ(val1, val2, "MPT_ASSERT_FATAL_GEQ(%f, %f), expect: %s", val1, val2, exp);
MPT_ASSERT_GEQ(val1, val2, "MPT_ASSERT_GEQ(%f, %f) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_GEQ_double, eq, id, proc_MPT_ASSERT_FATAL_GEQ_double, MPT_ArgValues("PASS", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_FATAL_GEQ_double, lt, id, proc_MPT_ASSERT_FATAL_GEQ_double, MPT_ArgValues("FAIL", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_FATAL_GEQ_double, gt, id, proc_MPT_ASSERT_FATAL_GEQ_double, MPT_ArgValues("PASS", 1.3, 1.2));
MPT_Test(MPT_ASSERT_FATAL_GEQ_double, eq, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_GEQ_double, lt, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_GEQ_double, gt, .xfail=false);
/************************************************************
* Test MPT_ASSERT_FATAL_LT
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_LT_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_FATAL_LT(val1, val2, "MPT_ASSERT_FATAL_LT(%d, %d), expect: %s", val1, val2, exp);
MPT_ASSERT_LT(val1, val2, "MPT_ASSERT_LT(%d, %d) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_LT_int, eq, id, proc_MPT_ASSERT_FATAL_LT_int, MPT_ArgValues("FAIL", 1, 1));
MPT_TestProcess(MPT_ASSERT_FATAL_LT_int, lt, id, proc_MPT_ASSERT_FATAL_LT_int, MPT_ArgValues("PASS", 1, 2));
MPT_TestProcess(MPT_ASSERT_FATAL_LT_int, gt, id, proc_MPT_ASSERT_FATAL_LT_int, MPT_ArgValues("FAIL", 3, 2));
MPT_Test(MPT_ASSERT_FATAL_LT_int, eq, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_LT_int, lt, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_LT_int, gt, .xfail=true);
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_LT_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_FATAL_LT(val1, val2, "MPT_ASSERT_FATAL_LT(%f, %f), expect: %s", val1, val2, exp);
MPT_ASSERT_LT(val1, val2, "MPT_ASSERT_LT(%f, %f) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_LT_double, eq, id, proc_MPT_ASSERT_FATAL_LT_double, MPT_ArgValues("FAIL", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_FATAL_LT_double, lt, id, proc_MPT_ASSERT_FATAL_LT_double, MPT_ArgValues("PASS", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_FATAL_LT_double, gt, id, proc_MPT_ASSERT_FATAL_LT_double, MPT_ArgValues("FAIL", 1.3, 1.2));
MPT_Test(MPT_ASSERT_FATAL_LT_double, eq, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_LT_double, lt, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_LT_double, gt, .xfail=true);
/************************************************************
* Test MPT_ASSERT_FATAL_GT
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_GT_int, MPT_Args(const char *exp, int val1, int val2))
{
assert(exp);
MPT_ASSERT_FATAL_GT(val1, val2, "MPT_ASSERT_FATAL_GT(%d, %d), expect: %s", val1, val2, exp);
MPT_ASSERT_GT(val1, val2, "MPT_ASSERT_GT(%d, %d) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_GT_int, eq, id, proc_MPT_ASSERT_FATAL_GT_int, MPT_ArgValues("FAIL", 1, 1));
MPT_TestProcess(MPT_ASSERT_FATAL_GT_int, lt, id, proc_MPT_ASSERT_FATAL_GT_int, MPT_ArgValues("FAIL", 1, 2));
MPT_TestProcess(MPT_ASSERT_FATAL_GT_int, gt, id, proc_MPT_ASSERT_FATAL_GT_int, MPT_ArgValues("PASS", 3, 2));
MPT_Test(MPT_ASSERT_FATAL_GT_int, eq, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_GT_int, lt, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_GT_int, gt, .xfail=false);
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_GT_double, MPT_Args(const char *exp, double val1, double val2))
{
assert(exp);
MPT_ASSERT_FATAL_GT(val1, val2, "MPT_ASSERT_FATAL_GT(%f, %f), expect: %s", val1, val2, exp);
MPT_ASSERT_GT(val1, val2, "MPT_ASSERT_GT(%f, %f) after a fatal", val1, val2);
}
MPT_TestProcess(MPT_ASSERT_FATAL_GT_double, eq, id, proc_MPT_ASSERT_FATAL_GT_double, MPT_ArgValues("FAIL", 1.1, 1.1));
MPT_TestProcess(MPT_ASSERT_FATAL_GT_double, lt, id, proc_MPT_ASSERT_FATAL_GT_double, MPT_ArgValues("FAIL", 1.1, 1.2));
MPT_TestProcess(MPT_ASSERT_FATAL_GT_double, gt, id, proc_MPT_ASSERT_FATAL_GT_double, MPT_ArgValues("PASS", 1.3, 1.2));
MPT_Test(MPT_ASSERT_FATAL_GT_double, eq, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_GT_double, lt, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_GT_double, gt, .xfail=false);
/************************************************************
* Test MPT_ASSERT_FATAL_NULL
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_NULL, MPT_Args(const char *exp, const void* ptr))
{
assert(exp);
MPT_ASSERT_FATAL_NULL(ptr, "MPT_ASSERT_FATAL_NULL(%p), expect: %s", ptr, exp);
}
MPT_TestProcess(MPT_ASSERT_FATAL_NULL, addr, id, proc_MPT_ASSERT_FATAL_NULL, MPT_ArgValues("FAIL", &dummy));
MPT_TestProcess(MPT_ASSERT_FATAL_NULL, null, id, proc_MPT_ASSERT_FATAL_NULL, MPT_ArgValues("PASS", NULL));
MPT_Test(MPT_ASSERT_FATAL_NULL, addr, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_NULL, null, .xfail=false);
/************************************************************
* Test MPT_ASSERT_FATAL_NOT_NULL
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_NOT_NULL, MPT_Args(const char *exp, const void* ptr))
{
assert(exp);
MPT_ASSERT_FATAL_NOT_NULL(ptr, "MPT_ASSERT_FATAL_NOT_NULL(%p), expect: %s", ptr, exp);
}
MPT_TestProcess(MPT_ASSERT_FATAL_NOT_NULL, addr, id, proc_MPT_ASSERT_FATAL_NOT_NULL, MPT_ArgValues("PASS", &dummy));
MPT_TestProcess(MPT_ASSERT_FATAL_NOT_NULL, null, id, proc_MPT_ASSERT_FATAL_NOT_NULL, MPT_ArgValues("FAIL", NULL));
MPT_Test(MPT_ASSERT_FATAL_NOT_NULL, addr, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_NOT_NULL, null, .xfail=true);
/************************************************************
* Test MPT_ASSERT_FATAL_STR_EQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_STR_EQ, MPT_Args(const char *exp, const char* val1, const char* val2))
{
assert(exp);
MPT_ASSERT_FATAL_STR_EQ(val1, val2, "MPT_ASSERT_FATAL_STR_EQ(%s, %s), expect: %s",
val1 ? val1 : "<null>",
val2 ? val2 : "<null>",
exp);
}
MPT_TestProcess(MPT_ASSERT_FATAL_STR_EQ, eq, id, proc_MPT_ASSERT_FATAL_STR_EQ, MPT_ArgValues("PASS", "foo", "foo"));
MPT_TestProcess(MPT_ASSERT_FATAL_STR_EQ, neq, id, proc_MPT_ASSERT_FATAL_STR_EQ, MPT_ArgValues("FAIL", "foo", "bar"));
MPT_TestProcess(MPT_ASSERT_FATAL_STR_EQ, null1, id, proc_MPT_ASSERT_FATAL_STR_EQ, MPT_ArgValues("FAIL", NULL, "foo"));
MPT_TestProcess(MPT_ASSERT_FATAL_STR_EQ, null2, id, proc_MPT_ASSERT_FATAL_STR_EQ, MPT_ArgValues("FAIL", "foo", NULL));
MPT_Test(MPT_ASSERT_FATAL_STR_EQ, eq, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_STR_EQ, neq, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_STR_EQ, null1, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_STR_EQ, null2, .xfail=true);
/************************************************************
* Test MPT_ASSERT_FATAL_STR_NEQ
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_STR_NEQ, MPT_Args(const char *exp, const char* val1, const char* val2))
{
assert(exp);
MPT_ASSERT_FATAL_STR_NEQ(val1, val2, "MPT_ASSERT_FATAL_STR_NEQ(%s, %s), expect: %s",
val1 ? val1 : "<null>",
val2 ? val2 : "<null>",
exp);
}
MPT_TestProcess(MPT_ASSERT_FATAL_STR_NEQ, eq, id, proc_MPT_ASSERT_FATAL_STR_NEQ, MPT_ArgValues("FAIL", "foo", "foo"));
MPT_TestProcess(MPT_ASSERT_FATAL_STR_NEQ, neq, id, proc_MPT_ASSERT_FATAL_STR_NEQ, MPT_ArgValues("PASS", "foo", "bar"));
MPT_TestProcess(MPT_ASSERT_FATAL_STR_NEQ, null1, id, proc_MPT_ASSERT_FATAL_STR_NEQ, MPT_ArgValues("FAIL", NULL, "foo"));
MPT_TestProcess(MPT_ASSERT_FATAL_STR_NEQ, null2, id, proc_MPT_ASSERT_FATAL_STR_NEQ, MPT_ArgValues("FAIL", "foo", NULL));
MPT_Test(MPT_ASSERT_FATAL_STR_NEQ, eq, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_STR_NEQ, neq, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_STR_NEQ, null1, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_STR_NEQ, null2, .xfail=true);
/************************************************************
* Test MPT_ASSERT_FATAL_STR_EMPTY
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_STR_EMPTY, MPT_Args(const char *exp, const char* val))
{
assert(exp);
MPT_ASSERT_FATAL_STR_EMPTY(val, "MPT_ASSERT_FATAL_STR_EMPTY(%s), expect: %s",
val ? val : "<null>",
exp);
}
MPT_TestProcess(MPT_ASSERT_FATAL_STR_EMPTY, nempty, id, proc_MPT_ASSERT_FATAL_STR_EMPTY, MPT_ArgValues("FAIL", "foo"));
MPT_TestProcess(MPT_ASSERT_FATAL_STR_EMPTY, empty, id, proc_MPT_ASSERT_FATAL_STR_EMPTY, MPT_ArgValues("PASS", ""));
MPT_TestProcess(MPT_ASSERT_FATAL_STR_EMPTY, null, id, proc_MPT_ASSERT_FATAL_STR_EMPTY, MPT_ArgValues("FAIL", NULL));
MPT_Test(MPT_ASSERT_FATAL_STR_EMPTY, nempty, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_STR_EMPTY, empty, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_STR_EMPTY, null, .xfail=true);
/************************************************************
* Test MPT_ASSERT_FATAL_STR_NOT_EMPTY
************************************************************/
MPT_ProcessEntry(proc_MPT_ASSERT_FATAL_STR_NOT_EMPTY, MPT_Args(const char *exp, const char* val))
{
assert(exp);
MPT_ASSERT_FATAL_STR_NOT_EMPTY(val, "MPT_ASSERT_FATAL_STR_NOT_EMPTY(%s), expect: %s",
val ? val : "<null>",
exp);
}
MPT_TestProcess(MPT_ASSERT_FATAL_STR_NOT_EMPTY, nempty, id, proc_MPT_ASSERT_FATAL_STR_NOT_EMPTY, MPT_ArgValues("PASS", "foo"));
MPT_TestProcess(MPT_ASSERT_FATAL_STR_NOT_EMPTY, empty, id, proc_MPT_ASSERT_FATAL_STR_NOT_EMPTY, MPT_ArgValues("FAIL", ""));
MPT_TestProcess(MPT_ASSERT_FATAL_STR_NOT_EMPTY, null, id, proc_MPT_ASSERT_FATAL_STR_NOT_EMPTY, MPT_ArgValues("FAIL", NULL));
MPT_Test(MPT_ASSERT_FATAL_STR_NOT_EMPTY, nempty, .xfail=false);
MPT_Test(MPT_ASSERT_FATAL_STR_NOT_EMPTY, empty, .xfail=true);
MPT_Test(MPT_ASSERT_FATAL_STR_NOT_EMPTY, null, .xfail=true);
/*****************************************************************************/
/************************************************************
* Test propagation,
* Check if failure/success is actually propagated to ctest.
************************************************************/
MPT_ProcessEntry(proc_propagation, MPT_Args(const char *exp, int cond, dds_duration_t delay))
{
assert(exp);
if (delay > 0) {
dds_sleepfor(delay);
}
MPT_ASSERT(cond, "MPT_ASSERT(%d), expect: %s", cond, exp);
}
/* This should pass in the ctest results. */
MPT_TestProcess(propagation, pass, id1, proc_propagation, MPT_ArgValues("PASS", 1, 0));
MPT_TestProcess(propagation, pass, id2, proc_propagation, MPT_ArgValues("PASS", 1, 0));
MPT_Test(propagation, pass);
/* This should fail in the ctest results. */
MPT_TestProcess(propagation, fail_1st, id1, proc_propagation, MPT_ArgValues("FAIL", 0, 0));
MPT_TestProcess(propagation, fail_1st, id2, proc_propagation, MPT_ArgValues("PASS", 1, DDS_SECS(1)));
MPT_Test(propagation, fail_1st);
/* This should fail in the ctest results. */
MPT_TestProcess(propagation, fail_2nd, id1, proc_propagation, MPT_ArgValues("PASS", 1, 0));
MPT_TestProcess(propagation, fail_2nd, id2, proc_propagation, MPT_ArgValues("FAIL", 0, DDS_SECS(1)));
MPT_Test(propagation, fail_2nd);

96
src/mpt/tests/self/environments.c Normal file
View file

@ -0,0 +1,96 @@
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "mpt/mpt.h"
#include "mpt/resource.h" /* MPT_SOURCE_ROOT_DIR */
#include "dds/ddsrt/environ.h"
/************************************************************
* Process
************************************************************/
MPT_ProcessEntry(proc_environments, MPT_Args(mpt_env_t *exp))
{
assert(exp);
while ((exp->name != NULL) && (exp->value != NULL)) {
/* The environment variable value should match the expected value. */
char *ptr = NULL;
ddsrt_getenv(exp->name, &ptr);
if (ptr) {
MPT_ASSERT((strcmp(exp->value, ptr) == 0), "%s: found \"%s\", expected \"%s\"", exp->name, ptr, exp->value);
} else {
MPT_ASSERT(0, "Expected \"%s\" not found in environment", exp->name);
}
exp++;
}
}
/************************************************************
* Basic environment tests
************************************************************/
static mpt_env_t environ_basic[] = {
{ "MY_ENV_VAR1", "1" },
{ "MY_ENV_VAR2", "2" },
{ NULL, NULL }
};
MPT_TestProcess(environment, proc, id, proc_environments, MPT_ArgValues(environ_basic), .environment=environ_basic);
MPT_Test(environment, proc);
MPT_TestProcess(environment, test, id, proc_environments, MPT_ArgValues(environ_basic));
MPT_Test(environment, test, .environment=environ_basic);
/************************************************************
* Expanding variables environment tests
************************************************************/
static mpt_env_t environ_expand[] = {
{ "1", "b" },
{ "2", "${1}l" },
{ "3", "${2}aat" },
{ "4", "bla${1}${2}a${3}" },
{ NULL, NULL }
};
static mpt_env_t expect_expand[] = {
{ "1", "b" },
{ "2", "bl" },
{ "3", "blaat" },
{ "4", "blabblablaat" },
{ NULL, NULL }
};
MPT_TestProcess(environment, expand_proc, id, proc_environments, MPT_ArgValues(expect_expand), .environment=environ_expand);
MPT_Test(environment, expand_proc);
MPT_TestProcess(environment, expand_test, id, proc_environments, MPT_ArgValues(expect_expand));
MPT_Test(environment, expand_test, .environment=environ_expand);
/************************************************************
* Environment inheritance test
************************************************************/
static mpt_env_t environ_test[] = {
{ "ETC_DIR", MPT_SOURCE_ROOT_DIR"/tests/self/etc" },
{ "OVERRULE", "NO" },
{ NULL, NULL }
};
static mpt_env_t environ_proc[] = {
{ "CYCLONE_URI", "file://${ETC_DIR}/ospl.xml" },
{ "OVERRULE", "YES" },
{ "EXTRA", "proc" },
{ NULL, NULL }
};
static mpt_env_t environ_test_proc[] = {
{ "ETC_DIR", MPT_SOURCE_ROOT_DIR"/tests/self/etc" },
{ "CYCLONE_URI", "file://"MPT_SOURCE_ROOT_DIR"/tests/self/etc/ospl.xml" },
{ "OVERRULE", "YES" },
{ "EXTRA", "proc" },
{ NULL, NULL }
};
MPT_TestProcess(environment, inheritance, id, proc_environments, MPT_ArgValues(environ_test_proc), .environment=environ_proc);
MPT_Test(environment, inheritance, .environment=environ_test);

0
src/mpt/tests/self/etc/file Normal file
View file

72
src/mpt/tests/self/fixtures.c Normal file
View file

@ -0,0 +1,72 @@
#include <stdio.h>
#include "mpt/mpt.h"
#include "mpt/resource.h" /* MPT_SOURCE_ROOT_DIR */
#include "dds/ddsrt/time.h"
/************************************************************
* Support functions
************************************************************/
static int g_initcnt = 0;
static void init_inc(void)
{
g_initcnt++;
};
/************************************************************
* Processes
************************************************************/
MPT_ProcessEntry(proc_initcnt, MPT_Args(int init))
{
MPT_ASSERT((g_initcnt == init), "init count: %d vs %d", g_initcnt, init);
}
MPT_ProcessEntry(proc_sleep, MPT_Args(dds_duration_t delay))
{
MPT_ASSERT((delay > 0), "basically just to satisfy the compiler");
dds_sleepfor(delay);
}
/************************************************************
* Init fixture tests
************************************************************/
MPT_TestProcess(init, none, id, proc_initcnt, MPT_ArgValues(0));
MPT_Test(init, none);
MPT_TestProcess(init, null, id, proc_initcnt, MPT_ArgValues(0), .init=NULL);
MPT_Test(init, null, .init=NULL);
MPT_TestProcess(init, proc, id, proc_initcnt, MPT_ArgValues(1), .init=init_inc);
MPT_Test(init, proc);
MPT_TestProcess(init, test, id, proc_initcnt, MPT_ArgValues(1));
MPT_Test(init, test, .init=init_inc);
MPT_TestProcess(init, test_proc, id, proc_initcnt, MPT_ArgValues(2), .init=init_inc);
MPT_Test(init, test_proc, .init=init_inc);
/************************************************************
* Disable fixture tests
************************************************************/
MPT_TestProcess(disabled, _true, id, proc_initcnt, MPT_ArgValues(0));
MPT_Test(disabled, _true, .disabled=true);
MPT_TestProcess(disabled, _false, id, proc_initcnt, MPT_ArgValues(0));
MPT_Test(disabled, _false, .disabled=false);
/************************************************************
* Timeout fixture tests
************************************************************/
/* See if a child process is killed when the parent is killed.
* This can only really be done manually, unfortunately. */
MPT_TestProcess(timeout, child_culling, id, proc_sleep, MPT_ArgValues(DDS_SECS(120)));
MPT_Test(timeout, child_culling, .timeout=1);

29
src/mpt/tests/self/ipc.c Normal file
View file

@ -0,0 +1,29 @@
#include <stdio.h>
#include "mpt/mpt.h"
/************************************************************
* Processes
************************************************************/
MPT_ProcessEntry(proc_ipc_send, MPT_NoArgs())
{
/* This will fail and cause an internal MPT assert as long
* as IPC is not yet implemented. */
MPT_Send("todo: implement");
}
MPT_ProcessEntry(proc_ipc_wait, MPT_NoArgs())
{
/* This will fail and cause an internal MPT assert as long
* as IPC is not yet implemented. */
MPT_Wait("todo: implement");
}
/************************************************************
* Tests
************************************************************/
MPT_TestProcess(ipc, TODO, id1, proc_ipc_send, MPT_NoArgValues());
MPT_TestProcess(ipc, TODO, id2, proc_ipc_wait, MPT_NoArgValues());
MPT_Test(ipc, TODO);

30
src/mpt/tests/self/resources.c Normal file
View file

@ -0,0 +1,30 @@
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "mpt/mpt.h"
#include "mpt/resource.h" /* MPT_SOURCE_ROOT_DIR */
/************************************************************
* Processes
************************************************************/
MPT_ProcessEntry(proc_file, MPT_NoArgs())
{
const char *test_file = MPT_SOURCE_ROOT_DIR"/tests/self/etc/file";
#if _WIN32
struct _stat buffer;
int ret = _stat(test_file,&buffer);
#else
struct stat buffer;
int ret = stat(test_file,&buffer);
#endif
MPT_ASSERT((ret == 0), "%s", test_file);
}
/************************************************************
* Test if MPT_SOURCE_ROOT_DIR is a valid location.
************************************************************/
MPT_TestProcess(resources, root_dir, id, proc_file, MPT_NoArgValues());
MPT_Test(resources, root_dir);

186
src/mpt/tests/self/usage.c Normal file
View file

@ -0,0 +1,186 @@
#include <stdio.h>
#include "mpt/mpt.h"
#include "mpt/resource.h" /* MPT_SOURCE_ROOT_DIR */
/******************************************************************************
* First, we need a process entry-point that can be used in tests.
*****************************************************************************/
/* | name | arguments | */
MPT_ProcessEntry(proc_noargs, MPT_NoArgs())
{
// Do stuff
// The test processes will use asserts to indicate success/failures.
MPT_ASSERT(1, "The problem is: %s", "existential crisis");
// No need to return anything, that's handled by the assert calls.
}
/******************************************************************************
* A process entry-point can have arguments.
*****************************************************************************/
/* | name | arguments | */
MPT_ProcessEntry(proc_args, MPT_Args(int domain, const char* text))
{
int expected = 1;
MPT_ASSERT(expected == domain, "proc_args(%d, %s)", domain, text);
}
/******************************************************************************
* Process entry-points can communicate to be able to sync fi.
*****************************************************************************/
MPT_ProcessEntry(proc_recv, MPT_NoArgs())
{
/* This will wait until another process sends the same string. */
MPT_Wait("some state reached");
}
MPT_ProcessEntry(proc_send, MPT_NoArgs())
{
/* If this fails, an internal MPT_ASSERT will be triggered.
* The same is true for MPT_Wait(). */
MPT_Send("some state reached");
}
/******************************************************************************
* Test: suitename_testA
******************************************************************************
* A simple test that starts two processes. Because a test can use the same
* process entry-point to start multiple processes, each process has to have
* its own unique id within the test.
*/
/* | process identification | entry-point | arguments | */
MPT_TestProcess(suitename, testA, id1, proc_noargs, MPT_NoArgValues());
MPT_TestProcess(suitename, testA, id2, proc_noargs, MPT_NoArgValues());
MPT_Test(suitename, testA);
/******************************************************************************
* Test: suitename_testB
******************************************************************************
* Of course, different processes can be started as well.
* Argument values are provided per test process.
*/
MPT_TestProcess(suitename, testB, id1, proc_noargs, MPT_NoArgValues( ));
MPT_TestProcess(suitename, testB, id2, proc_args, MPT_ArgValues(1, "2"));
MPT_TestProcess(suitename, testB, id3, proc_args, MPT_ArgValues(1, "3"));
MPT_Test(suitename, testB);
/******************************************************************************
* Test: suitename_testC
******************************************************************************
* The processes can have different or equal 'system environments'.
*/
mpt_env_t environment_C1[] = {
{ "CYCLONEDDS_URI", "file://config1.xml" },
{ "PERMISSIONS", "file://permissions.p7s" },
{ "GOVERNANCE", "file://governance.p7s" },
{ NULL, NULL }
};
mpt_env_t environment_C2[] = {
{ "CYCLONEDDS_URI", "file://config2.xml" },
{ "PERMISSIONS", "file://permissions.p7s" },
{ "GOVERNANCE", "file://governance.p7s" },
{ NULL, NULL }
};
MPT_TestProcess(suitename, testC, id1, proc_noargs, MPT_NoArgValues(), .environment=environment_C1);
MPT_TestProcess(suitename, testC, id2, proc_noargs, MPT_NoArgValues(), .environment=environment_C1);
MPT_TestProcess(suitename, testC, id3, proc_noargs, MPT_NoArgValues(), .environment=environment_C2);
MPT_Test(suitename, testC);
/******************************************************************************
* Test: suitename_testD
******************************************************************************
* The two environments in the previous example are partly the same.
* It's possible set the environment on test level. The environment variables
* related to the test are set before the ones related to a process. This
* means that a process can overrule variables.
*
* The following test is the same as the previous one.
*/
mpt_env_t environment_D1[] = {
{ "CYCLONEDDS_URI", "file://config1.xml" },
{ "PERMISSIONS", "file://permissions.p7s" },
{ "GOVERNANCE", "file://governance.p7s" },
{ NULL, NULL }
};
mpt_env_t environment_D2[] = {
{ "CYCLONEDDS_URI", "file://config2.xml" },
{ NULL, NULL }
};
MPT_TestProcess(suitename, testD, id1, proc_noargs, MPT_NoArgValues());
MPT_TestProcess(suitename, testD, id2, proc_noargs, MPT_NoArgValues());
MPT_TestProcess(suitename, testD, id3, proc_noargs, MPT_NoArgValues(), .environment=environment_D2);
MPT_Test(suitename, testD, .environment=environment_D1);
/******************************************************************************
* Test: suitename_testE
******************************************************************************
* Environment variables will be expanded.
* Also, the MPT_SOURCE_ROOT_DIR define contains a string to that particular
* directory.
* This can be combined to easily point to files.
*/
mpt_env_t environment_E[] = {
{ "ETC_DIR", MPT_SOURCE_ROOT_DIR"/tests/self/etc" },
{ "CYCLONEDDS_URI", "file://${ETC_DIR}/config.xml" },
{ NULL, NULL }
};
MPT_TestProcess(suitename, testE, id, proc_noargs, MPT_NoArgValues(), .environment=environment_E);
MPT_Test(suitename, testE);
/******************************************************************************
* Test: suitename_testF
******************************************************************************
* The processes and tests can use init/fini fixtures.
* The test init is executed before the process init.
* The process fini is executed before the test fini.
*/
void proc_setup(void) { /* do stuff */ }
void proc_teardown(void) { /* do stuff */ }
void test_setup(void) { /* do stuff */ }
void test_teardown(void) { /* do stuff */ }
MPT_TestProcess(suitename, testF, id1, proc_noargs, MPT_NoArgValues(), .init=proc_setup);
MPT_TestProcess(suitename, testF, id2, proc_noargs, MPT_NoArgValues(), .fini=proc_teardown);
MPT_TestProcess(suitename, testF, id3, proc_noargs, MPT_NoArgValues(), .init=proc_setup, .fini=proc_teardown);
MPT_Test(suitename, testF, .init=test_setup, .fini=test_teardown);
/******************************************************************************
* Test: suitename_testG
******************************************************************************
* The timeout and disable options are handled by test fixtures.
*/
MPT_TestProcess(suitename, testG, id1, proc_noargs, MPT_NoArgValues());
MPT_TestProcess(suitename, testG, id2, proc_noargs, MPT_NoArgValues());
MPT_Test(suitename, testG, .timeout=10, .disabled=true);
/******************************************************************************
* Test: suitename_testH
******************************************************************************
* See the process entries to notice the MPT Send/Wait IPC.
*/
MPT_TestProcess(suitename, testH, id1, proc_recv, MPT_NoArgValues());
MPT_TestProcess(suitename, testH, id2, proc_send, MPT_NoArgValues());
MPT_Test(suitename, testH);