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

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);