/* Run multiple compression tests on data stored in a file */
int test_compress_file(char *file_name)
{
int ret = IGZIP_COMP_OK;
uint32_t in_size;
uint8_t *in_buf = NULL;
FILE *in_file = NULL;
in_file = fopen(file_name, "rb");
if (!in_file)
return FILE_READ_FAILED;
in_size = get_filesize(in_file);
if (in_size != 0) {
in_buf = malloc(in_size);
if (in_buf == NULL)
return MALLOC_FAILED;
fread(in_buf, 1, in_size, in_file);
}
ret |= test_compress_stateless(in_buf, in_size);
ret |= test_compress(in_buf, in_size, NO_FLUSH);
ret |= test_compress(in_buf, in_size, SYNC_FLUSH);
ret |= test_flush(in_buf, in_size);
if (ret)
printf("Failed on file %s\n", file_name);
if (in_buf != NULL)
free(in_buf);
return ret;
}
int
main (int argc, char ** args)
{
int args_offset;
if (log4c_init()) {
g_printerr("Failed to init log4c\r\n");
abort();
}
args_offset = 1;
args_offset += init_static_vars(argc-args_offset,args+args_offset);
if (test_add_service(argc-args_offset,args+args_offset, FALSE)) {
NOTICE("%s : ok", "test_add_service(rollback)");
} else {
NOTICE("%s : KO", "test_add_service(rollback)");
}
if (test_add_service(argc-args_offset,args+args_offset, TRUE)) {
NOTICE("%s : ok", "test_add_service(commit)");
} else {
NOTICE("%s : KO", "test_add_service(commit)");
}
if (test_flush()) {
NOTICE("%s : ok", "test_flush()");
} else {
NOTICE("%s : KO", "test_flush()");
}
return 0;
}
int
main(int argc, char **argv)
{
DDMDataModel *model;
DDMDataResource *result;
DDMDataResource *user1;
DDMDataResource *user2;
DDMDataResource *buddy1;
DDMDataResource *user;
DDMDataValue value;
gboolean was_changed = FALSE;
model = test_init(TRUE);
result = test_query_resource("online-desktop:/o/pidgin-buddy/AIM.JohnDoe1", "fixedUser name");
buddy1 = ddm_data_model_lookup_resource(model, "online-desktop:/o/pidgin-buddy/AIM.JohnDoe1");
g_assert(buddy1 != NULL);
user1 = ddm_data_model_lookup_resource(model, "http://mugshot.org/o/user/USER1");
g_assert(user1 != NULL);
user = NULL;
ddm_data_resource_get(buddy1,
"fixedUser", DDM_DATA_RESOURCE, &user,
NULL);
g_assert(user == user1);
ddm_data_resource_connect(buddy1, NULL, on_buddy1_changed, &was_changed);
/* This change will trigger the immediate change to user1, but it should also
* cause a fetch from upstream of the name property of user2, since our stored
* fetch for buddy1 is 'user name' and we haven't yet fetched name for user2
*/
user2 = ddm_data_model_ensure_resource(model, "http://mugshot.org/o/user/USER2", NULL);
value.type = DDM_DATA_RESOURCE;
value.u.resource = user2;
ddm_data_resource_update_property(buddy1,
ddm_qname_get("online-desktop://p/o/buddy", "fixedUser"),
DDM_DATA_UPDATE_REPLACE, DDM_DATA_CARDINALITY_01,
FALSE, NULL,
&value);
test_flush();
g_assert(was_changed);
return 0;
}
int main(
int argc,
char *argv[])
{
Byte *compr, *uncompr;
uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
uLong uncomprLen = comprLen;
static const char* myVersion = ZLIB_VERSION;
if (zlibVersion()[0] != myVersion[0]) {
fprintf(stderr, "incompatible zlib version\n");
exit(1);
} else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
fprintf(stderr, "warning: different zlib version\n");
}
printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n",
ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags());
compr = (Byte*)calloc((uInt)comprLen, 1);
uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
/* compr and uncompr are cleared to avoid reading uninitialized
* data and to ensure that uncompr compresses well.
*/
if (compr == Z_NULL || uncompr == Z_NULL) {
printf("out of memory\n");
exit(1);
}
test_compress(compr, comprLen, uncompr, uncomprLen);
test_gzio((argc > 1 ? argv[1] : TESTFILE),
uncompr, uncomprLen);
test_deflate(compr, comprLen);
test_inflate(compr, comprLen, uncompr, uncomprLen);
test_large_deflate(compr, comprLen, uncompr, uncomprLen);
test_large_inflate(compr, comprLen, uncompr, uncomprLen);
test_flush(compr, &comprLen);
test_sync(compr, comprLen, uncompr, uncomprLen);
comprLen = uncomprLen;
test_dict_deflate(compr, comprLen);
test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
free(compr);
free(uncompr);
return 0;
}
static void test_abort(io_channel channel, unsigned long block)
{
struct test_private_data *data;
FILE *f;
data = (struct test_private_data *) channel->private_data;
f = data->outfile;
test_flush(channel);
fprintf(f, "Aborting due to I/O to block %lu\n", block);
fflush(f);
abort();
}
int init_module(void)
{
START_TESTS("IPv4 Pool DB");
/*
* TODO (test) This is missing a multiple-tables test.
* (it always does mark = 1.)
*/
INIT_CALL_END(init(), test_foreach_sample(), destroy(), "Sample for");
INIT_CALL_END(init(), test_add(), destroy(), "Add");
INIT_CALL_END(init(), test_rm(), destroy(), "Rm");
INIT_CALL_END(init(), test_flush(), destroy(), "Flush");
END_TESTS;
}
int main(int argc, char **argv) {
grpc_closure destroyed;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_test_init(argc, argv);
grpc_init();
grpc_pollset_init(&g_pollset);
test_ref_unref();
test_add_closure();
test_flush();
grpc_closure_init(&destroyed, destroy_pollset, &g_pollset);
grpc_pollset_shutdown(&exec_ctx, &g_pollset, &destroyed);
grpc_exec_ctx_finish(&exec_ctx);
grpc_shutdown();
return 0;
}
static void produce_many (char **topics, int topic_cnt, uint64_t testid) {
rd_kafka_t *rk;
test_timing_t t_rkt_create;
int i;
rd_kafka_topic_t **rkts;
TEST_SAY(_C_MAG "%s\n" _C_CLR, __FUNCTION__);
rk = test_create_producer();
TEST_SAY("Creating %d topic objects\n", topic_cnt);
rkts = malloc(sizeof(*rkts) * topic_cnt);
TIMING_START(&t_rkt_create, "Topic object create");
for (i = 0 ; i < topic_cnt ; i++) {
rkts[i] = test_create_topic_object(rk, topics[i], NULL);
}
TIMING_STOP(&t_rkt_create);
TEST_SAY("Producing %d messages to each %d topics\n",
msgs_per_topic, topic_cnt);
/* Produce messages to each topic (so they are created) */
for (i = 0 ; i < topic_cnt ; i++) {
test_produce_msgs(rk, rkts[i], testid, 0,
i * msgs_per_topic, msgs_per_topic,
NULL, 100);
}
TEST_SAY("Destroying %d topic objects\n", topic_cnt);
for (i = 0 ; i < topic_cnt ; i++) {
rd_kafka_topic_destroy(rkts[i]);
}
free(rkts);
test_flush(rk, 30000);
rd_kafka_destroy(rk);
}
/**
* @brief Interceptors must not be copied automatically by conf_dup()
* unless the interceptors have added on_conf_dup().
* This behaviour makes sure an interceptor's instance
* is not duplicated without the interceptor's knowledge or
* assistance.
*/
static void do_test_conf_copy (const char *topic) {
rd_kafka_conf_t *conf, *conf2;
int i;
rd_kafka_t *rk;
TEST_SAY(_C_MAG "[ %s ]\n" _C_CLR, __FUNCTION__);
memset(&msgs[0], 0, sizeof(msgs));
test_conf_init(&conf, NULL, 0);
rd_kafka_conf_interceptor_add_on_new(conf, "on_new_conf_copy",
on_new_producer, NULL);
/* Now copy the configuration to verify that interceptors are
* NOT copied. */
conf2 = conf;
conf = rd_kafka_conf_dup(conf2);
rd_kafka_conf_destroy(conf2);
/* Create producer */
rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
for (i = 0 ; i < msgcnt-1 ; i++)
do_test_produce(rk, topic, RD_KAFKA_PARTITION_UA, i, 0, 0);
/* Wait for messages to be delivered */
test_flush(rk, -1);
/* Verify acks */
for (i = 0 ; i < msgcnt ; i++) {
struct msg_state *msg = &msgs[i];
msg_verify_ic_cnt(msg, "on_ack", msg->bits[_ON_ACK], 0);
}
rd_kafka_destroy(rk);
}
static void do_test_producer (const char *topic) {
rd_kafka_conf_t *conf;
int i;
rd_kafka_t *rk;
TEST_SAY(_C_MAG "[ %s ]\n" _C_CLR, __FUNCTION__);
test_conf_init(&conf, NULL, 0);
rd_kafka_conf_interceptor_add_on_new(conf, "on_new_prodcer",
on_new_producer, NULL);
/* Create producer */
rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
for (i = 0 ; i < msgcnt-1 ; i++)
do_test_produce(rk, topic, RD_KAFKA_PARTITION_UA, i, 0,
producer_ic_cnt);
/* Wait for messages to be delivered */
test_flush(rk, -1);
/* Now send a message that will fail in produce()
* due to bad partition */
do_test_produce(rk, topic, 1234, i, 1, producer_ic_cnt);
/* Verify acks */
for (i = 0 ; i < msgcnt ; i++) {
struct msg_state *msg = &msgs[i];
msg_verify_ic_cnt(msg, "on_ack", msg->bits[_ON_ACK],
producer_ic_cnt);
}
rd_kafka_destroy(rk);
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: This function coordinates the test of flush/refresh
* functionality verification. It accepts either one, two or
* no command line parameters. The main test routine runs
* with no command line parameters specified, while verification
* routines run with one or two command line parameters.
*
* Note: This program should not be run manually, as the
* test is controlled by the testflushrefresh.sh script. Running
* the flushrefresh program manually will result in failure, as
* it will time out waiting for a signal from the test script
* which will never come.
*
* Return: 0 on Success, 1 on Failure
*
* Programmer: Mike McGreevy
* July 1, 2010
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int main(int argc, const char *argv[])
{
/* Variables */
const char *envval = NULL;
/* Initialize library */
if(H5open() < 0)
TEST_ERROR;
/* Parse command line options */
if (argc == 1) {
/* No arguments supplied. Run main test routines if
* using sec2 or stdio driver, otherwise don't run
* anything. */
/* Determine driver being used */
envval = HDgetenv("HDF5_DRIVER");
if(envval == NULL)
envval = "";
if (!HDstrcmp(envval, "sec2") || !HDstrcmp(envval, "stdio") || !HDstrcmp(envval, "")) {
if (test_flush() != SUCCEED) TEST_ERROR;
if (test_refresh() != SUCCEED) TEST_ERROR;
} /* end if */
else {
HDfprintf(stdout, "Skipping all flush/refresh tests (only run with sec2 or stdio file drivers).\n");
/* Test script is expecting some signals, so send them out to end it. */
if (end_verification() < 0) TEST_ERROR;
if (end_verification() < 0) TEST_ERROR;
} /* end else */
} else if (argc == 3) {
/* Two arguments supplied. Pass them to flush verification routine. */
if (flush_verification(argv[1], argv[2]) != 0) PROCESS_ERROR;
} else if (argc == 2) {
/* One argument supplied. Pass it to refresh verification routine. */
if (refresh_verification(argv[1]) != 0) PROCESS_ERROR;
} else {
/* Illegal number of arguments supplied. Error. */
HDfprintf(stderr, "Error. %d is an Invalid number of arguments to main().\n", argc);
PROCESS_ERROR
} /* end if */
return SUCCEED;
error:
/* Return */
return FAIL;
} /* main */
int main_0088_produce_metadata_timeout (int argc, char **argv) {
int64_t testid;
rd_kafka_t *rk;
rd_kafka_topic_t *rkt;
const char *topic = test_mk_topic_name("0088_produce_metadata_timeout",
1);
int msgcnt = 0;
rd_kafka_conf_t *conf;
testid = test_id_generate();
/* Create topic with single partition, for simplicity. */
test_create_topic(topic, 1, 1);
test_conf_init(&conf, NULL, 15*60*2); // msgcnt * 2);
rd_kafka_conf_set_dr_msg_cb(conf, dr_msg_cb);
test_conf_set(conf, "metadata.max.age.ms", "10000");
test_conf_set(conf, "topic.metadata.refresh.interval.ms", "-1");
test_conf_set(conf, "linger.ms", "5000");
test_conf_set(conf, "batch.num.messages", "5");
test_socket_enable(conf);
test_curr->connect_cb = connect_cb;
test_curr->is_fatal_cb = is_fatal_cb;
rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
rkt = rd_kafka_topic_new(rk, topic, NULL);
/* Produce first set of messages and wait for delivery */
test_produce_msgs_nowait(rk, rkt, testid, RD_KAFKA_PARTITION_UA,
msgcnt, 20, NULL, 0, &msgcnt);
while (msg_dr_cnt < 5)
rd_kafka_poll(rk, 1000);
TEST_SAY(_C_YEL "Disconnecting sockets and "
"refusing future connections\n");
rd_atomic32_set(&refuse_connect, 1);
test_socket_close_all(test_curr, 1/*reinit*/);
/* Wait for metadata timeout */
TEST_SAY("Waiting for metadata timeout\n");
rd_sleep(10+5);
/* These messages will be put on the UA queue */
test_produce_msgs_nowait(rk, rkt, testid, RD_KAFKA_PARTITION_UA,
msgcnt, 20, NULL, 0, &msgcnt);
/* Restore the connection(s) when metadata has timed out. */
TEST_SAY(_C_YEL "Allowing connections\n");
rd_atomic32_set(&refuse_connect, 0);
rd_sleep(3);
test_produce_msgs_nowait(rk, rkt, testid, RD_KAFKA_PARTITION_UA,
msgcnt, 20, NULL, 0, &msgcnt);
test_flush(rk, 2*5*1000); /* linger.ms * 2 */
TEST_ASSERT(msg_dr_cnt == msgcnt,
"expected %d, got %d", msgcnt, msg_dr_cnt);
TEST_ASSERT(msg_dr_fail_cnt == 0,
"expected %d dr failures, got %d", 0, msg_dr_fail_cnt);
rd_kafka_topic_destroy(rkt);
rd_kafka_destroy(rk);
return 0;
}
int main(int argc, char *argv[])
{
int err, c, status;
pid_t pid;
unsigned char flags[LastOpt];
struct mntent ent;
char *dev, *mntpnt, *opts, *cwd;
DIR *cur;
if (argc < 3) {
errno = EINVAL;
AuFin(NULL);
}
memset(flags, 0, sizeof(flags));
flags[Update] = 1;
opts = NULL;
/* mount(8) always passes the arguments in this order */
dev = argv[1];
mntpnt = argv[2];
while ((c = getopt(argc - 2, argv + 2, "nvo:")) != -1) {
switch (c) {
case 'n':
flags[Update] = 0;
break;
case 'v':
flags[Verbose] = 1;
break;
case 'o':
opts = optarg;
break;
case '?':
case ':':
errno = EINVAL;
AuFin("internal error");
}
}
cur = opendir(".");
if (!cur)
AuFin(".");
err = chdir(mntpnt);
if (err)
AuFin(mntpnt);
cwd = getcwd(NULL, 0); /* glibc */
if (!cwd)
AuFin("getcwd");
err = fchdir(dirfd(cur));
if (err)
AuFin("fchdir");
closedir(cur); /* ignore */
if (opts)
test_opts(opts, flags);
if (!flags[Bind] && flags[Update]) {
err = access(MTab, R_OK | W_OK);
if (err)
AuFin(MTab);
}
if (flags[Remount]) {
errno = EINVAL;
if (flags[Bind])
AuFin("both of remount and bind are specified");
flags[AuFlush] = test_flush(opts);
if (flags[AuFlush]) {
err = au_plink(cwd, AuPlink_FLUSH, 1, 1);
if (err)
AuFin(NULL);
}
}
pid = fork();
if (!pid) {
/* actual mount operation */
do_mount(dev, mntpnt, argc, argv, flags);
return 0;
} else if (pid < 0)
AuFin("fork");
err = waitpid(pid, &status, 0);
if (err < 0)
AuFin("child process");
err = !WIFEXITED(status);
if (!err)
err = WEXITSTATUS(status);
if (!err && !flags[Bind]) {
if (flags[Update])
err = au_update_mtab(cwd, flags[Remount],
flags[Verbose]);
else if (flags[Verbose]) {
/* withoug blocking plink */
err = au_proc_getmntent(cwd, &ent);
if (!err)
au_print_ent(&ent);
else
AuFin("internal error");
}
}
return err;
}
