void
mcview_done (mcview_t * view)
{
/* Save current file position */
if (mcview_remember_file_position && view->filename_vpath != NULL)
{
save_file_position (view->filename_vpath, -1, 0,
view->hex_mode ? view->hex_cursor : view->dpy_start,
view->saved_bookmarks);
view->saved_bookmarks = NULL;
}
/* Write back the global viewer mode */
mcview_default_hex_mode = view->hex_mode;
mcview_default_nroff_flag = view->text_nroff_mode;
mcview_default_magic_flag = view->magic_mode;
mcview_global_wrap_mode = view->text_wrap_mode;
/* Free memory used by the viewer */
/* view->widget needs no destructor */
vfs_path_free (view->filename_vpath);
view->filename_vpath = NULL;
vfs_path_free (view->workdir_vpath);
view->workdir_vpath = NULL;
MC_PTR_FREE (view->command);
mcview_close_datasource (view);
/* the growing buffer is freed with the datasource */
coord_cache_free (view->coord_cache), view->coord_cache = NULL;
if (view->converter == INVALID_CONV)
view->converter = str_cnv_from_term;
if (view->converter != str_cnv_from_term)
{
str_close_conv (view->converter);
view->converter = str_cnv_from_term;
}
mc_search_free (view->search);
view->search = NULL;
g_free (view->last_search_string);
view->last_search_string = NULL;
mcview_nroff_seq_free (&view->search_nroff_seq);
mcview_hexedit_free_change_list (view);
if (mc_global.mc_run_mode == MC_RUN_VIEWER && view->dir != NULL)
{
/* mcviewer is the owner of file list */
dir_list_clean (view->dir);
g_free (view->dir->list);
g_free (view->dir_idx);
g_free (view->dir);
}
view->dir = NULL;
}
/* *INDENT-OFF* */
END_PARAMETRIZED_TEST
/* *INDENT-ON* */
/* --------------------------------------------------------------------------------------------- */
/* @Test(dataSource = "test_vfs_path_relative_ds") */
/* *INDENT-OFF* */
START_PARAMETRIZED_TEST (test_vfs_path_relative_clone, test_vfs_path_relative_ds)
/* *INDENT-ON* */
{
/* given */
vfs_path_t *vpath, *cloned_vpath;
vpath = vfs_path_from_str_flags (data->input_path, VPF_NO_CANON);
/* when */
cloned_vpath = vfs_path_clone (vpath);
/* then */
mctest_assert_int_eq (cloned_vpath->relative, TRUE);
mctest_assert_str_eq (vfs_path_get_last_path_str (cloned_vpath),
data->expected_last_path_in_element);
mctest_assert_str_eq (vfs_path_as_str (cloned_vpath), data->expected_path);
vfs_path_free (vpath);
vfs_path_free (cloned_vpath);
}
void
edit_symlink_cmd (void)
{
if (S_ISLNK (selection (current_panel)->st.st_mode))
{
char buffer[MC_MAXPATHLEN];
char *p = NULL;
int i;
char *q;
vfs_path_t *p_vpath;
p = selection (current_panel)->fname;
p_vpath = vfs_path_from_str (p);
q = g_strdup_printf (_("Symlink '%s\' points to:"), str_trunc (p, 32));
i = readlink (p, buffer, MC_MAXPATHLEN - 1);
if (i > 0)
{
char *dest;
buffer[i] = 0;
dest =
input_expand_dialog (_("Edit symlink"), q, MC_HISTORY_FM_EDIT_LINK, buffer,
INPUT_COMPLETE_FILENAMES);
if (dest)
{
if (*dest && strcmp (buffer, dest))
{
save_cwds_stat ();
if (mc_unlink (p_vpath) == -1)
{
message (D_ERROR, MSG_ERROR, _("edit symlink, unable to remove %s: %s"),
p, unix_error_string (errno));
}
else
{
vfs_path_t *dest_vpath;
dest_vpath = vfs_path_from_str_flags (dest, VPF_NO_CANON);
if (mc_symlink (dest_vpath, p_vpath) == -1)
message (D_ERROR, MSG_ERROR, _("edit symlink: %s"),
unix_error_string (errno));
vfs_path_free (dest_vpath);
}
update_panels (UP_OPTIMIZE, UP_KEEPSEL);
repaint_screen ();
}
g_free (dest);
}
}
g_free (q);
vfs_path_free (p_vpath);
}
else
{
message (D_ERROR, MSG_ERROR, _("'%s' is not a symbolic link"),
selection (current_panel)->fname);
}
}
/**
* Run viewer (internal or external) on the currently selected file.
* If normal is TRUE, force internal viewer and raw mode (used for F13).
*/
static void
do_view_cmd (gboolean normal)
{
/* Directories are viewed by changing to them */
if (S_ISDIR (selection (current_panel)->st.st_mode) || link_isdir (selection (current_panel)))
{
vfs_path_t *fname_vpath;
if (confirm_view_dir && (current_panel->marked || current_panel->dirs_marked))
{
if (query_dialog
(_("Confirmation"), _("Files tagged, want to cd?"), D_NORMAL, 2,
_("&Yes"), _("&No")) != 0)
{
return;
}
}
fname_vpath = vfs_path_from_str (selection (current_panel)->fname);
if (!do_cd (fname_vpath, cd_exact))
message (D_ERROR, MSG_ERROR, _("Cannot change directory"));
vfs_path_free (fname_vpath);
}
else
{
int file_idx;
vfs_path_t *filename_vpath;
file_idx = current_panel->selected;
filename_vpath = vfs_path_from_str (current_panel->dir.list[file_idx].fname);
view_file (filename_vpath, normal, use_internal_view != 0);
vfs_path_free (filename_vpath);
}
repaint_screen ();
}
gboolean
handle_path (const char *path, struct stat * buf1, int *link_to_dir, int *stale_link)
{
vfs_path_t *vpath;
if (DIR_IS_DOT (path) || DIR_IS_DOTDOT (path))
return FALSE;
vpath = vfs_path_from_str (path);
if (mc_lstat (vpath, buf1) == -1)
{
vfs_path_free (vpath);
return FALSE;
}
if (S_ISDIR (buf1->st_mode))
tree_store_mark_checked (path);
/* A link to a file or a directory? */
*link_to_dir = 0;
*stale_link = 0;
if (S_ISLNK (buf1->st_mode))
{
struct stat buf2;
if (mc_stat (vpath, &buf2) == 0)
*link_to_dir = S_ISDIR (buf2.st_mode) != 0;
else
*stale_link = 1;
}
vfs_path_free (vpath);
return TRUE;
}
/* *INDENT-OFF* */
END_TEST
/* *INDENT-ON* */
/* --------------------------------------------------------------------------------------------- */
/* @Test */
/* *INDENT-OFF* */
START_TEST (the_file_is_remote)
/* *INDENT-ON* */
{
/* given */
vfs_path_t *filename_vpath, *local_vpath, *local_vpath_should_be_freeing;
filename_vpath = vfs_path_from_str ("/ftp://some.host/editme.txt");
local_vpath = vfs_path_from_str ("/tmp/blabla-editme.txt");
local_vpath_should_be_freeing = vfs_path_clone (local_vpath);
vfs_file_is_local__return_value = FALSE;
mc_getlocalcopy__return_value = local_vpath_should_be_freeing;
/* when */
execute_with_vfs_arg ("cmd_for_remote_file", filename_vpath);
/* then */
mctest_assert_str_eq (do_execute__lc_shell__captured, "cmd_for_remote_file");
mctest_assert_str_eq (do_execute__command__captured, "/tmp/blabla-editme.txt");
mctest_assert_int_eq (vfs_file_is_local__vpath__captured->len, 1);
mctest_assert_int_eq (vfs_path_equal
(g_ptr_array_index (vfs_file_is_local__vpath__captured, 0),
filename_vpath), TRUE);
mctest_assert_int_eq (vfs_path_equal
(mc_getlocalcopy__pathname_vpath__captured, filename_vpath), TRUE);
mctest_assert_int_eq (mc_stat__vpath__captured->len, 2);
mctest_assert_int_eq (vfs_path_equal
(g_ptr_array_index (mc_stat__vpath__captured, 0), local_vpath), TRUE);
mctest_assert_int_eq (vfs_path_equal
(g_ptr_array_index (mc_stat__vpath__captured, 0),
g_ptr_array_index (mc_stat__vpath__captured, 1)), TRUE);
mctest_assert_int_eq (vfs_path_equal
(mc_ungetlocalcopy__pathname_vpath__captured, filename_vpath), TRUE);
mctest_assert_int_eq (vfs_path_equal (mc_ungetlocalcopy__local_vpath__captured, local_vpath),
TRUE);
vfs_path_free (filename_vpath);
vfs_path_free (local_vpath);
}
void
edit_mc_menu_cmd (void)
{
vfs_path_t *buffer_vpath;
vfs_path_t *menufile_vpath;
int dir = 0;
query_set_sel (1);
dir = query_dialog (_("Menu edit"),
_("Which menu file do you want to edit?"),
D_NORMAL, geteuid ()? 2 : 3, _("&Local"), _("&User"), _("&System Wide"));
menufile_vpath = vfs_path_build_filename (mc_global.sysconfig_dir, MC_GLOBAL_MENU, NULL);
if (!exist_file (vfs_path_get_last_path_str (menufile_vpath)))
{
vfs_path_free (menufile_vpath);
menufile_vpath = vfs_path_build_filename (mc_global.share_data_dir, MC_GLOBAL_MENU, NULL);
}
switch (dir)
{
case 0:
buffer_vpath = vfs_path_from_str (MC_LOCAL_MENU);
check_for_default (menufile_vpath, buffer_vpath);
chmod (vfs_path_get_last_path_str (buffer_vpath), 0600);
break;
case 1:
buffer_vpath = mc_config_get_full_vpath (MC_USERMENU_FILE);
check_for_default (menufile_vpath, buffer_vpath);
break;
case 2:
buffer_vpath = vfs_path_build_filename (mc_global.sysconfig_dir, MC_GLOBAL_MENU, NULL);
if (!exist_file (vfs_path_get_last_path_str (buffer_vpath)))
{
vfs_path_free (buffer_vpath);
buffer_vpath = vfs_path_build_filename (mc_global.share_data_dir, MC_GLOBAL_MENU, NULL);
}
break;
default:
vfs_path_free (menufile_vpath);
return;
}
do_edit (buffer_vpath);
vfs_path_free (buffer_vpath);
vfs_path_free (menufile_vpath);
}
static void
apply_advanced_chowns (struct stat *sf)
{
vfs_path_t *vpath;
char *lc_fname;
gid_t a_gid = sf->st_gid;
uid_t a_uid = sf->st_uid;
lc_fname = current_panel->dir.list[current_file].fname;
vpath = vfs_path_from_str (lc_fname);
need_update = end_chown = TRUE;
if (mc_chmod (vpath, get_mode ()) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chmod \"%s\"\n%s"),
lc_fname, unix_error_string (errno));
/* call mc_chown only, if mc_chmod didn't fail */
else if (mc_chown (vpath, (ch_flags[9] == '+') ? sf->st_uid : (uid_t) (-1),
(ch_flags[10] == '+') ? sf->st_gid : (gid_t) (-1)) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chown \"%s\"\n%s"),
lc_fname, unix_error_string (errno));
do_file_mark (current_panel, current_file, 0);
vfs_path_free (vpath);
do
{
lc_fname = next_file ();
vpath = vfs_path_from_str (lc_fname);
if (mc_stat (vpath, sf) != 0)
{
vfs_path_free (vpath);
break;
}
ch_cmode = sf->st_mode;
if (mc_chmod (vpath, get_mode ()) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chmod \"%s\"\n%s"),
lc_fname, unix_error_string (errno));
/* call mc_chown only, if mc_chmod didn't fail */
else if (mc_chown (vpath, (ch_flags[9] == '+') ? a_uid : (uid_t) (-1),
(ch_flags[10] == '+') ? a_gid : (gid_t) (-1)) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chown \"%s\"\n%s"),
lc_fname, unix_error_string (errno));
do_file_mark (current_panel, current_file, 0);
vfs_path_free (vpath);
}
while (current_panel->marked != 0);
}
static gboolean
mc_config_new_or_override_file (mc_config_t * mc_config, const gchar * ini_path, GError ** error)
{
gchar *data, *written_data;
gsize len, total_written;
gboolean ret;
int fd;
ssize_t cur_written;
vfs_path_t *ini_vpath;
ini_vpath = vfs_path_from_str (ini_path);
data = g_key_file_to_data (mc_config->handle, &len, NULL);
if (!exist_file (ini_path))
{
ret = g_file_set_contents (ini_path, data, len, error);
g_free (data);
vfs_path_free (ini_vpath);
return ret;
}
mc_util_make_backup_if_possible (ini_path, "~");
fd = mc_open (ini_vpath, O_WRONLY | O_TRUNC, 0);
if (fd == -1)
{
g_propagate_error (error, g_error_new (MC_ERROR, 0, "%s", unix_error_string (errno)));
g_free (data);
vfs_path_free (ini_vpath);
return FALSE;
}
for (written_data = data, total_written = len;
(cur_written = mc_write (fd, (const void *) written_data, total_written)) > 0;
written_data += cur_written, total_written -= cur_written);
mc_close (fd);
g_free (data);
if (cur_written == -1)
{
mc_util_restore_from_backup_if_possible (ini_path, "~");
g_propagate_error (error, g_error_new (MC_ERROR, 0, "%s", unix_error_string (errno)));
vfs_path_free (ini_vpath);
return FALSE;
}
mc_util_unlink_backup_if_possible (ini_path, "~");
vfs_path_free (ini_vpath);
return TRUE;
}
/* event callback */
gboolean
clipboard_text_to_file (const gchar * event_group_name, const gchar * event_name,
gpointer init_data, gpointer data)
{
int file;
vfs_path_t *fname_vpath = NULL;
size_t str_len;
const char *text = (const char *) data;
(void) event_group_name;
(void) event_name;
(void) init_data;
if (text == NULL)
return FALSE;
fname_vpath = mc_config_get_full_vpath (EDIT_CLIP_FILE);
file = mc_open (fname_vpath, O_CREAT | O_WRONLY | O_TRUNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH | O_BINARY);
vfs_path_free (fname_vpath);
if (file == -1)
return TRUE;
str_len = strlen (text);
{
ssize_t ret;
ret = mc_write (file, (char *) text, str_len);
(void) ret;
}
mc_close (file);
return TRUE;
}
static void
apply_mask (struct stat *sf)
{
need_update = TRUE;
end_chmod = TRUE;
do_chmod (sf);
do
{
char *fname;
vfs_path_t *vpath;
gboolean ok;
fname = next_file ();
vpath = vfs_path_from_str (fname);
ok = (mc_stat (vpath, sf) == 0);
vfs_path_free (vpath);
if (!ok)
return;
c_stat = sf->st_mode;
do_chmod (sf);
}
while (current_panel->marked != 0);
}
/* *INDENT-OFF* */
START_PARAMETRIZED_TEST (check_if_filename_and_lineno_will_be_subtituted, check_subtitute_ds)
/* *INDENT-ON* */
{
/* given */
char *actual_result;
vfs_path_t *filename_vpath;
g_ptr_array_add (mc_config_get_string__return_value, g_strdup (data->config_opts_string));
filename_vpath = vfs_path_from_str (data->file_name);
/* when */
actual_result =
execute_get_external_cmd_opts_from_config (data->app_name, filename_vpath,
data->start_line);
/* then */
/* check returned value */
mctest_assert_str_eq (actual_result, data->expected_result);
/* check calls to mc_config_get_string() function */
mctest_assert_str_eq (g_ptr_array_index (mc_config_get_string__group__captured, 0),
CONFIG_EXT_EDITOR_VIEWER_SECTION);
mctest_assert_str_eq (g_ptr_array_index (mc_config_get_string__param__captured, 0),
data->app_name);
mctest_assert_str_eq (g_ptr_array_index (mc_config_get_string__default_value__captured, 0),
NULL);
vfs_path_free (filename_vpath);
}
/* *INDENT-OFF* */
END_PARAMETRIZED_TEST
/* *INDENT-ON* */
/* --------------------------------------------------------------------------------------------- */
/* @Test */
/* *INDENT-OFF* */
START_TEST (the_file_is_remote_but_empty)
/* *INDENT-ON* */
{
/* given */
vfs_path_t *filename_vpath;
filename_vpath = NULL;
vfs_file_is_local__return_value = FALSE;
/* when */
execute_with_vfs_arg ("cmd_for_remote_file", filename_vpath);
/* then */
mctest_assert_str_eq (do_execute__lc_shell__captured, NULL);
mctest_assert_str_eq (do_execute__command__captured, NULL);
mctest_assert_int_eq (vfs_file_is_local__vpath__captured->len, 2);
mctest_assert_int_eq (vfs_path_equal
(g_ptr_array_index (vfs_file_is_local__vpath__captured, 0),
vfs_get_raw_current_dir ()), TRUE);
fail_unless (g_ptr_array_index (vfs_file_is_local__vpath__captured, 1) == NULL,
"\nParameter for second call to vfs_file_is_local() should be NULL!");
fail_unless (mc_getlocalcopy__pathname_vpath__captured == NULL,
"\nFunction mc_getlocalcopy() shouldn't be called!");
vfs_path_free (filename_vpath);
}
/* *INDENT-OFF* */
START_PARAMETRIZED_TEST (the_file_is_local, the_file_is_local_ds)
/* *INDENT-ON* */
{
/* given */
vfs_path_t *filename_vpath;
filename_vpath = vfs_path_from_str (data->input_path);
vfs_file_is_local__return_value = TRUE;
/* when */
execute_with_vfs_arg ("cmd_for_local_file", filename_vpath);
/* then */
mctest_assert_str_eq (do_execute__lc_shell__captured, "cmd_for_local_file");
mctest_assert_str_eq (do_execute__command__captured, data->input_path);
mctest_assert_int_eq (vfs_file_is_local__vpath__captured->len, 1);
{
const vfs_path_t *tmp_vpath;
tmp_vpath = (data->input_path == NULL) ? vfs_get_raw_current_dir () : filename_vpath;
mctest_assert_int_eq (vfs_path_equal
(g_ptr_array_index (vfs_file_is_local__vpath__captured, 0),
tmp_vpath), TRUE);
}
mctest_assert_int_eq (do_execute__flags__captured, EXECUTE_INTERNAL);
fail_unless (mc_getlocalcopy__pathname_vpath__captured == NULL,
"\nFunction mc_getlocalcopy() shouldn't be called!");
vfs_path_free (filename_vpath);
}
END_TEST
/* --------------------------------------------------------------------------------------------- */
#define ETALON_STR "/path/to/file.ext/test1://#enc:KOI8-R"
START_TEST (test_vfs_path_encoding_at_end)
{
vfs_path_t *vpath;
char *result;
const vfs_path_element_t *element;
mc_global.sysconfig_dir = (char *) TEST_SHARE_DIR;
load_codepages_list ();
vpath = vfs_path_from_str_flags ("/path/to/file.ext#test1:/#enc:KOI8-R", VPF_USE_DEPRECATED_PARSER);
result = vfs_path_to_str(vpath);
element = vfs_path_get_by_index(vpath, -1);
fail_unless(*element->path == '\0', "element->path should be empty, but actual value is '%s'",element->path);
fail_unless(element->encoding != NULL && strcmp(element->encoding, "KOI8-R") == 0,
"element->encoding should be 'KOI8-R', but actual value is '%s'",element->encoding);
fail_unless( result != NULL && strcmp(result, ETALON_STR) ==0,
"\nactual: %s\netalon: %s", result , ETALON_STR );
g_free(result);
vfs_path_free(vpath);
free_codepages_list ();
}
END_TEST
/* --------------------------------------------------------------------------------------------- */
START_TEST (test_vfs_path_from_to_string2)
{
vfs_path_t *vpath;
size_t vpath_len;
char *result;
const vfs_path_element_t *path_element;
vpath = vfs_path_from_str ("/");
vpath_len = vfs_path_elements_count(vpath);
fail_unless(vpath_len == 1, "vpath length should be 1 (actial: %d)",vpath_len);
result = vfs_path_to_str(vpath);
fail_unless(strcmp("/", result) == 0, "expected(%s) doesn't equal to actual(%s)", "/", result);
g_free(result);
path_element = vfs_path_get_by_index (vpath, -1);
fail_unless(strcmp("/", path_element->path) == 0, "expected(%s) doesn't equal to actual(%s)", "/", path_element->path);
fail_unless(path_element->class == &vfs_local_ops , "actual vfs-class doesn't equal to localfs");
vfs_path_free(vpath);
}
void
hotlist_cmd (void)
{
char *target;
target = hotlist_show (LIST_HOTLIST);
if (!target)
return;
if (get_current_type () == view_tree)
tree_chdir (the_tree, target);
else
{
vfs_path_t *deprecated_vpath;
char *cmd;
deprecated_vpath = vfs_path_from_str_flags (target, VPF_USE_DEPRECATED_PARSER);
cmd = g_strconcat ("cd ", vfs_path_as_str (deprecated_vpath), (char *) NULL);
vfs_path_free (deprecated_vpath);
do_cd_command (cmd);
g_free (cmd);
}
g_free (target);
}
void
edit_cmd_new (void)
{
vfs_path_t *fname_vpath = NULL;
if (editor_ask_filename_before_edit)
{
char *fname;
fname = input_expand_dialog (_("Edit file"), _("Enter file name:"),
MC_HISTORY_EDIT_LOAD, "", INPUT_COMPLETE_FILENAMES);
if (fname == NULL)
return;
if (*fname != '\0')
fname_vpath = vfs_path_from_str (fname);
g_free (fname);
}
#ifdef HAVE_CHARSET
mc_global.source_codepage = default_source_codepage;
#endif
do_edit (fname_vpath);
vfs_path_free (fname_vpath);
}
static int
my_mkdir_rec (const vfs_path_t * s_vpath, mode_t mode)
{
vfs_path_t *q;
int result;
if (mc_mkdir (s_vpath, mode) == 0)
return 0;
if (errno != ENOENT)
return (-1);
/* FIXME: should check instead if s_vpath is at the root of that filesystem */
if (!vfs_file_is_local (s_vpath))
return (-1);
if (strcmp (vfs_path_as_str (s_vpath), PATH_SEP_STR) == 0)
{
errno = ENOTDIR;
return (-1);
}
q = vfs_path_append_new (s_vpath, "..", NULL);
result = my_mkdir_rec (q, mode);
vfs_path_free (q);
if (result == 0)
result = mc_mkdir (s_vpath, mode);
return result;
}
/* *INDENT-OFF* */
START_PARAMETRIZED_TEST (test_path_to_str_flags, test_path_to_str_flags_ds)
/* *INDENT-ON* */
{
/* given */
vfs_path_t *vpath;
char *str_path;
test_init_vfs ("UTF-8");
test_subclass1.flags = VFS_S_REMOTE;
vfs_s_init_class (&vfs_test_ops1, &test_subclass1);
vfs_test_ops1.name = "testfs1";
vfs_test_ops1.flags = VFSF_NOLINKS;
vfs_test_ops1.prefix = "test1";
vfs_register_class (&vfs_test_ops1);
/* when */
vpath = vfs_path_from_str_flags (data->input_path, data->input_from_str_flags);
str_path = vfs_path_to_str_flags (vpath, 0, data->input_to_str_flags);
/* then */
mctest_assert_str_eq (str_path, data->expected_path);
g_free (str_path);
vfs_path_free (vpath);
test_deinit_vfs ();
}
/* *INDENT-OFF* */
START_PARAMETRIZED_TEST (test_cd, test_cd_ds)
/* *INDENT-ON* */
{
/* given */
vfs_path_t *vpath;
vfs_test_ops.flags = data->input_class_flags;
test_subclass.flags = data->input_subclass_flags;
vfs_register_class (&vfs_test_ops);
vfs_set_raw_current_dir (vfs_path_from_str (data->input_initial_path));
vpath = vfs_path_from_str (data->input_cd_path);
/* when */
mc_chdir (vpath);
/* then */
{
char *actual_cd_path;
actual_cd_path = _vfs_get_cwd ();
mctest_assert_str_eq (actual_cd_path, data->expected_cd_path);
g_free (actual_cd_path);
}
vfs_path_free (vpath);
}
END_TEST
/* --------------------------------------------------------------------------------------------- */
START_TEST(test_encode_info_at_start)
{
vfs_path_t *vpath;
char *actual;
const vfs_path_element_t *vpath_element;
test_init_vfs("UTF-8");
vpath = vfs_path_from_str ("#enc:KOI8-R/bla-bla/some/path");
actual = vfs_path_to_str (vpath);
fail_unless (strcmp ("/#enc:KOI8-R/bla-bla/some/path", actual) == 0, "\nactual=%s\n", actual);
vpath_element = vfs_path_get_by_index (vpath, -1);
fail_unless (strcmp ("/bla-bla/some/path", vpath_element->path) == 0, "\nvpath_element->path=%s\n", vpath_element->path);
g_free (actual);
vfs_path_free (vpath);
test_deinit_vfs();
}
/* @After */
static void
teardown (void)
{
vfs_path_free (do_cd__new_dir_vpath__captured);
vfs_shut ();
str_uninit_strings ();
}
/* *INDENT-OFF* */
END_TEST
/* *INDENT-ON* */
/* --------------------------------------------------------------------------------------------- */
/* @Test */
/* *INDENT-OFF* */
START_TEST (test_mc_mkstemps)
/* *INDENT-ON* */
{
/* given */
vfs_path_t *pname_vpath = NULL;
char *pname = NULL;
char *begin_pname;
int fd;
/* when */
fd = mc_mkstemps (&pname_vpath, "mctest-", NULL);
if (fd != -1)
pname = vfs_path_to_str (pname_vpath);
begin_pname = g_build_filename (mc_tmpdir (), "mctest-", NULL);
/* then */
vfs_path_free (pname_vpath);
close (fd);
mctest_assert_int_ne (fd, -1);
fail_unless (g_file_test (pname, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR),
"\nNo such file: %s\n", pname);
unlink (pname);
fail_unless (strncmp (pname, begin_pname, strlen (begin_pname)) == 0,
"\nstart of %s should be equal to %s\n", pname, begin_pname);
g_free (pname);
}
static void
exec_cleanup_script (vfs_path_t * script_vpath)
{
if (script_vpath != NULL)
{
(void) mc_unlink (script_vpath);
vfs_path_free (script_vpath);
}
}
int
my_rmdir (const char *s)
{
int result;
vfs_path_t *vpath;
vpath = vfs_path_from_str_flags (s, VPF_NO_CANON);
/* FIXME: Should receive a Wtree! */
result = mc_rmdir (vpath);
if (result == 0)
{
vfs_path_t *my_s;
my_s = get_absolute_name (vpath);
vfs_path_free (my_s);
}
vfs_path_free (vpath);
return result;
}
static void
mcview_remove_ext_script (mcview_t * view)
{
if (view->ext_script != NULL)
{
mc_unlink (view->ext_script);
vfs_path_free (view->ext_script);
view->ext_script = NULL;
}
}
void
edit_cmd_force_internal (void)
{
vfs_path_t *fname;
fname = vfs_path_from_str (selection (current_panel)->fname);
if (regex_command (fname, "Edit") == 0)
edit_file_at_line (fname, TRUE, 1);
vfs_path_free (fname);
}
void
edit_cmd (void)
{
vfs_path_t *fname;
fname = vfs_path_from_str (selection (current_panel)->fname);
if (regex_command (fname, "Edit") == 0)
do_edit (fname);
vfs_path_free (fname);
}
/* *INDENT-OFF* */
START_PARAMETRIZED_TEST (test_path_equal_len, test_path_equal_len_ds)
/* *INDENT-ON* */
{
/* given */
vfs_path_t *vpath1, *vpath2;
gboolean actual_result;
vpath1 = vfs_path_from_str (data->input_path1);
vpath2 = vfs_path_from_str (data->input_path2);
/* when */
actual_result = vfs_path_equal_len (vpath1, vpath2, data->input_length);
/* then */
mctest_assert_int_eq (actual_result, data->expected_result);
vfs_path_free (vpath1);
vfs_path_free (vpath2);
}
