void Test_configure_stdout() {
ResourceMark rm;
LogHandle(logging) log;
LogOutput* stdoutput = LogOutput::Stdout;
// Save current stdout config and clear it
char* saved_config = os::strdup_check_oom(stdoutput->config_string());
LogConfiguration::parse_log_arguments("stdout", "all=off", NULL, NULL, log.error_stream());
// Enable 'logging=info', verifying it has been set
LogConfiguration::configure_stdout(LogLevel::Info, true, LOG_TAGS(logging));
assert_str_eq("logging=info,", stdoutput->config_string());
assert(log_is_enabled(Info, logging), "logging was not properly enabled");
// Enable 'gc=debug' (no wildcard), verifying no other tags are enabled
LogConfiguration::configure_stdout(LogLevel::Debug, true, LOG_TAGS(gc));
// No '+' character means only single tags are enabled, and no combinations
assert_char_not_in('+', stdoutput->config_string());
assert(log_is_enabled(Debug, gc), "logging was not properly enabled");
// Enable 'gc*=trace' (with wildcard), verifying at least one tag combination is enabled (gc+...)
LogConfiguration::configure_stdout(LogLevel::Trace, false, LOG_TAGS(gc));
assert_char_in('+', stdoutput->config_string());
assert(log_is_enabled(Trace, gc), "logging was not properly enabled");
// Disable 'gc*' and 'logging', verifying all logging is properly disabled
LogConfiguration::configure_stdout(LogLevel::Off, false, LOG_TAGS(gc));
LogConfiguration::configure_stdout(LogLevel::Off, true, LOG_TAGS(logging));
assert_str_eq("all=off", stdoutput->config_string());
// Restore saved configuration
LogConfiguration::parse_log_arguments("stdout", saved_config, NULL, NULL, log.error_stream());
os::free(saved_config);
}
static void
test_uri_pin_value (void)
{
P11KitUri *uri;
const char *pin_value;
char *string;
int ret;
uri = p11_kit_uri_new ();
assert_ptr_not_null (uri);
p11_kit_uri_set_pin_value (uri, "123456");
pin_value = p11_kit_uri_get_pin_value (uri);
assert_str_eq ("123456", pin_value);
p11_kit_uri_set_pin_value (uri, "1*&#%&@(");
pin_value = p11_kit_uri_get_pin_value (uri);
assert_str_eq ("1*&#%&@(", pin_value);
ret = p11_kit_uri_format (uri, P11_KIT_URI_FOR_ANY, &string);
assert_num_eq (P11_KIT_URI_OK, ret);
assert (strstr (string, "pkcs11:?pin-value=1%2a%26%23%25%26%40%28") != NULL);
free (string);
ret = p11_kit_uri_parse ("pkcs11:?pin-value=blah%2Fblah", P11_KIT_URI_FOR_ANY, uri);
assert_num_eq (P11_KIT_URI_OK, ret);
pin_value = p11_kit_uri_get_pin_value (uri);
assert_str_eq ("blah/blah", pin_value);
p11_kit_uri_free (uri);
}
//verifies a message with all types included serializes and deserializes
int main()
{
unsigned message_len;
int32_t i = 42; //integer
float f = 0.25; //float
const char *s = "string"; //string
rtosc_blob_t b = {3,(uint8_t*)s};//blob
int64_t h = -125; //long integer
uint64_t t = 22412; //timetag
double d = 0.125; //double
const char *S = "Symbol"; //symbol
char c = 25; //character
int32_t r = 0x12345678; //RGBA
midi_t m = {0x12,0x23, //midi
0x34,0x45
};
//true
//false
//nil
//inf
message_len = rtosc_message(buffer, 1024, "/dest",
"[ifsbhtdScrmTFNI]", i,f,s,b.len,b.data,h,t,d,S,c,r,m);
assert_int_eq(96, message_len,
"Generating A Message With All Arg Types", __LINE__);
rtosc_arg_t arg;
assert_int_eq(i, rtosc_argument(buffer, 0).i,
"Checking 'i' Argument", __LINE__);
CHECK(f,f,1);
assert_str_eq(s, rtosc_argument(buffer, 2).s,
"Checking 's' Argument", __LINE__);
CHECK(b.len,b.len,3);
assert_hex_eq((char*)b.data, (char*)arg.b.data, 3, b.len,
"Checking 'b.data' Argument", __LINE__);
CHECK(h,h,4);
CHECK(t,t,5);
CHECK(d,d,6);
assert_str_eq(S,rtosc_argument(buffer, 7).s,
"Checking 'S' Argument", __LINE__);
assert_char_eq(c,rtosc_argument(buffer, 8).i,
"Checking 'c' Argument", __LINE__);
CHECK(r,i,9);
CHECK(m,m,10);
assert_char_eq('T', rtosc_type(buffer,11),
"Checking 'T' Argument", __LINE__);
assert_char_eq('F', rtosc_type(buffer,12),
"Checking 'F' Argument", __LINE__);
assert_char_eq('N', rtosc_type(buffer,13),
"Checking 'N' Argument", __LINE__);
assert_char_eq('I', rtosc_type(buffer,14),
"Checking 'I' Argument", __LINE__);
assert_true(rtosc_valid_message_p(buffer, message_len),
"Verifying Message Is Valid", __LINE__);
return test_summary();
}
static CK_RV
override_initialize (CK_X_FUNCTION_LIST *self,
CK_VOID_PTR args)
{
Override *over = (Override *)self;
assert_str_eq ("initialize-arg", args);
assert_str_eq ("overide-arg", over->check);
/* An arbitrary error code to check */
return CKR_NEED_TO_CREATE_THREADS;
}
int main()
{
//Message 1
assert_int_eq(sizeof(MSG1)-1, len_a = rtosc_message(buffer_a, 256,
"/flying-monkey", "s", "bannana"),
"Creating Simple Message 1", __LINE__);
assert_hex_eq(MSG1, buffer_a, sizeof(MSG1)-1, len_a,
"Verifying Content of Message 1", __LINE__);
assert_int_eq(0, rtosc_bundle_p(buffer_a),
"Simple Message 1 Is Not A Bundle", __LINE__);
//Message 2
assert_int_eq(sizeof(MSG2)-1, len_b = rtosc_message(buffer_b, 256,
"/foobar-message", "iT", 42),
"Creating Simple Message 2", __LINE__);
assert_hex_eq(MSG2, buffer_b, sizeof(MSG2)-1, len_b,
"Verifying Content of Message 2", __LINE__);
assert_int_eq(0, rtosc_bundle_p(buffer_b),
"Simple Message 2 Is Not A Bundle", __LINE__);
//Bundle 1
assert_int_eq(sizeof(RESULT)-1, len_c = rtosc_bundle(buffer_c, 256, 0, 2, buffer_a, buffer_b),
"Creating Bundle 1", __LINE__);
assert_int_eq(len_c, rtosc_message_length(buffer_c, len_c),
"Verifying Bundle 1's Length", __LINE__);
assert_hex_eq(RESULT, buffer_c, sizeof(RESULT)-1, len_c,
"Verifying Bundle 1's Content", __LINE__);
assert_int_eq(1, rtosc_bundle_p(buffer_c),
"Verifying Bundle 1 Is A Bundle", __LINE__);
assert_int_eq(2, rtosc_bundle_elements(buffer_c, 256),
"Verifying Bundle 2 Has Two Messages", __LINE__);
assert_str_eq("/flying-monkey", rtosc_bundle_fetch(buffer_c, 0),
"Verifying Message 1 Path", __LINE__);
assert_str_eq("/foobar-message", rtosc_bundle_fetch(buffer_c, 1),
"Verifying Message 2 Path", __LINE__);
//Check minimum bundle size #bundle + time tag
assert_int_eq(8+8, rtosc_bundle(buffer_c, 256, 1, 0),
"Verify Minimum Legal Bundle Size", __LINE__);
//check message length support
assert_int_eq(8+8, rtosc_message_length(buffer_c, 256),
"Verify rtosc_message_length() on Minimum Bundle", __LINE__);
//Verify that timetag can be fetched
assert_int_eq(1, rtosc_bundle_timetag(buffer_c),
"Verify rtosc_bundle_timetag() Works", __LINE__);
return test_summary();
}
static void
test_iterate_remove (void)
{
p11_dict *map;
p11_dictiter iter;
char *keys[] = { "111", "222", "333" };
char *values[] = { "444", "555", "666" };
void *okeys[3];
void *ovalues[3];
bool ret;
int i;
map = p11_dict_new (p11_dict_str_hash, p11_dict_str_equal, NULL, NULL);
assert_ptr_not_null (map);
for (i = 0; i < 3; i++) {
if (!p11_dict_set (map, keys[i], values[i]))
assert_not_reached ();
}
p11_dict_iterate (map, &iter);
ret = p11_dict_next (&iter, &okeys[0], &ovalues[0]);
assert_num_eq (true, ret);
ret = p11_dict_next (&iter, &okeys[1], &ovalues[1]);
assert_num_eq (true, ret);
if (!p11_dict_remove (map, okeys[1]))
assert_not_reached ();
ret = p11_dict_next (&iter, &okeys[2], &ovalues[2]);
assert_num_eq (true, ret);
ret = p11_dict_next (&iter, NULL, NULL);
assert_num_eq (false, ret);
assert_num_eq (2, p11_dict_size (map));
p11_dict_free (map);
qsort (okeys, 3, sizeof (void *), compar_strings);
qsort (ovalues, 3, sizeof (void *), compar_strings);
for (i = 0; i < 3; i++) {
assert_str_eq (keys[i], okeys[i]);
assert_ptr_eq (keys[i], okeys[i]);
assert_str_eq (values[i], ovalues[i]);
assert_ptr_eq (values[i], ovalues[i]);
}
}
ASTRO_TEST_END
ASTRO_TEST_BEGIN(test_parse_object_multiple_keys)
{
enum cyjson_event_type event_type;
enum cyjson_data_type data_type;
cyjson_parser_t parser;
int retval;
char json[] = "{ \"key1\": \"value1\", \"key2\": \"value2\" }";
cyjson_parser_init(&parser, json);
retval = cyjson_parse(&parser);
assert_int_eq(0, retval, "cyjson_parse() failed");
event_type = cyjson_get_event_type(parser);
assert_int_eq(CYJSON_EVENT_OBJECT_BEGIN, event_type, "Wrong event type");
retval = cyjson_parse(&parser);
assert_int_eq(0, retval, "cyjson_parse() failed");
event_type = cyjson_get_event_type(parser);
assert_int_eq(CYJSON_EVENT_OBJECT_KEY, event_type, "Wrong event type");
data_type = cyjson_get_data_type(parser);
assert_int_eq(CYJSON_STRING, data_type, "Wrong data type");
assert_str_eq("key1", cyjson_get_string(parser), "Wrong key");
retval = cyjson_parse(&parser);
assert_int_eq(0, retval, "cyjson_parse() failed");
event_type = cyjson_get_event_type(parser);
assert_int_eq(CYJSON_EVENT_OBJECT_VALUE, event_type, "Wrong event type");
data_type = cyjson_get_data_type(parser);
assert_int_eq(CYJSON_STRING, data_type, "Wrong data type");
assert_str_eq("value1", cyjson_get_string(parser), "Wrong value");
retval = cyjson_parse(&parser);
assert_int_eq(0, retval, "cyjson_parse() failed");
event_type = cyjson_get_event_type(parser);
assert_int_eq(CYJSON_EVENT_OBJECT_KEY, event_type, "Wrong event type");
data_type = cyjson_get_data_type(parser);
assert_int_eq(CYJSON_STRING, data_type, "Wrong data type");
assert_str_eq("key2", cyjson_get_string(parser), "Wrong key");
retval = cyjson_parse(&parser);
assert_int_eq(0, retval, "cyjson_parse() failed");
event_type = cyjson_get_event_type(parser);
assert_int_eq(CYJSON_EVENT_OBJECT_VALUE, event_type, "Wrong event type");
data_type = cyjson_get_data_type(parser);
assert_int_eq(CYJSON_STRING, data_type, "Wrong data type");
assert_str_eq("value2", cyjson_get_string(parser), "Wrong value");
}
static CK_RV
override_initialize (CK_VOID_PTR init_args)
{
CK_C_INITIALIZE_ARGS_PTR args = init_args;
assert_str_eq ("initialize-arg", args->pReserved);
return mock_C_Initialize (init_args);
}
static void
mallctl_thread_name_get_impl(const char *thread_name_expected, const char *func,
int line)
{
const char *thread_name_old;
size_t sz;
sz = sizeof(thread_name_old);
assert_d_eq(mallctl("thread.prof.name", &thread_name_old, &sz, NULL, 0),
0, "%s():%d: Unexpected mallctl failure reading thread.prof.name",
func, line);
assert_str_eq(thread_name_old, thread_name_expected,
"%s():%d: Unexpected thread.prof.name value", func, line);
}
static void
test_uri_pin_source (void)
{
P11KitUri *uri;
const char *pin_source;
char *string;
int ret;
uri = p11_kit_uri_new ();
assert_ptr_not_null (uri);
p11_kit_uri_set_pin_source (uri, "|my-pin-source");
pin_source = p11_kit_uri_get_pin_source (uri);
assert_str_eq ("|my-pin-source", pin_source);
pin_source = p11_kit_uri_get_pinfile (uri);
assert_str_eq ("|my-pin-source", pin_source);
p11_kit_uri_set_pinfile (uri, "|my-pin-file");
pin_source = p11_kit_uri_get_pin_source (uri);
assert_str_eq ("|my-pin-file", pin_source);
ret = p11_kit_uri_format (uri, P11_KIT_URI_FOR_ANY, &string);
assert_num_eq (P11_KIT_URI_OK, ret);
assert (strstr (string, "pin-source=%7cmy-pin-file") != NULL);
free (string);
ret = p11_kit_uri_parse ("pkcs11:?pin-source=blah%2Fblah", P11_KIT_URI_FOR_ANY, uri);
assert_num_eq (P11_KIT_URI_OK, ret);
pin_source = p11_kit_uri_get_pin_source (uri);
assert_str_eq ("blah/blah", pin_source);
p11_kit_uri_free (uri);
}
ASTRO_TEST_END
ASTRO_TEST_BEGIN(test_parse_object_single_key)
{
enum cyjson_event_type event_type;
enum cyjson_data_type data_type;
cyjson_parser_t parser;
int retval;
cyjson_parser_init(&parser, "{ \"key\": \"value\" }");
retval = cyjson_parse(&parser);
assert_int_eq(0, retval, "cyjson_parse() failed");
event_type = cyjson_get_event_type(parser);
assert_int_eq(CYJSON_EVENT_OBJECT_BEGIN, event_type, "Wrong event type");
retval = cyjson_parse(&parser);
assert_int_eq(0, retval, "cyjson_parse() failed");
event_type = cyjson_get_event_type(parser);
assert_int_eq(CYJSON_EVENT_OBJECT_KEY, event_type, "Wrong event type");
data_type = cyjson_get_data_type(parser);
assert_int_eq(CYJSON_STRING, data_type, "Wrong data type");
assert_str_eq("key", cyjson_get_string(parser), "Data is wrong");
retval = cyjson_parse(&parser);
assert_int_eq(0, retval, "cyjson_parse() failed");
event_type = cyjson_get_event_type(parser);
assert_int_eq(CYJSON_EVENT_OBJECT_VALUE , event_type, "Wrong event type");
data_type = cyjson_get_data_type(parser);
assert_int_eq(CYJSON_STRING, data_type, "Wrong data type");
assert_str_eq("value", cyjson_get_string(parser), "Data is wrong");
retval = cyjson_parse(&parser);
assert_int_eq(0, retval, "cyjson_parse() failed");
event_type = cyjson_get_event_type(parser);
assert_int_eq(CYJSON_EVENT_OBJECT_END, event_type, "Wrong data type");
}
static void
test_type (void *data)
{
ChallengeFixture *fix = data;
char *type;
if (fix->ret != 0)
expect_message = "invalid reauthorize challenge";
assert_num_eq (reauthorize_type (fix->challenge, &type), fix->ret);
if (fix->ret == 0)
{
assert_str_eq (type, fix->expected);
free (type);
}
}
static void
test_user (void *data)
{
ChallengeFixture *fix = data;
char *user;
if (fix->ret != 0)
expect_message = "invalid reauthorize challenge";
assert_num_eq (reauthorize_user (fix->challenge, &user), fix->ret);
if (fix->ret == 0)
{
assert_str_eq (user, fix->expected);
free (user);
}
}
static void
test_crypt1 (void *data)
{
CryptFixture *fix = data;
char *response;
if (fix->ret != 0)
expect_message = "reauthorize challenge";
assert_num_eq (reauthorize_crypt1 (fix->challenge, fix->password, &response), fix->ret);
if (fix->ret == 0)
{
assert_str_eq (response, fix->expected);
free (response);
}
}
static void
test_uri_build_empty (void)
{
P11KitUri *uri;
char *string;
int ret;
uri = p11_kit_uri_new ();
assert_ptr_not_null (uri);
ret = p11_kit_uri_format (uri, P11_KIT_URI_FOR_ANY, &string);
assert_num_eq (P11_KIT_URI_OK, ret);
assert_str_eq ("pkcs11:", string);
free (string);
p11_kit_uri_free (uri);
}
TEST_END
TEST_BEGIN(test_malloc_strtoumax)
{
struct test_s {
const char *input;
const char *expected_remainder;
int base;
int expected_errno;
const char *expected_errno_name;
uintmax_t expected_x;
};
#define ERR(e) e, #e
#define UMAX(x) ((uintmax_t)x##ULL)
struct test_s tests[] = {
{"0", "0", -1, ERR(EINVAL), UINTMAX_MAX},
{"0", "0", 1, ERR(EINVAL), UINTMAX_MAX},
{"0", "0", 37, ERR(EINVAL), UINTMAX_MAX},
{"", "", 0, ERR(EINVAL), UINTMAX_MAX},
{"+", "+", 0, ERR(EINVAL), UINTMAX_MAX},
{"++3", "++3", 0, ERR(EINVAL), UINTMAX_MAX},
{"-", "-", 0, ERR(EINVAL), UINTMAX_MAX},
{"42", "", 0, ERR(0), UMAX(42)},
{"+42", "", 0, ERR(0), UMAX(42)},
{"-42", "", 0, ERR(0), UMAX(-42)},
{"042", "", 0, ERR(0), UMAX(042)},
{"+042", "", 0, ERR(0), UMAX(042)},
{"-042", "", 0, ERR(0), UMAX(-042)},
{"0x42", "", 0, ERR(0), UMAX(0x42)},
{"+0x42", "", 0, ERR(0), UMAX(0x42)},
{"-0x42", "", 0, ERR(0), UMAX(-0x42)},
{"0", "", 0, ERR(0), UMAX(0)},
{"1", "", 0, ERR(0), UMAX(1)},
{"42", "", 0, ERR(0), UMAX(42)},
{" 42", "", 0, ERR(0), UMAX(42)},
{"42 ", " ", 0, ERR(0), UMAX(42)},
{"0x", "x", 0, ERR(0), UMAX(0)},
{"42x", "x", 0, ERR(0), UMAX(42)},
{"07", "", 0, ERR(0), UMAX(7)},
{"010", "", 0, ERR(0), UMAX(8)},
{"08", "8", 0, ERR(0), UMAX(0)},
{"0_", "_", 0, ERR(0), UMAX(0)},
{"0x", "x", 0, ERR(0), UMAX(0)},
{"0X", "X", 0, ERR(0), UMAX(0)},
{"0xg", "xg", 0, ERR(0), UMAX(0)},
{"0XA", "", 0, ERR(0), UMAX(10)},
{"010", "", 10, ERR(0), UMAX(10)},
{"0x3", "x3", 10, ERR(0), UMAX(0)},
{"12", "2", 2, ERR(0), UMAX(1)},
{"78", "8", 8, ERR(0), UMAX(7)},
{"9a", "a", 10, ERR(0), UMAX(9)},
{"9A", "A", 10, ERR(0), UMAX(9)},
{"fg", "g", 16, ERR(0), UMAX(15)},
{"FG", "G", 16, ERR(0), UMAX(15)},
{"0xfg", "g", 16, ERR(0), UMAX(15)},
{"0XFG", "G", 16, ERR(0), UMAX(15)},
{"z_", "_", 36, ERR(0), UMAX(35)},
{"Z_", "_", 36, ERR(0), UMAX(35)}
};
#undef ERR
#undef UMAX
unsigned i;
for (i = 0; i < sizeof(tests)/sizeof(struct test_s); i++) {
struct test_s *test = &tests[i];
int err;
uintmax_t result;
char *remainder;
set_errno(0);
result = malloc_strtoumax(test->input, &remainder, test->base);
err = get_errno();
assert_d_eq(err, test->expected_errno,
"Expected errno %s for \"%s\", base %d",
test->expected_errno_name, test->input, test->base);
assert_str_eq(remainder, test->expected_remainder,
"Unexpected remainder for \"%s\", base %d",
test->input, test->base);
if (err == 0) {
assert_ju_eq(result, test->expected_x,
"Unexpected result for \"%s\", base %d",
test->input, test->base);
}
}
}
int main()
{
//clean buffer
memset(buffer1, 0xc3, sizeof(buffer1));
//generate liblo message 1
size_t len = 128;
lo_message message = lo_message_new();
assert_non_null(message, "Generating A Liblo Message 1 (int/float)", __LINE__);
lo_message_add_float(message, 24.0);
lo_message_add_int32(message, 42);
lo_message_serialise(message, "/path", buffer1, &len);
assert_str_eq("/path", buffer1, "Verifying Path From Message 1", __LINE__);
assert_f32_eq(24.0f, rtosc_argument(buffer1, 0).f,
"Verifying Float From Message 1", __LINE__);
assert_int_eq(42, rtosc_argument(buffer1, 1).i,
"Verifying Int From Message 1", __LINE__);
assert_int_eq(20, rtosc_message_length(buffer1, 128),
"Verifying Length From Message 1", __LINE__);
//Message 2
size_t len2 = rtosc_message(buffer2, 1024, "/li", "bb", 4, buffer1, 4, buffer1);
assert_int_eq(24, len2, "Generate A Rtosc Message 2 (bb)", __LINE__);
lo_message msg2 = lo_message_deserialise((void*)buffer2, len2, &result_var);
if(assert_non_null(msg2, "Deserialize Message 2 To Liblo", __LINE__))
printf("# Liblo Did Not Accept the Rtosc Message [error '%d']\n", result_var);
//Message 3
size_t len3 = rtosc_message(buffer3+4, 2048, "/close-ui", "");
assert_int_eq(16, len3, "Generate A Rtosc Message 3 ()", __LINE__);
lo_message msg3 = lo_message_deserialise((void*)(buffer3+4), len3, &result_var);
if(assert_non_null(msg2, "Deserialize Message 3 To Liblo", __LINE__))
printf("#Liblo Did Not Accept the Rtosc Message [error '%d']\n", result_var);
//Bundle 4
size_t len4 = rtosc_bundle(buffer4, 2048, 0xdeadbeefcafebaad, 3, buffer1, buffer2, buffer3+4);
assert_int_eq(88, len4, "Generate A Bundle 4", __LINE__);
//Bundle 5
lo_timetag time;
time.sec = 0xdeadbeef;
time.frac = 0xcafebaad;
lo_bundle ms4 = lo_bundle_new(time);
lo_bundle_add_message(ms4, "/path", message);
lo_bundle_add_message(ms4, "/li", msg2);
lo_bundle_add_message(ms4, "/close-ui", msg3);
size_t len5 = 2048;
lo_bundle_serialise(ms4,(void*)buffer5, &len5);
//Verify 4 == 5
assert_non_null(ms4, "Generate A Liblo Bundle 5", __LINE__);
assert_hex_eq(buffer5, buffer4, len5, len4,
"Verify Liblo Style Bundles", __LINE__);
//Cleanup
lo_message_free(message);
lo_message_free(msg2);
lo_message_free(msg3);
lo_bundle_free(ms4);
return test_summary();
}
int coro__ut_data_1( co_t *co_p )
{
static dword i;
if ( *co_p ) goto **co_p;
/* begin */
data_clear_watch( peek__ut_data_1 );
data_watch( peek__ut_data_1, _ut_data_1_watch );
data_set_byte( var__ut_byte, 1 );
data_set_dword( var__ut_array_1, 1 );
data_set_float( var__ut_float, 0.0 );
data_reset_all( peek__ut_data_2 );
/* Main operations */
for ( i = 0; i < CYCLE_COUNT; i++ ) {
/* 1 */
data_set_byte( var__ut_byte, ( byte ) i );
do {
/* wait */
*co_p = &&L__0;
L__0:
if (!( data_get_changed( peek__ut_data_1, var__ut_word ))) { /* cond */
return CO_WAIT;
}
} while ( 0 );
/* 3 */
data_reset( peek__ut_data_1, var__ut_word );
assert_u32_eq(( word ) i, data_get_word( var__ut_word ));
data_set_dword( var__ut_array_1, i << 8 );
do {
/* wait */
*co_p = &&L__1;
L__1:
if (!( data_get_changed( peek__ut_data_1, var__ut_array_3 ))) { /* cond */
return CO_WAIT;
}
} while ( 0 );
/* 5 */
data_reset( peek__ut_data_1, var__ut_array_3 );
assert_u32_eq( data_get_dword( var__ut_array_1 ), data_get_dword( var__ut_array_3 ));
data_set_dword( var__ut_array_0, data_get_dword( var__ut_array_2 ));
data_set_dword( var__ut_array_2, 0 );
data_set_float( var__ut_float, data_get_float( var__ut_float ) + 0.25 );
data_reset( peek__ut_data_1, var__ut_float );
do {
/* wait */
*co_p = &&L__2;
L__2:
if (!( data_get_changed( peek__ut_data_1, var__ut_float ))) { /* cond */
return CO_WAIT;
}
} while ( 0 );
}
assert_u32_eq( 0x55555555, data_get_dword( var__ut_array_0 ));
/* Auxiliary operations */
data_set_all_changed( peek__ut_data_1 );
assert(( data_get_changed( peek__ut_data_1, var__ut_word )
&& data_get_changed( peek__ut_data_1, var__ut_array_3 )
&& data_get_changed( peek__ut_data_1, var__ut_float )
&& !data_get_changed( peek__ut_data_1, var__ut_array_1 )
&& !data_get_changed( peek__ut_data_1, var__ut_array_2 ))
);
data_reset_all( peek__ut_data_1 );
assert_not( data_get_changed_any( peek__ut_data_1 ));
data_set_changed( var__ut_byte );
assert_not( data_get_changed_any( peek__ut_data_1 ));
data_set_changed( var__ut_float );
assert( data_get_changed_any( peek__ut_data_1 ));
do {
/* yield */
*co_p = &&L__3;
return CO_YIELD;
L__3:;
} while ( 0 );
data_clear_watch( peek__ut_data_1 );
assert_not( data_get_changed_any( peek__ut_data_1 ));
data_watch_array( peek__ut_data_1, _ut_data_array_watch );
data_set_changed( var__ut_float );
data_set_changed( var__ut_word );
data_set_changed( var__ut_array_0 );
assert_not( data_get_changed_any( peek__ut_data_1 ));
data_set_changed( var__ut_array_1 );
assert( data_get_changed( peek__ut_data_1, var__ut_array_1 ));
data_set_changed( var__ut_array_2 );
assert( data_get_changed( peek__ut_data_1, var__ut_array_2 ));
data_set_changed( var__ut_array_3 );
assert( data_get_changed( peek__ut_data_1, var__ut_array_3 ));
data_set_changed( var__ut_byte );
assert( data_get_changed( peek__ut_data_1, var__ut_byte ));
do {
/* yield */
*co_p = &&L__4;
return CO_YIELD;
L__4:;
} while ( 0 );
assert_u32_eq( var__ut_array, data_atovar( data_vartoa( var__ut_array_0 )));
assert_str_eq( "_ut_byte", data_vartoa( data_atovar( "_ut_byte" )));
i = 0x00ABCDEF;
data_set( var__ut_array_3, &i );
assert_str_eq( "0x00ABCDEF", data_get_string( __str, var__ut_array_3 ));
data_set_string( var__ut_float, "8080.02" );
assert_str_eq( "8080.02", data_get_string( __str, var__ut_float ));
assert_str_eq( "word", data_get_type( var__ut_word ));
/* end */
*co_p = &&L__END__ut_data_1;
L__END__ut_data_1:
return CO_END;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "htmlmacros.h"
#include "testhelp.h"
#define assert_str_eq(expected, actual) strcmp(expected, actual) == 0
int main() {
test_cond("element", assert_str_eq(
element("abc", ""),
"<abc></abc>"))
test_cond("element with content", assert_str_eq(
element("abc", "Hello World!"),
"<abc>Hello World!</abc>"))
test_cond("element with attribute", assert_str_eq(
element("abc", attr("key", "value") , ""),
"<abc key=\"value\"></abc>"))
test_cond("element with attribute and content", assert_str_eq(
element("abc", attr("key", "value"), "Hello World!"),
"<abc key=\"value\">Hello World!</abc>"))
test_cond("self-closing element", assert_str_eq(
sc_element("br", ""),
"<br/>"))
test_cond("self-closing element and attribute", assert_str_eq(
