END_TEST
#define test_i(type, var, format) \
do { \
omlc_set_ ## type(to, var); \
fail_unless(omlc_get_ ## type(to) == var, \
"Error setting " #type ", expected %" format ", got %" format, \
var, omlc_get_ ## type(to)); \
from = to; \
fail_unless(omlc_get_ ## type(from) == var, \
"Error copying" #type ", expected %" format ", got %" format, \
var, omlc_get_ ## type(to)); \
} while(0)
START_TEST (test_intrinsic)
{
OmlValueU to, from;
int32_t i32 = -123234;
uint32_t u32 = 128937;
int64_t i64 = -123234892374;
uint64_t u64 = 128939087987;
double d = M_PI;
omlc_zero(to);
omlc_zero(from);
test_i(int32, i32, "i");
test_i(uint32, u32, "u");
test_i(int64, i64, PRId64);
test_i(uint64, u64, PRIu64);
test_i(double, d, "f");
test_i(bool, 0, "d");
test_i(bool, 1, "d");
}
/** Marshal meta-data for an OML measurement stream's sample
*
* An OML measurement stream is written as two bytes; the first one is the
* counter for the number of elements in the message, and therefore starts at
* 0, and the second one is the stream's index. This is followed by a
* marshalled int32 value containing the sequence number, and a double value
* containing the timestamp.
*
* A marshalling message should have been prepared in the MBuffer first with
* marshal_init(). Actual data can then be marshalled into the message with
* marshal_values().
*
*
* \param mbuf MBuffer to write marshalled data to
* \param stream Measurement Stream's index
* \param seqno message sequence number
* \param now message time
* \return 1 if successful, -1 otherwise
* \see marshal_init, marshal_values, marshal_finalize
*/
int
marshal_measurements(MBuffer* mbuf, int stream, int seqno, double now)
{
OmlValueU v;
uint8_t s[2] = { 0, (uint8_t)stream };
/* Write num-meas (0, for now), and the stream index */
int result = mbuf_write (mbuf, s, LENGTH (s));
omlc_zero(v);
if (result == -1) {
logerror("Unable to marshal table number and measurement count (mbuf_write())\n");
mbuf_reset_write (mbuf);
return -1;
}
logdebug("Marshalling sample %d for stream %d\n", seqno, stream);
omlc_set_int32(v, seqno);
marshal_value(mbuf, OML_INT32_VALUE, &v);
omlc_set_double(v, now);
marshal_value(mbuf, OML_DOUBLE_VALUE, &v);
return 1;
}
END_TEST
START_TEST (test_blob)
{
char *str = "this is a string subtly disguised as a blob";
OmlValue v, v2;
OmlValueU vu;
size_t len = strlen(str);
void *test = (void*)str;
size_t bcount;
size_t alloc_diff;
oml_value_init(&v);
oml_value_init(&v2);
omlc_zero(vu);
/* Prepare the OmlValueU to be duplicated in the OmlValue */
omlc_set_blob(vu, test, len);
bcount = xmembytes();
oml_value_set(&v, &vu, OML_BLOB_VALUE);
alloc_diff = xmembytes() - bcount - sizeof(size_t);
bcount = xmembytes();
fail_if(alloc_diff < len,
"OmlValue blob allocated memory not big enough (%d instead of at least %d)",
alloc_diff, len);
oml_value_duplicate(&v2, &v);
fail_if(omlc_get_blob_ptr(*oml_value_get_value(&v2)) == omlc_get_blob_ptr(*oml_value_get_value(&v)),
"Copied OmlValue blob pointer not allocated properly");
fail_if(strncmp(omlc_get_blob_ptr(*oml_value_get_value(&v2)), omlc_get_blob_ptr(*oml_value_get_value(&v)), len),
"Copied OmlValue blob mismatch");
fail_unless(omlc_get_blob_length(*oml_value_get_value(&v2)) == omlc_get_blob_length(*oml_value_get_value(&v)),
"Copied OmlValue blob length not set properly (%d instead of %d)",
omlc_get_blob_length(*oml_value_get_value(&v2)), omlc_get_blob_length(*oml_value_get_value(&v2)));
alloc_diff = xmembytes() - bcount - sizeof(size_t); /* oml_malloc() always allocates at least sizeof(size_t) more for bookkeeping */
bcount = xmembytes();
fail_if(alloc_diff < len,
"Copied OmlValue blob allocated memory not big enough (%d instead of at least %d)",
alloc_diff, len);
fail_unless(omlc_get_blob_size(*oml_value_get_value(&v2)) == oml_malloc_usable_size(omlc_get_blob_ptr(*oml_value_get_value(&v2))),
"Copied OmlValue blob allocated size not set properly (%d instead of %d)",
omlc_get_blob_size(*oml_value_get_value(&v2)), oml_malloc_usable_size(omlc_get_blob_ptr(*oml_value_get_value(&v2))));
oml_value_set_type(&v, OML_UINT64_VALUE);
fail_unless(xmembytes() < bcount,
"OmlValue blob was not freed after oml_value_set_type() (%d allocated, which is not less than %d)",
xmembytes(), bcount);
bcount = xmembytes();
oml_value_reset(&v2);
fail_unless(xmembytes() < bcount,
"OmlValue blob was not freed after oml_value_reset() (%d allocated, which is not less than %d)",
xmembytes(), bcount);
bcount = xmembytes();
oml_value_reset(&v);
omlc_reset_blob(vu);
}
END_TEST
START_TEST (test_string)
{
char *test = "test";
OmlValue v, v2;
OmlValueU vu;
size_t bcount = xmembytes();
size_t alloc_diff;
oml_value_init(&v);
oml_value_init(&v2);
omlc_zero(vu);
/* Prepare the OmlValueU to be duplicated in the OmlValue */
omlc_set_const_string(vu, test);
oml_value_set(&v, &vu, OML_STRING_VALUE);
alloc_diff = xmembytes() - bcount - sizeof(size_t);
bcount = xmembytes();
fail_if(alloc_diff < strlen(test) + 1,
"OmlValue string allocated memory not big enough (%d instead of at least %d)",
alloc_diff, strlen(test) + 1);
oml_value_duplicate(&v2, &v);
fail_if(omlc_get_string_ptr(*oml_value_get_value(&v2)) == omlc_get_string_ptr(*oml_value_get_value(&v)),
"Copied OmlValue string pointer not allocated properly");
fail_if(strcmp(omlc_get_string_ptr(*oml_value_get_value(&v2)), omlc_get_string_ptr(*oml_value_get_value(&v))),
"Copied OmlValue string mismatch ('%s' instead of '%s')",
omlc_get_string_ptr(*oml_value_get_value(&v2)), omlc_get_string_ptr(*oml_value_get_value(&v)));
fail_unless(omlc_get_string_length(*oml_value_get_value(&v2)) == strlen(omlc_get_string_ptr(*oml_value_get_value(&v2))),
"Copied OmlValue string length not set properly (%d instead of %d)",
omlc_get_string_length(*oml_value_get_value(&v2)), strlen(omlc_get_string_ptr(*oml_value_get_value(&v2))) + 1);
alloc_diff = xmembytes() - bcount - sizeof(size_t); /* oml_malloc() always allocates at least sizeof(size_t) more for bookkeeping */
bcount = xmembytes();
fail_if(alloc_diff < strlen(omlc_get_string_ptr(*oml_value_get_value(&v))) + 1,
"Copied OmlValue string allocated memory not big enough (%d instead of at least %d)",
alloc_diff, strlen(omlc_get_string_ptr(*oml_value_get_value(&v))) + 1);
fail_unless(omlc_get_string_size(*oml_value_get_value(&v2)) == oml_malloc_usable_size(omlc_get_string_ptr(*oml_value_get_value(&v2))),
"Copied OmlValue string allocated size not set properly (%d instead of %d)",
omlc_get_string_size(*oml_value_get_value(&v2)), oml_malloc_usable_size(omlc_get_string_ptr(*oml_value_get_value(&v2))));
fail_unless(omlc_get_string_is_const(*oml_value_get_value(&v2)) == 0,
"Copied OmlValue string should not be constant");
oml_value_set_type(&v, OML_UINT64_VALUE);
fail_unless(xmembytes() < bcount,
"OmlValue string was not freed after oml_value_set_type() (%d allocated, which is not less than %d)",
xmembytes(), bcount);
bcount = xmembytes();
oml_value_reset(&v2);
fail_unless(xmembytes() < bcount,
"OmlValue string was not freed after oml_value_reset() (%d allocated, which is not less than %d)",
xmembytes(), bcount);
bcount = xmembytes();
oml_value_reset(&v);
omlc_reset_string(vu);
}
int
main(int argc, const char *argv[])
{
int c, i, ret;
/* Reconstruct command line */
size_t cmdline_len = 0;
for(i = 0; i < argc; i++) {
cmdline_len += strlen(argv[i]) + 1;
}
char *cmdline = oml_malloc(cmdline_len);
cmdline[0] = '\0';
for(i = 0; i < argc; i++) {
strncat(cmdline, argv[i], cmdline_len);
cmdline_len -= strlen(argv[i]);
strncat(cmdline, " ", cmdline_len);
cmdline_len--;
}
/* Initialize OML */
if((ret = omlc_init("generator", &argc, argv, NULL)) < 0) {
logerror("Could not initialise OML\n");
return -1;
}
/* Parse command line arguments */
poptContext optCon = poptGetContext(NULL, argc, argv, options, 0); /* options is defined in generator_popt.h */
while ((c = poptGetNextOpt(optCon)) > 0) {}
/* Initialise measurement points and start OML */
oml_register_mps(); /* Defined in generator_oml.h */
if(omlc_start()) {
logerror("Could not start OML\n");
return -1;
}
/* Inject some metadata about this application */
OmlValueU v;
omlc_zero(v);
omlc_set_string(v, PACKAGE_NAME);
omlc_inject_metadata(NULL, "appname", &v, OML_STRING_VALUE, NULL);
omlc_set_string(v, PACKAGE_VERSION);
omlc_inject_metadata(NULL, "version", &v, OML_STRING_VALUE, NULL);
omlc_set_string(v, cmdline);
omlc_inject_metadata(NULL, "cmdline", &v, OML_STRING_VALUE, NULL);
omlc_reset_string(v);
oml_free(cmdline);
/* Inject measurements */
run(g_opts, g_oml_mps_generator); /* Do some work and injections, see above */
omlc_close();
return 0;
}
END_TEST
START_TEST (test_blobU)
{
OmlValueU v, v2;
char *str = "this is a string subtly disguised as a blob";
char *str2 = "this is another string in blob's clothing, except longer";
void *test = (void*) str;
void *test2 = (void*) str2;
size_t len = strlen(str);
size_t len2 = strlen(str2);
size_t bcount = xmembytes(), alloc_diff, size;
omlc_zero(v);
omlc_zero(v2);
/* Set blob (copy) */
omlc_set_blob(v, test, len);
fail_if(omlc_get_blob_ptr(v) == test,
"Test blob pointer not allocated properly");
fail_if(strncmp(test, omlc_get_blob_ptr(v), len),
"Test blob mismatch");
fail_unless(omlc_get_blob_length(v) == len,
"Test blob length not set properly (%d instead of %d)",
omlc_get_blob_length(v), len);
alloc_diff = xmembytes() - bcount - sizeof(size_t);
bcount = xmembytes();
fail_if(alloc_diff < len,
"Test blob allocated memory not big enough (%d instead of at least %d)",
alloc_diff, len);
fail_unless(omlc_get_blob_size(v) == oml_malloc_usable_size(omlc_get_string_ptr(v)),
"Test blob allocated size not set properly (%d instead of %d)",
omlc_get_blob_size(v), oml_malloc_usable_size(omlc_get_string_ptr(v)));
/* Duplicate blob*/
omlc_copy_blob(v2, v);
fail_if(omlc_get_blob_ptr(v2) == omlc_get_blob_ptr(v),
"Copied blob not allocated properly");
fail_if(strncmp(omlc_get_blob_ptr(v2), omlc_get_blob_ptr(v), len),
"Copied allocated blob mismatch");
fail_unless(omlc_get_blob_length(v2) == omlc_get_blob_length(v),
"Copied allocated blob length not set properly (%d instead of %d)",
omlc_get_blob_length(v2), omlc_get_blob_length(v));
alloc_diff = xmembytes() - bcount - sizeof(size_t);
bcount = xmembytes();
fail_if(alloc_diff < len,
"Copied allocated blob allocated memory not big enough (%d instead of at least %d)",
alloc_diff, len);
fail_unless(omlc_get_blob_size(v) == oml_malloc_usable_size(omlc_get_blob_ptr(v2)),
"Copied allocated blob allocated size not set properly (%d instead of %d)",
omlc_get_blob_size(v2), oml_malloc_usable_size(omlc_get_blob_ptr(v2)));
/* Overwrite blob */
omlc_set_blob(v, test2, len2);
/* We know omlc_set_blob() already sets properly, we just want to check it does cleanup previously allocated memory */
fail_if(xmembytes() > bcount + omlc_get_blob_size(v),
"Overwritten blob did not deallocate memory properly (%d used but expected %d)",
xmembytes(), bcount + omlc_get_blob_size(v));
/* Reset blob and clear allocated pointer */
omlc_reset_blob(v);
size = omlc_get_blob_size(v);
omlc_reset_blob(v);
fail_unless(omlc_get_blob_ptr(v) == NULL,
"Reset allocated blob pointer not cleared properly");
fail_unless(omlc_get_blob_length(v) == 0,
"Reset allocated blob length not cleared properly");
alloc_diff = bcount - xmembytes() + sizeof(size_t);
bcount = xmembytes();
fail_if(alloc_diff <= size,
"Reset allocated blob didn't free the memory as expected (%d freed instead at least %d)",
alloc_diff, size);
fail_unless(omlc_get_blob_size(v) == 0,
"Reset allocated blob allocated size not cleared properly");
omlc_reset_blob(v2);
}
