* Copyright 2011 kubtek <kubtek@mail.com>
*
* This file is part of StarDict.
*
* StarDict 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.
*
* StarDict 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 StarDict. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <glib.h>
#include <cstdlib>
#include <cstring>
#include <string>
#include "lib/utils.h"
#include "libcommon.h"
void test_extract_word(void)
{
const size_t buffer_size = 256;
char buffer[buffer_size];
struct TData {
const char* source;
int pos;
const char* result;
};
TData data[] = {
{
"",
0,
""
},
{
" ",
2,
""
},
{
"aaaaaaa",
0,
"aaaaaaa"
},
{
"aaaaaaa",
1,
"aaaaaaa"
},
{
" aaaaaaa",
0,
"aaaaaaa"
},
{
" aaaaaaa ",
4,
"aaaaaaa"
},
{
" aaa bbbb ",
5,
"aaa"
},
{
" 1111 333333 33333 7 9 00000 88383883 ",
24,
"7"
},
{
NULL,
0,
NULL
}
};
for(TData *d=data; d->source; ++d) {
extract_word(buffer, d->source, d->pos, g_unichar_isspace);
if(strcmp(buffer, d->result)) {
printf("Test extract_word failed. source = %s, pos = %d\n", d->source, d->pos);
exit(1);
}
}
}
void test_extract_capitalized_word(void)
{
const size_t buffer_size = 256;
char buffer[buffer_size];
struct TData {
const char* source;
int pos;
const char* result;
};
TData data[] = {
{
"",
0,
""
},
{
"cAb ",
0,
"Ab"
},
{
"cAb ",
1,
"Ab"
},
{
"cAb ",
2,
"Ab"
},
{
"cAb ",
4,
"Ab"
},
{
NULL,
0,
NULL
}
};
for(TData *d=data; d->source; ++d) {
extract_capitalized_word(buffer, d->source, d->pos, g_unichar_isupper, g_unichar_islower);
if(strcmp(buffer, d->result)) {
printf("Test extract_capitalized_word failed. source = %s, pos = %d\n", d->source, d->pos);
exit(1);
}
}
}
void test_copy_normalize_trim_spaces(void)
{
const size_t buffer_size = 256;
char buffer[buffer_size];
struct TData {
const char* source;
const char* result;
};
TData data[] = {
{
" a b ",
"a b"
},
{
"a b d",
"a b d"
},
{
NULL,
NULL
}
};
for(TData *d=data; d->source; ++d) {
copy_normalize_trim_spaces(buffer, d->source);
if(strcmp(buffer, d->result)) {
printf("Test copy_normalize_trim_spaces failed. source = %s\n", d->source);
exit(1);
}
}
}
void test_norm_path_win(void)
{
struct TData {
const char* source;
const char* resolved_path;
int result;
};
TData data[] = {
{
"c:\\",
"c:\\",
EXIT_SUCCESS
},
{
"c:",
"c:",
EXIT_SUCCESS
},
{
"\\\\abcd",
"\\\\abcd",
EXIT_SUCCESS
},
{
"\\\\abcd\\",
"\\\\abcd\\",
EXIT_SUCCESS
},
{
"\\\\",
"",
EXIT_FAILURE
},
{
"\\\\\\",
"",
EXIT_FAILURE
},
{
"\\abcd",
"\\abcd",
EXIT_SUCCESS
},
{
"\\abcd\\",
"\\abcd\\",
EXIT_SUCCESS
},
{
"abcd",
"abcd",
EXIT_SUCCESS
},
{
"a",
"a",
EXIT_SUCCESS
},
{
".",
".",
EXIT_SUCCESS
},
{
".\\",
".\\",
EXIT_SUCCESS
},
{
".\\ab",
"ab",
EXIT_SUCCESS
},
{
"",
".",
EXIT_SUCCESS
},
{
"c:\\..",
"",
EXIT_FAILURE
},
{
"\\\\..",
"\\\\..",
EXIT_SUCCESS
},
{
"\\\\abcd\\..",
"",
EXIT_FAILURE
},
{
"\\..",
"",
EXIT_FAILURE
},
{
"..",
"..",
EXIT_SUCCESS
},
{
"..\\",
"..\\",
EXIT_SUCCESS
},
{
"c:\\ab\\\\cd",
"",
EXIT_FAILURE
},
{
"\\\\abcd\\\\",
"",
EXIT_FAILURE
},
{
"\\abcd\\\\de",
"",
EXIT_FAILURE
},
{
"..",
"..",
EXIT_SUCCESS
},
{
"..\\..",
"..\\..",
EXIT_SUCCESS
},
{
"abcd\\..",
".",
EXIT_SUCCESS
},
{
"abcd\\..\\..",
"..",
EXIT_SUCCESS
},
{
"abcd\\..\\..\\",
"..\\",
EXIT_SUCCESS
},
{
"\\a\\b\\..",
"\\a\\",
EXIT_SUCCESS
},
{
"\\a\\b\\c\\..\\..\\d",
"\\a\\d",
EXIT_SUCCESS
},
{
".\\..",
"..",
EXIT_SUCCESS
},
{
"c:\\dir\\.",
"c:\\dir\\",
EXIT_SUCCESS
},
{
"c:\\dir\\.\\",
"c:\\dir\\",
EXIT_SUCCESS
},
{
"\\dir\\.",
"\\dir\\",
EXIT_SUCCESS
},
{
"\\dir\\.\\",
"\\dir\\",
EXIT_SUCCESS
},
{
"\\.",
"\\",
EXIT_SUCCESS
},
{
"\\.\\",
"\\",
EXIT_SUCCESS
},
{
"\\dir\\.\\..",
"\\",
EXIT_SUCCESS
},
{
"\\dir\\.\\.\\make",
"\\dir\\make",
EXIT_SUCCESS
},
{
"",
"",
EXIT_SUCCESS
},
{
"",
"",
EXIT_FAILURE
},
*/
{
NULL,
NULL,
0
}
};
std::string resolved_path;
for(TData *d=data; d->source; ++d) {
int result = norm_path_win(d->source, resolved_path);
if(strcmp(resolved_path.c_str(), d->resolved_path) != 0 || result != d->result) {
printf("Test test_resolve_path failed. source = %s\n", d->source);
exit(1);
}
}
}
void test_build_relative_path(void)
{
struct TData {
const char* base_dir;
const char* path;
const char* rel_path;
int result;
};
TData data[] = {
{
"c:\\",
"c:\\dir1",
"dir1",
EXIT_SUCCESS
},
{
"c:\\",
"c:\\dir1\\",
"dir1\\",
EXIT_SUCCESS
},
{
"c:\\",
"c:\\a\\b\\",
"a\\b\\",
EXIT_SUCCESS
},
{
"c:\\",
"c:\\a\\b",
"a\\b",
EXIT_SUCCESS
},
{
"c:\\dir",
"c:\\dir",
"",
EXIT_SUCCESS
},
{
"c:\\dir\\",
"c:\\dir",
"",
EXIT_SUCCESS
},
{
"c:\\dir\\",
"c:\\dir\\",
"",
EXIT_SUCCESS
},
{
"\\",
"\\a",
"a",
EXIT_SUCCESS
},
{
"\\",
"\\a\\",
"a\\",
EXIT_SUCCESS
},
{
"\\a",
"\\a\\",
"",
EXIT_SUCCESS
},
{
"\\\\a",
"\\\\a",
"",
EXIT_SUCCESS
},
{
"\\\\a\\",
"\\\\a",
"",
EXIT_SUCCESS
},
{
"\\\\a",
"\\\\a\\dir",
"dir",
EXIT_SUCCESS
},
{
"\\\\a\\",
"\\\\a\\dir",
"dir",
EXIT_SUCCESS
},
{
"\\\\a\\",
"\\\\a\\dir\\",
"dir\\",
EXIT_SUCCESS
},
{
"\\a\\b\\c",
"\\a\\b",
"..",
EXIT_SUCCESS
},
{
"\\a\\b\\c\\",
"\\a\\b",
"..",
EXIT_SUCCESS
},
{
"\\a\\b\\c\\",
"\\a\\b\\",
"..\\",
EXIT_SUCCESS
},
{
"\\a\\b\\c",
"\\a\\d",
"..\\..\\d",
EXIT_SUCCESS
},
{
"\\a\\b\\c",
"\\a\\d\\",
"..\\..\\d\\",
EXIT_SUCCESS
},
{
"",
"",
"",
EXIT_SUCCESS
},
{
"",
"",
"",
EXIT_FAILURE
},
*/
{
NULL,
NULL,
NULL,
0
}
};
std::string rel_path;
for(TData *d=data; d->base_dir; ++d) {
int result = build_relative_path(d->base_dir, d->path, rel_path);
if(strcmp(rel_path.c_str(), d->rel_path) != 0 || result != d->result) {
printf("Test test_build_relative_path failed. base_dir = '%s', path = '%s', rel_path = '%s'\n",
d->base_dir, d->path, rel_path.c_str());
exit(1);
}
}
}
void test_is_ascii_alpha(void)
{
struct TData {
wchar_t ch;
bool result;
};
TData data[] = {
{
L'a',
true
},
{
L'Z',
true
},
{
L'',
true
},
{
L'',
false
},
*/
{
L'\0',
false
}
};
for(TData *d=data; d->ch; ++d) {
bool result = is_ascii_alpha(d->ch);
if(result != d->result) {
printf("Test test_is_ascii_alpha failed.\n");
exit(1);
}
}
}
int main(int argc, char *argv[])
{
test_extract_word();
test_extract_capitalized_word();
test_copy_normalize_trim_spaces();
test_norm_path_win();
test_build_relative_path();
test_is_ascii_alpha();
return 0;
}