mirrors
/
mc
mirror of https://github.com/MidnightCommander/mc
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
mc/tests/lib/utilunix__mc_pstream_get_st...

397 lines
9.5 KiB
C
Raw Blame History

/*
lib - Read string from mc_pipe_stream
Copyright (C) 2021-2023
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);
}
/* --------------------------------------------------------------------------------------------- */
Reference in New Issue View Git Blame Copy Permalink