|
1 /* GLIB - Library of useful routines for C programming |
|
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald |
|
3 * Portion Copyright © 2008-09 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. |
|
4 * This library is free software; you can redistribute it and/or |
|
5 * modify it under the terms of the GNU Lesser General Public |
|
6 * License as published by the Free Software Foundation; either |
|
7 * version 2 of the License, or (at your option) any later version. |
|
8 * |
|
9 * This library is distributed in the hope that it will be useful, |
|
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
12 * Lesser General Public License for more details. |
|
13 * |
|
14 * You should have received a copy of the GNU Lesser General Public |
|
15 * License along with this library; if not, write to the |
|
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
|
17 * Boston, MA 02111-1307, USA. |
|
18 */ |
|
19 |
|
20 /* |
|
21 * Modified by the GLib Team and others 1997-2000. See the AUTHORS |
|
22 * file for a list of people on the GLib Team. See the ChangeLog |
|
23 * files for a list of changes. These files are distributed with |
|
24 * GLib at ftp://ftp.gtk.org/pub/gtk/. |
|
25 */ |
|
26 |
|
27 #undef G_DISABLE_ASSERT |
|
28 #undef G_LOG_DOMAIN |
|
29 |
|
30 #include <glib.h> |
|
31 #include <stdio.h> |
|
32 #include <string.h> |
|
33 #include <stdlib.h> |
|
34 |
|
35 #ifdef __SYMBIAN32__ |
|
36 #include "mrt2_glib2_test.h" |
|
37 #endif /*__SYMBIAN32__*/ |
|
38 |
|
39 typedef struct _TestResult TestResult; |
|
40 |
|
41 struct _TestResult |
|
42 { |
|
43 gint argc; |
|
44 const gchar **argv; |
|
45 }; |
|
46 |
|
47 static const gchar * |
|
48 test_command_lines[] = |
|
49 { |
|
50 /* 0 */ "foo bar", |
|
51 /* 1 */ "foo 'bar'", |
|
52 /* 2 */ "foo \"bar\"", |
|
53 /* 3 */ "foo '' 'bar'", |
|
54 /* 4 */ "foo \"bar\"'baz'blah'foo'\\''blah'\"boo\"", |
|
55 /* 5 */ "foo \t \tblah\tfoo\t\tbar baz", |
|
56 /* 6 */ "foo ' spaces more spaces lots of spaces in this ' \t", |
|
57 /* 7 */ "foo \\\nbar", |
|
58 /* 8 */ "foo '' ''", |
|
59 /* 9 */ "foo \\\" la la la", |
|
60 /* 10 */ "foo \\ foo woo woo\\ ", |
|
61 /* 11 */ "foo \"yada yada \\$\\\"\"", |
|
62 /* 12 */ "foo \"c:\\\\\"", |
|
63 NULL |
|
64 }; |
|
65 |
|
66 static const gchar *result0[] = { "foo", "bar", NULL }; |
|
67 static const gchar *result1[] = { "foo", "bar", NULL }; |
|
68 static const gchar *result2[] = { "foo", "bar", NULL }; |
|
69 static const gchar *result3[] = { "foo", "", "bar", NULL }; |
|
70 static const gchar *result4[] = { "foo", "barbazblahfoo'blahboo", NULL }; |
|
71 static const gchar *result5[] = { "foo", "blah", "foo", "bar", "baz", NULL }; |
|
72 static const gchar *result6[] = { "foo", " spaces more spaces lots of spaces in this ", NULL }; |
|
73 static const gchar *result7[] = { "foo", "bar", NULL }; |
|
74 static const gchar *result8[] = { "foo", "", "", NULL }; |
|
75 static const gchar *result9[] = { "foo", "\"", "la", "la", "la", NULL }; |
|
76 static const gchar *result10[] = { "foo", " foo", "woo", "woo ", NULL }; |
|
77 static const gchar *result11[] = { "foo", "yada yada $\"", NULL }; |
|
78 static const gchar *result12[] = { "foo", "c:\\", NULL }; |
|
79 |
|
80 static const TestResult |
|
81 correct_results[] = |
|
82 { |
|
83 { G_N_ELEMENTS (result0) - 1, result0 }, |
|
84 { G_N_ELEMENTS (result1) - 1, result1 }, |
|
85 { G_N_ELEMENTS (result2) - 1, result2 }, |
|
86 { G_N_ELEMENTS (result3) - 1, result3 }, |
|
87 { G_N_ELEMENTS (result4) - 1, result4 }, |
|
88 { G_N_ELEMENTS (result5) - 1, result5 }, |
|
89 { G_N_ELEMENTS (result6) - 1, result6 }, |
|
90 { G_N_ELEMENTS (result7) - 1, result7 }, |
|
91 { G_N_ELEMENTS (result8) - 1, result8 }, |
|
92 { G_N_ELEMENTS (result9) - 1, result9 }, |
|
93 { G_N_ELEMENTS (result10) - 1, result10 }, |
|
94 { G_N_ELEMENTS (result11) - 1, result11 }, |
|
95 { G_N_ELEMENTS (result12) - 1, result12 } |
|
96 }; |
|
97 |
|
98 static void |
|
99 print_test (const gchar *cmdline, gint argc, gchar **argv, |
|
100 const TestResult *result) |
|
101 { |
|
102 gint i; |
|
103 |
|
104 fprintf (stderr, "Command line was: '%s'\n", cmdline); |
|
105 |
|
106 fprintf (stderr, "Expected result (%d args):\n", result->argc); |
|
107 |
|
108 i = 0; |
|
109 while (result->argv[i]) |
|
110 { |
|
111 fprintf (stderr, " %3d '%s'\n", i, result->argv[i]); |
|
112 ++i; |
|
113 } |
|
114 |
|
115 fprintf (stderr, "Actual result (%d args):\n", argc); |
|
116 |
|
117 i = 0; |
|
118 while (argv[i]) |
|
119 { |
|
120 fprintf (stderr, " %3d '%s'\n", i, argv[i]); |
|
121 ++i; |
|
122 } |
|
123 } |
|
124 |
|
125 static void |
|
126 do_argv_test (const gchar *cmdline, const TestResult *result) |
|
127 { |
|
128 gint argc; |
|
129 gchar **argv; |
|
130 GError *err; |
|
131 gint i; |
|
132 |
|
133 err = NULL; |
|
134 if (!g_shell_parse_argv (cmdline, &argc, &argv, &err)) |
|
135 { |
|
136 fprintf (stderr, "Error parsing command line that should work fine: %s\n", |
|
137 err->message); |
|
138 |
|
139 exit (1); |
|
140 } |
|
141 |
|
142 if (argc != result->argc) |
|
143 { |
|
144 fprintf (stderr, "Expected and actual argc don't match\n"); |
|
145 print_test (cmdline, argc, argv, result); |
|
146 exit (1); |
|
147 } |
|
148 |
|
149 i = 0; |
|
150 while (argv[i]) |
|
151 { |
|
152 if (strcmp (argv[i], result->argv[i]) != 0) |
|
153 { |
|
154 fprintf (stderr, "Expected and actual arg %d do not match\n", i); |
|
155 print_test (cmdline, argc, argv, result); |
|
156 exit (1); |
|
157 } |
|
158 |
|
159 ++i; |
|
160 } |
|
161 |
|
162 if (argv[i] != NULL) |
|
163 { |
|
164 fprintf (stderr, "argv didn't get NULL-terminated\n"); |
|
165 exit (1); |
|
166 } |
|
167 g_strfreev (argv); |
|
168 } |
|
169 |
|
170 static void |
|
171 run_tests (void) |
|
172 { |
|
173 gint i; |
|
174 |
|
175 i = 0; |
|
176 while (test_command_lines[i]) |
|
177 { |
|
178 do_argv_test (test_command_lines[i], &correct_results[i]); |
|
179 ++i; |
|
180 } |
|
181 } |
|
182 |
|
183 static gboolean any_test_failed = FALSE; |
|
184 |
|
185 #define CHECK_STRING_RESULT(expression, expected_value) \ |
|
186 check_string_result (#expression, __FILE__, __LINE__, expression, expected_value) |
|
187 |
|
188 static void |
|
189 check_string_result (const char *expression, |
|
190 const char *file_name, |
|
191 int line_number, |
|
192 char *result, |
|
193 const char *expected) |
|
194 { |
|
195 gboolean match; |
|
196 |
|
197 if (expected == NULL) |
|
198 match = result == NULL; |
|
199 else |
|
200 match = result != NULL && strcmp (result, expected) == 0; |
|
201 |
|
202 if (!match) |
|
203 { |
|
204 if (!any_test_failed) |
|
205 fprintf (stderr, "\n"); |
|
206 |
|
207 fprintf (stderr, "FAIL: check failed in %s, line %d\n", file_name, line_number); |
|
208 fprintf (stderr, " evaluated: %s\n", expression); |
|
209 fprintf (stderr, " expected: %s\n", expected == NULL ? "NULL" : expected); |
|
210 fprintf (stderr, " got: %s\n", result == NULL ? "NULL" : result); |
|
211 |
|
212 any_test_failed = TRUE; |
|
213 } |
|
214 |
|
215 g_free (result); |
|
216 } |
|
217 |
|
218 static char * |
|
219 test_shell_unquote (const char *str) |
|
220 { |
|
221 char *result; |
|
222 GError *error; |
|
223 |
|
224 error = NULL; |
|
225 result = g_shell_unquote (str, &error); |
|
226 if (error == NULL) |
|
227 return result; |
|
228 |
|
229 /* Leaks the error, which is no big deal and easy to fix if we |
|
230 * decide it matters. |
|
231 */ |
|
232 |
|
233 if (error->domain != G_SHELL_ERROR) |
|
234 return g_strdup ("error in domain other than G_SHELL_ERROR"); |
|
235 |
|
236 /* It would be nice to check the error message too, but that's |
|
237 * localized, so it's too much of a pain. |
|
238 */ |
|
239 switch (error->code) |
|
240 { |
|
241 case G_SHELL_ERROR_BAD_QUOTING: |
|
242 return g_strdup ("G_SHELL_ERROR_BAD_QUOTING"); |
|
243 case G_SHELL_ERROR_EMPTY_STRING: |
|
244 return g_strdup ("G_SHELL_ERROR_EMPTY_STRING"); |
|
245 case G_SHELL_ERROR_FAILED: |
|
246 return g_strdup ("G_SHELL_ERROR_FAILED"); |
|
247 default: |
|
248 return g_strdup ("bad error code in G_SHELL_ERROR domain"); |
|
249 } |
|
250 } |
|
251 |
|
252 int |
|
253 main (int argc, |
|
254 char *argv[]) |
|
255 { |
|
256 #ifdef __SYMBIAN32__ |
|
257 g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL); |
|
258 g_set_print_handler(mrtPrintHandler); |
|
259 #endif /*__SYMBIAN32__*/ |
|
260 |
|
261 |
|
262 run_tests (); |
|
263 |
|
264 CHECK_STRING_RESULT (g_shell_quote (""), "''"); |
|
265 CHECK_STRING_RESULT (g_shell_quote ("a"), "'a'"); |
|
266 CHECK_STRING_RESULT (g_shell_quote ("("), "'('"); |
|
267 CHECK_STRING_RESULT (g_shell_quote ("'"), "''\\'''"); |
|
268 CHECK_STRING_RESULT (g_shell_quote ("'a"), "''\\''a'"); |
|
269 CHECK_STRING_RESULT (g_shell_quote ("a'"), "'a'\\'''"); |
|
270 CHECK_STRING_RESULT (g_shell_quote ("a'a"), "'a'\\''a'"); |
|
271 |
|
272 CHECK_STRING_RESULT (test_shell_unquote (""), ""); |
|
273 CHECK_STRING_RESULT (test_shell_unquote ("a"), "a"); |
|
274 CHECK_STRING_RESULT (test_shell_unquote ("'a'"), "a"); |
|
275 CHECK_STRING_RESULT (test_shell_unquote ("'('"), "("); |
|
276 CHECK_STRING_RESULT (test_shell_unquote ("''\\'''"), "'"); |
|
277 CHECK_STRING_RESULT (test_shell_unquote ("''\\''a'"), "'a"); |
|
278 CHECK_STRING_RESULT (test_shell_unquote ("'a'\\'''"), "a'"); |
|
279 CHECK_STRING_RESULT (test_shell_unquote ("'a'\\''a'"), "a'a"); |
|
280 |
|
281 CHECK_STRING_RESULT (test_shell_unquote ("\\\\"), "\\"); |
|
282 CHECK_STRING_RESULT (test_shell_unquote ("\\\n"), ""); |
|
283 |
|
284 CHECK_STRING_RESULT (test_shell_unquote ("'\\''"), "G_SHELL_ERROR_BAD_QUOTING"); |
|
285 |
|
286 #if defined (_MSC_VER) && (_MSC_VER <= 1200) |
|
287 /* using \x22 instead of \" to work around a msvc 5.0, 6.0 compiler bug */ |
|
288 CHECK_STRING_RESULT (test_shell_unquote ("\x22\\\x22\""), "\""); |
|
289 #else |
|
290 CHECK_STRING_RESULT (test_shell_unquote ("\"\\\"\""), "\""); |
|
291 #endif |
|
292 |
|
293 CHECK_STRING_RESULT (test_shell_unquote ("\""), "G_SHELL_ERROR_BAD_QUOTING"); |
|
294 CHECK_STRING_RESULT (test_shell_unquote ("'"), "G_SHELL_ERROR_BAD_QUOTING"); |
|
295 |
|
296 CHECK_STRING_RESULT (test_shell_unquote ("\x22\\\\\""), "\\"); |
|
297 CHECK_STRING_RESULT (test_shell_unquote ("\x22\\`\""), "`"); |
|
298 CHECK_STRING_RESULT (test_shell_unquote ("\x22\\$\""), "$"); |
|
299 CHECK_STRING_RESULT (test_shell_unquote ("\x22\\\n\""), "\n"); |
|
300 |
|
301 CHECK_STRING_RESULT (test_shell_unquote ("\"\\'\""), "\\'"); |
|
302 CHECK_STRING_RESULT (test_shell_unquote ("\x22\\\r\""), "\\\r"); |
|
303 CHECK_STRING_RESULT (test_shell_unquote ("\x22\\n\""), "\\n"); |
|
304 |
|
305 #ifdef __SYMBIAN32__ |
|
306 testResultXml("shell-test"); |
|
307 #endif /* EMULATOR */ |
|
308 return any_test_failed ? 1 : 0; |
|
309 } |