static int
sync_kloop_eventfds(struct TestContext *ctx)
{
struct nmreq_opt_sync_kloop_eventfds *evopt = NULL;
struct nmreq_opt_sync_kloop_mode modeopt;
struct nmreq_option evsave;
int num_entries;
size_t opt_size;
int ret, i;
memset(&modeopt, 0, sizeof(modeopt));
modeopt.nro_opt.nro_reqtype = NETMAP_REQ_OPT_SYNC_KLOOP_MODE;
modeopt.mode = ctx->sync_kloop_mode;
push_option(&modeopt.nro_opt, ctx);
num_entries = num_registered_rings(ctx);
opt_size = sizeof(*evopt) + num_entries * sizeof(evopt->eventfds[0]);
evopt = calloc(1, opt_size);
evopt->nro_opt.nro_next = 0;
evopt->nro_opt.nro_reqtype = NETMAP_REQ_OPT_SYNC_KLOOP_EVENTFDS;
evopt->nro_opt.nro_status = 0;
evopt->nro_opt.nro_size = opt_size;
for (i = 0; i < num_entries; i++) {
int efd = eventfd(0, 0);
evopt->eventfds[i].ioeventfd = efd;
efd = eventfd(0, 0);
evopt->eventfds[i].irqfd = efd;
}
push_option(&evopt->nro_opt, ctx);
evsave = evopt->nro_opt;
ret = sync_kloop_start_stop(ctx);
if (ret != 0) {
free(evopt);
clear_options(ctx);
return ret;
}
#ifdef __linux__
evsave.nro_status = 0;
#else /* !__linux__ */
evsave.nro_status = EOPNOTSUPP;
#endif /* !__linux__ */
ret = checkoption(&evopt->nro_opt, &evsave);
free(evopt);
clear_options(ctx);
return ret;
}
TEARDOWN()
{
reset_cmds();
clear_options();
free(cfg.slow_fs_list);
cfg.slow_fs_list = NULL;
free(cfg.apropos_prg);
free(cfg.cd_path);
free(cfg.find_prg);
free(cfg.fuse_home);
free(cfg.time_format);
free(cfg.vi_command);
free(cfg.vi_x_command);
free(cfg.ruler_format);
free(cfg.status_line);
free(cfg.grep_prg);
free(cfg.locate_prg);
free(cfg.border_filler);
free(cfg.shell);
columns_free(lwin.columns);
lwin.columns = NULL;
free(lwin.view_columns);
lwin.view_columns = NULL;
columns_free(rwin.columns);
rwin.columns = NULL;
free(rwin.view_columns);
rwin.view_columns = NULL;
}
int main(int argc, char **argv) {
clear_options(argc, argv);
char *arg0 = strrchr(argv[0], '/');
if(arg0) arg0 += 1;
else arg0 = argv[0];
parse_arg0(argv[0]);
parse_options(argc, argv);
int sock = cli_options.sock;
if(!sock) sock = cli_options.arg0_sock;
if(!cli_options.sock && !cli_options.arg0_sock) {
fprintf(stderr, "Socket type is not specified\n");
print_usage(stderr, argv[0]);
exit(1);
}
int lib = cli_options.lib;
if(!lib) lib = cli_options.arg0_lib;
if(!lib) lib = cli_options.defaultlib;
if(!lib) {
fprintf(stderr, "Library used (libxs or libzmq) is not specified\n");
exit(0);
}
for(int i = 0; i < sizeof(table)/sizeof(table[0]); ++i) {
if(table[i].pattern[0] == lib && table[i].pattern[1] == sock) {
table[i].function();
exit(0);
}
}
fprintf(stderr, "Wrong combination of library and socket type\n");
exit(1);
}
static int
sync_kloop_eventfds_mismatch(struct TestContext *ctx)
{
struct nmreq_opt_csb opt;
int ret;
ret = push_csb_option(ctx, &opt);
if (ret != 0) {
return ret;
}
ret = port_register_hwall_rx(ctx);
if (ret != 0) {
return ret;
}
clear_options(ctx);
/* Deceive num_registered_rings() to trigger a failure of
* sync_kloop_eventfds(). The latter will think that all the
* rings were registered, and allocate the wrong number of
* eventfds. */
ctx->nr_flags &= ~NR_RX_RINGS_ONLY;
return (sync_kloop_eventfds(ctx) != 0) ? 0 : -1;
}
void
opt_handlers_teardown(void)
{
clear_options();
update_string(&cfg.slow_fs_list, NULL);
update_string(&cfg.apropos_prg, NULL);
update_string(&cfg.cd_path, NULL);
update_string(&cfg.find_prg, NULL);
update_string(&cfg.fuse_home, NULL);
update_string(&cfg.time_format, NULL);
update_string(&cfg.vi_command, NULL);
update_string(&cfg.vi_x_command, NULL);
update_string(&cfg.ruler_format, NULL);
update_string(&cfg.status_line, NULL);
update_string(&cfg.grep_prg, NULL);
update_string(&cfg.locate_prg, NULL);
update_string(&cfg.border_filler, NULL);
update_string(&cfg.shell, NULL);
update_string(&lwin.view_columns, NULL);
update_string(&lwin.view_columns_g, NULL);
update_string(&lwin.sort_groups, NULL);
update_string(&lwin.sort_groups_g, NULL);
update_string(&rwin.view_columns, NULL);
update_string(&rwin.view_columns_g, NULL);
update_string(&rwin.sort_groups, NULL);
update_string(&rwin.sort_groups_g, NULL);
}
static int
csb_enable(struct TestContext *ctx)
{
struct nmreq_option saveopt;
struct nmreq_opt_csb opt;
struct nmreq_header hdr;
int ret;
ret = push_csb_option(ctx, &opt);
if (ret != 0) {
return ret;
}
saveopt = opt.nro_opt;
saveopt.nro_status = 0;
nmreq_hdr_init(&hdr, ctx->ifname_ext);
hdr.nr_reqtype = NETMAP_REQ_CSB_ENABLE;
hdr.nr_options = (uintptr_t)ctx->nr_opt;
hdr.nr_body = (uintptr_t)NULL;
printf("Testing NETMAP_REQ_CSB_ENABLE on '%s'\n", ctx->ifname_ext);
ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
if (ret != 0) {
perror("ioctl(/dev/netmap, NIOCCTRL, CSB_ENABLE)");
return ret;
}
ret = checkoption(&opt.nro_opt, &saveopt);
clear_options(ctx);
return ret;
}
static int
infinite_options(struct TestContext *ctx)
{
struct nmreq_option opt;
printf("Testing infinite list of options on %s\n", ctx->ifname_ext);
opt.nro_reqtype = 1234;
push_option(&opt, ctx);
opt.nro_next = (uintptr_t)&opt;
if (port_register_hwall(ctx) >= 0)
return -1;
clear_options(ctx);
return (errno == EMSGSIZE ? 0 : -1);
}
static int
csb_mode(struct TestContext *ctx)
{
struct nmreq_opt_csb opt;
int ret;
ret = push_csb_option(ctx, &opt);
if (ret != 0) {
return ret;
}
ret = port_register_hwall(ctx);
clear_options(ctx);
return ret;
}
static int
csb_mode_invalid_memory(struct TestContext *ctx)
{
struct nmreq_opt_csb opt;
int ret;
memset(&opt, 0, sizeof(opt));
opt.nro_opt.nro_reqtype = NETMAP_REQ_OPT_CSB;
opt.csb_atok = (uintptr_t)0x10;
opt.csb_ktoa = (uintptr_t)0x800;
push_option(&opt.nro_opt, ctx);
ctx->nr_flags = NR_EXCLUSIVE;
ret = port_register_hwall(ctx);
clear_options(ctx);
return (ret < 0) ? 0 : -1;
}
static int
unsupported_option(struct TestContext *ctx)
{
struct nmreq_option opt, save;
printf("Testing unsupported option on %s\n", ctx->ifname_ext);
memset(&opt, 0, sizeof(opt));
opt.nro_reqtype = 1234;
push_option(&opt, ctx);
save = opt;
if (port_register_hwall(ctx) >= 0)
return -1;
clear_options(ctx);
save.nro_status = EOPNOTSUPP;
return checkoption(&opt, &save);
}
static int
sync_kloop_eventfds_all_tx(struct TestContext *ctx)
{
struct nmreq_opt_csb opt;
int ret;
ret = push_csb_option(ctx, &opt);
if (ret != 0) {
return ret;
}
ret = port_register_hwall_tx(ctx);
if (ret != 0) {
return ret;
}
clear_options(ctx);
return sync_kloop_eventfds(ctx);
}
static int
duplicate_extmem_options(struct TestContext *ctx)
{
struct nmreq_opt_extmem e1, save1, e2, save2;
struct nmreq_pools_info pools_info;
int ret;
printf("Testing duplicate extmem option on vale0:0\n");
pools_info_fill(&pools_info);
if ((ret = push_extmem_option(ctx, &pools_info, &e1)) < 0)
return ret;
if ((ret = push_extmem_option(ctx, &pools_info, &e2)) < 0) {
clear_options(ctx);
return ret;
}
save1 = e1;
save2 = e2;
strncpy(ctx->ifname_ext, "vale0:0", sizeof(ctx->ifname_ext));
ctx->nr_tx_slots = 16;
ctx->nr_rx_slots = 16;
ret = port_register_hwall(ctx);
if (ret >= 0) {
printf("duplicate option not detected\n");
return -1;
}
save2.nro_opt.nro_status = EINVAL;
if ((ret = pop_extmem_option(ctx, &save2)))
return ret;
save1.nro_opt.nro_status = EINVAL;
if ((ret = pop_extmem_option(ctx, &save1)))
return ret;
return 0;
}
static gint
gedit_app_command_line (GApplication *application,
GApplicationCommandLine *cl)
{
GeditAppPrivate *priv;
GVariantDict *options;
const gchar *encoding_charset;
const gchar **remaining_args;
priv = gedit_app_get_instance_private (GEDIT_APP (application));
options = g_application_command_line_get_options_dict (cl);
g_variant_dict_lookup (options, "new-window", "b", &priv->new_window);
g_variant_dict_lookup (options, "new-document", "b", &priv->new_document);
g_variant_dict_lookup (options, "geometry", "s", &priv->geometry);
if (g_variant_dict_contains (options, "wait"))
{
priv->command_line = cl;
}
if (g_variant_dict_lookup (options, "encoding", "&s", &encoding_charset))
{
priv->encoding = gtk_source_encoding_get_from_charset (encoding_charset);
if (priv->encoding == NULL)
{
g_application_command_line_printerr (cl,
_("%s: invalid encoding."),
encoding_charset);
}
}
/* Parse filenames */
if (g_variant_dict_lookup (options, G_OPTION_REMAINING, "^a&ay", &remaining_args))
{
gint i;
for (i = 0; remaining_args[i]; i++)
{
if (*remaining_args[i] == '+')
{
if (*(remaining_args[i] + 1) == '\0')
{
/* goto the last line of the document */
priv->line_position = G_MAXINT;
priv->column_position = 0;
}
else
{
get_line_column_position (remaining_args[i] + 1,
&priv->line_position,
&priv->column_position);
}
}
else if (*remaining_args[i] == '-' && *(remaining_args[i] + 1) == '\0')
{
priv->stdin_stream = g_application_command_line_get_stdin (cl);
}
else
{
GFile *file;
file = g_application_command_line_create_file_for_arg (cl, remaining_args[i]);
priv->file_list = g_slist_prepend (priv->file_list, file);
}
}
priv->file_list = g_slist_reverse (priv->file_list);
g_free (remaining_args);
}
g_application_activate (application);
clear_options (GEDIT_APP (application));
return 0;
}
static int
sync_kloop_conflict(struct TestContext *ctx)
{
struct nmreq_opt_csb opt;
pthread_t th1, th2;
void *thret1 = THRET_FAILURE, *thret2 = THRET_FAILURE;
struct timespec to;
sem_t sem;
int err = 0;
int ret;
ret = push_csb_option(ctx, &opt);
if (ret != 0) {
return ret;
}
ret = port_register_hwall(ctx);
if (ret != 0) {
return ret;
}
clear_options(ctx);
ret = sem_init(&sem, 0, 0);
if (ret != 0) {
printf("sem_init() failed: %s\n", strerror(ret));
return ret;
}
ctx->sem = &sem;
ret = pthread_create(&th1, NULL, sync_kloop_worker, ctx);
err |= ret;
if (ret != 0) {
printf("pthread_create(kloop1): %s\n", strerror(ret));
}
ret = pthread_create(&th2, NULL, sync_kloop_worker, ctx);
err |= ret;
if (ret != 0) {
printf("pthread_create(kloop2): %s\n", strerror(ret));
}
/* Wait for one of the two threads to fail to start the kloop, to
* avoid a race condition where th1 starts the loop and stops,
* and after that th2 starts the loop successfully. */
clock_gettime(CLOCK_REALTIME, &to);
to.tv_sec += 2;
ret = sem_timedwait(&sem, &to);
err |= ret;
if (ret != 0) {
printf("sem_timedwait() failed: %s\n", strerror(errno));
}
err |= sync_kloop_stop(ctx);
ret = pthread_join(th1, &thret1);
err |= ret;
if (ret != 0) {
printf("pthread_join(kloop1): %s\n", strerror(ret));
}
ret = pthread_join(th2, &thret2);
err |= ret;
if (ret != 0) {
printf("pthread_join(kloop2): %s %d\n", strerror(ret), ret);
}
sem_destroy(&sem);
ctx->sem = NULL;
if (err) {
return err;
}
/* Check that one of the two failed, while the other one succeeded. */
return ((thret1 == THRET_SUCCESS && thret2 == THRET_FAILURE) ||
(thret1 == THRET_FAILURE && thret2 == THRET_SUCCESS))
? 0
: -1;
}
SETUP()
{
static int option_changed;
optval_t def = { .str_val = "/tmp" };
cfg.slow_fs_list = strdup("");
init_builtin_functions();
stats.line = wcsdup(L"set ");
stats.index = wcslen(stats.line);
stats.curs_pos = 0;
stats.len = stats.index;
stats.cmd_pos = -1;
stats.complete_continue = 0;
stats.history_search = 0;
stats.line_buf = NULL;
stats.complete = &complete_cmd;
init_commands();
execute_cmd("command bar a");
execute_cmd("command baz b");
execute_cmd("command foo c");
init_options(&option_changed);
add_option("fusehome", "fh", OPT_STR, 0, NULL, fusehome_handler, def);
assert_int_equal(0, chdir("test-data/existing-files"));
}
TEARDOWN()
{
assert_int_equal(0, chdir("../.."));
free(cfg.slow_fs_list);
cfg.slow_fs_list = NULL;
free(stats.line);
reset_cmds();
clear_options();
function_reset_all();
}
static void
fusehome_handler(OPT_OP op, optval_t val)
{
}
TEST(leave_spaces_at_begin)
{
char *buf;
vle_compl_reset();
assert_int_equal(1, complete_cmd(" qui", NULL));
buf = vle_compl_next();
assert_string_equal("quit", buf);
free(buf);
buf = vle_compl_next();
assert_string_equal("quit", buf);
free(buf);
}
TEST(only_user)
{
char *buf;
vle_compl_reset();
assert_int_equal(8, complete_cmd("command ", NULL));
buf = vle_compl_next();
assert_string_equal("bar", buf);
free(buf);
vle_compl_reset();
assert_int_equal(9, complete_cmd(" command ", NULL));
buf = vle_compl_next();
assert_string_equal("bar", buf);
free(buf);
vle_compl_reset();
assert_int_equal(10, complete_cmd(" command ", NULL));
buf = vle_compl_next();
assert_string_equal("bar", buf);
free(buf);
}
TEST(test_set_completion)
{
vle_compl_reset();
assert_success(line_completion(&stats));
assert_wstring_equal(L"set all", stats.line);
}
TEST(no_sdquoted_completion_does_nothing)
{
free(stats.line);
stats.line = wcsdup(L"command '");
stats.len = wcslen(stats.line);
stats.index = stats.len;
vle_compl_reset();
assert_success(line_completion(&stats));
assert_wstring_equal(L"command '", stats.line);
}
static void
prepare_for_line_completion(const wchar_t str[])
{
free(stats.line);
stats.line = wcsdup(str);
stats.len = wcslen(stats.line);
stats.index = stats.len;
stats.complete_continue = 0;
vle_compl_reset();
}
TEARDOWN()
{
clear_options();
}
SETUP()
{
static int option_changed;
optval_t def = { .str_val = "/tmp" };
init_options(&option_changed, NULL);
def.str_val = "/tmp";
add_option("fusehome", "fh", "descr", OPT_STR, OPT_GLOBAL, 0, NULL,
&fusehome_handler, def);
def.int_val = 0;
add_option("number", "nu", "descr", OPT_BOOL, OPT_GLOBAL, 0, NULL,
&number_handler, def);
add_option("numberwidth", "nuw", "descr", OPT_INT, OPT_GLOBAL, 0, NULL,
&numberwidth_global, def);
add_option("numberwidth", "nuw", "descr", OPT_INT, OPT_LOCAL, 0, NULL,
&numberwidth_local, def);
fuse_home = NULL;
number_width_global = 0;
number_width_local = 0;
}
TEARDOWN()
{
clear_options();
}
static void
fusehome_handler(OPT_OP op, optval_t val)
{
fuse_home = val.str_val;
}
static void
number_handler(OPT_OP op, optval_t val)
{
number = val.bool_val;
}
static void
numberwidth_global(OPT_OP op, optval_t val)
{
number_width_global = val.int_val;
}
static void
numberwidth_local(OPT_OP op, optval_t val)
{
number_width_local = val.int_val;
}
TEST(set_global_option_without_prefix)
{
assert_success(let_variables("&fusehome = 'value'"));
assert_string_equal("value", fuse_home);
}
TEST(set_global_option_with_global_prefix)
{
assert_success(let_variables("&g:fusehome = 'value'"));
assert_string_equal("value", fuse_home);
}
TEST(set_global_option_with_local_prefix)
{
assert_failure(let_variables("&l:fusehome = 'value'"));
assert_string_equal(NULL, fuse_home);
}
TEST(set_global_and_local_option_without_prefix)
{
assert_success(let_variables("&numberwidth = 2"));
assert_int_equal(2, number_width_global);
assert_int_equal(2, number_width_local);
}
TEST(set_global_and_local_option_with_global_prefix)
{
assert_success(let_variables("&g:numberwidth = 2"));
assert_int_equal(2, number_width_global);
assert_int_equal(0, number_width_local);
}
TEST(set_global_and_local_option_with_local_prefix)
{
assert_success(let_variables("&l:numberwidth = 2"));
assert_int_equal(0, number_width_global);
assert_int_equal(2, number_width_local);
}
TEST(appending_works_for_strings)
{
assert_success(let_variables("&fusehome = 'value'"));
assert_string_equal("value", fuse_home);
assert_success(let_variables("&fusehome .= 'more'"));
assert_string_equal("valuemore", fuse_home);
}
TEST(incdec_does_not_work_for_strings)
{
assert_failure(let_variables("&fusehome += 3"));
assert_failure(let_variables("&fusehome -= 3"));
}
TEST(incdec_works_for_numbers)
{
assert_success(let_variables("&numberwidth += 2"));
assert_int_equal(2, number_width_local);
assert_success(let_variables("&numberwidth += 4"));
assert_int_equal(6, number_width_local);
assert_success(let_variables("&numberwidth -= 5"));
assert_int_equal(1, number_width_local);
}
TEST(appending_does_not_work_for_numbers)
{
assert_failure(let_variables("&numberwidth .= 2"));
}
TEST(appending_does_not_work_for_bools)
{
assert_failure(let_variables("&number .= 2"));
}
TEST(addition_does_not_work_for_bools)
{
assert_failure(let_variables("&number += 2"));
}
#if 0
/* For the future. */
TEST(set_of_a_boolean_option)
{
assert_failure(let_variables("&number = 'a'"));
assert_success(let_variables("&number = '1'"));
assert_true(number);
assert_success(let_variables("&number = '0'"));
assert_false(number);
}
