mirror of
https://github.com/MidnightCommander/mc
synced 2024-12-22 20:36:50 +03:00
397 lines
9.5 KiB
C
397 lines
9.5 KiB
C
/*
|
|
lib - Read string from mc_pipe_stream
|
|
|
|
Copyright (C) 2021-2024
|
|
Free Software Foundation, Inc.
|
|
|
|
Written by:
|
|
Andrew Borodin <aborodin@vmail.ru>, 2021
|
|
|
|
This file is part of the Midnight Commander.
|
|
|
|
The Midnight Commander is free software: you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation, either version 3 of the License,
|
|
or (at your option) any later version.
|
|
|
|
The Midnight Commander is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#define TEST_SUITE_NAME "/lib/util"
|
|
|
|
#include "tests/mctest.h"
|
|
|
|
#include "lib/util.h"
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
#define MAX_CHUNKS 8
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
static mc_pipe_stream_t stream;
|
|
|
|
static char etalon_long_file_list[BUF_1K];
|
|
static size_t etalon_long_file_list_pos;
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/* @Before */
|
|
static void
|
|
setup (void)
|
|
{
|
|
}
|
|
|
|
/* @After */
|
|
static void
|
|
teardown (void)
|
|
{
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/* @DataSource("data_source") */
|
|
/* *INDENT-OFF* */
|
|
static const struct data_source
|
|
{
|
|
/* input */
|
|
const char *buf; /* string to read */
|
|
|
|
/* output */
|
|
int pos[MAX_CHUNKS]; /* ps.pos values */
|
|
const char *str[MAX_CHUNKS]; /* chunks */
|
|
size_t len[MAX_CHUNKS]; /* chunk lengths */
|
|
}
|
|
data_source[] =
|
|
{
|
|
/* 0 */
|
|
{
|
|
.buf = "",
|
|
.pos = { 0 },
|
|
.str = { "" },
|
|
.len = { 0 }
|
|
},
|
|
/* 1 */
|
|
{
|
|
.buf = "\n",
|
|
.pos = { 0, 1 },
|
|
.str = { "\n" },
|
|
.len = { 1, 0 }
|
|
},
|
|
/* 2 */
|
|
{
|
|
.buf = "\\\n",
|
|
.pos = { 0, 2 },
|
|
.str = { "\\\n" },
|
|
.len = { 2, 0 }
|
|
},
|
|
/* 3 */
|
|
{
|
|
.buf = "\\\\\n",
|
|
.pos = { 0, 3 },
|
|
.str = { "\\\\\n" },
|
|
.len = { 3, 0 }
|
|
},
|
|
/* 4 */
|
|
{
|
|
.buf = "\\\\\\\n",
|
|
.pos = { 0, 4 },
|
|
.str = { "\\\\\\\n" },
|
|
.len = { 4, 0 }
|
|
},
|
|
/* 5 */
|
|
{
|
|
.buf = "\\\\\\\\\n",
|
|
.pos = { 0, 5 },
|
|
.str = { "\\\\\\\\\n" },
|
|
.len = { 5, 0 }
|
|
},
|
|
/* 6 */
|
|
{
|
|
.buf = "12345",
|
|
.pos = { 0, 5 },
|
|
.str = { "12345" },
|
|
.len = { 5, 0 }
|
|
},
|
|
/* 7 */
|
|
{
|
|
.buf = "12345\n",
|
|
.pos = { 0, 6 },
|
|
.str = { "12345\n" },
|
|
.len = { 6, 0 }
|
|
},
|
|
/* 8 */
|
|
{
|
|
.buf = "12345\\\n",
|
|
.pos = { 0, 7 },
|
|
.str = { "12345\\\n" },
|
|
.len = { 7, 0 }
|
|
},
|
|
/* 9 */
|
|
{
|
|
.buf = "12345\\\\\n",
|
|
.pos = { 0, 8 },
|
|
.str = { "12345\\\\\n" },
|
|
.len = { 8, 0 }
|
|
},
|
|
/* 10 */
|
|
{
|
|
.buf = "12345\nabcd",
|
|
.pos = { 0, 6, 10 },
|
|
.str = { "12345\n", "abcd" },
|
|
.len = { 6, 4, 0 }
|
|
},
|
|
/* 11 */
|
|
{
|
|
.buf = "12345\\\nabcd",
|
|
.pos = { 0, 11 },
|
|
.str = { "12345\\\nabcd" },
|
|
.len = { 11, 0 }
|
|
},
|
|
/* 12 */
|
|
{
|
|
.buf = "12345\\\\\nabcd",
|
|
.pos = { 0, 8, 12 },
|
|
.str = { "12345\\\\\n", "abcd" },
|
|
.len = { 8, 4, 0 }
|
|
},
|
|
/* 13 */
|
|
{
|
|
.buf = "12345\\\\\\\nabcd",
|
|
.pos = { 0, 13 },
|
|
.str = { "12345\\\\\\\nabcd" },
|
|
.len = { 13, 0 }
|
|
},
|
|
/* 14 */
|
|
{
|
|
.buf = "12345\\\\\\\\\nabcd",
|
|
.pos = { 0, 10, 14 },
|
|
.str = { "12345\\\\\\\\\n", "abcd" },
|
|
.len = { 10, 4, 0 }
|
|
},
|
|
/* 15 */
|
|
{
|
|
.buf = "12345\nabcd\n",
|
|
.pos = { 0, 6, 11 },
|
|
.str = { "12345\n", "abcd\n" },
|
|
.len = { 6, 5, 0 }
|
|
},
|
|
/* 16 */
|
|
{
|
|
.buf = "12345\nabcd\n~!@#$%^",
|
|
.pos = { 0, 6, 11, 18 },
|
|
.str = { "12345\n", "abcd\n", "~!@#$%^" },
|
|
.len = { 6, 5, 7, 0 }
|
|
},
|
|
/* 17 */
|
|
{
|
|
.buf = "12345\nabcd\n~!@#$%^\n",
|
|
.pos = { 0, 6, 11, 19 },
|
|
.str = { "12345\n", "abcd\n", "~!@#$%^\n" },
|
|
.len = { 6, 5, 8, 0 }
|
|
}
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
/* @Test(dataSource = "data_source") */
|
|
/* *INDENT-OFF* */
|
|
START_PARAMETRIZED_TEST (mc_pstream_get_string_test, data_source)
|
|
/* *INDENT-ON* */
|
|
{
|
|
/* given */
|
|
int j = 0;
|
|
|
|
/* when */
|
|
memset (&stream, 0, sizeof (stream));
|
|
stream.len = strlen (data->buf);
|
|
memmove (&stream.buf, data->buf, stream.len);
|
|
|
|
/* then */
|
|
do
|
|
{
|
|
GString *ret;
|
|
|
|
ck_assert_int_eq (stream.pos, data->pos[j]);
|
|
|
|
ret = mc_pstream_get_string (&stream);
|
|
if (ret == NULL)
|
|
break;
|
|
|
|
ck_assert_int_eq (ret->len, data->len[j]);
|
|
mctest_assert_str_eq (ret->str, data->str[j]);
|
|
|
|
g_string_free (ret, TRUE);
|
|
|
|
j++;
|
|
}
|
|
while (TRUE);
|
|
}
|
|
/* *INDENT-OFF* */
|
|
END_PARAMETRIZED_TEST
|
|
/* *INDENT-ON* */
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
static mc_pipe_t *
|
|
test_mc_popen (void)
|
|
{
|
|
mc_pipe_t *p;
|
|
|
|
p = g_try_new0 (mc_pipe_t, 1);
|
|
/* make less than sizeof (etalon_long_file_list) */
|
|
p->out.len = 128;
|
|
|
|
etalon_long_file_list_pos = 0;
|
|
|
|
return p;
|
|
}
|
|
|
|
static void
|
|
test_mc_pread (mc_pipe_t *p)
|
|
{
|
|
size_t len;
|
|
|
|
p->out.pos = 0;
|
|
|
|
if (etalon_long_file_list_pos >= sizeof (etalon_long_file_list))
|
|
{
|
|
etalon_long_file_list_pos = sizeof (etalon_long_file_list);
|
|
p->out.len = MC_PIPE_STREAM_EOF;
|
|
return;
|
|
}
|
|
|
|
len = sizeof (etalon_long_file_list) - etalon_long_file_list_pos;
|
|
len = MIN (len, (size_t) p->out.len);
|
|
memmove (p->out.buf, etalon_long_file_list + etalon_long_file_list_pos, len);
|
|
p->out.len = (ssize_t) len;
|
|
|
|
etalon_long_file_list_pos += len;
|
|
}
|
|
|
|
/* *INDENT-OFF* */
|
|
START_TEST (mc_pstream_get_long_file_list_test)
|
|
/* *INDENT-ON* */
|
|
|
|
{
|
|
/* given */
|
|
GString *result_long_file_list = NULL;
|
|
mc_pipe_t *pip;
|
|
GString *remain_file_name = NULL;
|
|
|
|
/* when */
|
|
/* fill the list */
|
|
memset (etalon_long_file_list, 'a', sizeof (etalon_long_file_list) - 1);
|
|
/* create an \n-separated list */
|
|
etalon_long_file_list[5] = '\n';
|
|
etalon_long_file_list[25] = '\n';
|
|
etalon_long_file_list[50] = '\n';
|
|
etalon_long_file_list[75] = '\n';
|
|
etalon_long_file_list[127] = '\n';
|
|
etalon_long_file_list[200] = '\n';
|
|
etalon_long_file_list[310] = '\n';
|
|
etalon_long_file_list[325] = '\n';
|
|
etalon_long_file_list[360] = '\n';
|
|
etalon_long_file_list[512] = '\n';
|
|
etalon_long_file_list[701] = '\n';
|
|
etalon_long_file_list[725] = '\n';
|
|
etalon_long_file_list[800] = '\n';
|
|
etalon_long_file_list[sizeof (etalon_long_file_list) - 2] = '\n';
|
|
etalon_long_file_list[sizeof (etalon_long_file_list) - 1] = '\0';
|
|
|
|
/* then */
|
|
/* read file list */
|
|
pip = test_mc_popen ();
|
|
|
|
while (TRUE)
|
|
{
|
|
GString *line;
|
|
|
|
test_mc_pread (pip);
|
|
|
|
if (pip->out.len == MC_PIPE_STREAM_EOF)
|
|
break;
|
|
|
|
while ((line = mc_pstream_get_string (&pip->out)) != NULL)
|
|
{
|
|
/* handle an \n-separated file list */
|
|
|
|
if (line->str[line->len - 1] == '\n')
|
|
{
|
|
/* entire file name or last chunk */
|
|
|
|
g_string_truncate (line, line->len - 1);
|
|
|
|
/* join filename chunks */
|
|
if (remain_file_name != NULL)
|
|
{
|
|
g_string_append_len (remain_file_name, line->str, line->len);
|
|
g_string_free (line, TRUE);
|
|
line = remain_file_name;
|
|
remain_file_name = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* first or middle chunk of file name */
|
|
if (remain_file_name == NULL)
|
|
remain_file_name = line;
|
|
else
|
|
{
|
|
g_string_append_len (remain_file_name, line->str, line->len);
|
|
g_string_free (line, TRUE);
|
|
}
|
|
|
|
line = NULL;
|
|
}
|
|
|
|
/* collect file names to assemble the result string */
|
|
if (line == NULL)
|
|
continue;
|
|
|
|
if (result_long_file_list == NULL)
|
|
result_long_file_list = line;
|
|
else
|
|
{
|
|
g_string_append_len (result_long_file_list, line->str, line->len);
|
|
g_string_free (line, TRUE);
|
|
}
|
|
|
|
g_string_append_c (result_long_file_list, '\n');
|
|
}
|
|
}
|
|
|
|
mctest_assert_str_eq (etalon_long_file_list, result_long_file_list->str);
|
|
g_string_free (result_long_file_list, TRUE);
|
|
|
|
}
|
|
/* *INDENT-OFF* */
|
|
END_TEST
|
|
/* *INDENT-ON* */
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
TCase *tc_core;
|
|
|
|
tc_core = tcase_create ("Core");
|
|
|
|
tcase_add_checked_fixture (tc_core, setup, teardown);
|
|
|
|
/* Add new tests here: *************** */
|
|
mctest_add_parameterized_test (tc_core, mc_pstream_get_string_test, data_source);
|
|
tcase_add_test (tc_core, mc_pstream_get_long_file_list_test);
|
|
/* *********************************** */
|
|
|
|
return mctest_run_all (tc_core);
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|