/[pcre]/code/trunk/pcrecpp_unittest.cc
ViewVC logotype

Diff of /code/trunk/pcrecpp_unittest.cc

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 96 by nigel, Fri Mar 2 13:10:43 2007 UTC revision 302 by ph10, Sun Jan 20 19:12:46 2008 UTC
# Line 33  Line 33 
33  //  //
34  // TODO: Test extractions for PartialMatch/Consume  // TODO: Test extractions for PartialMatch/Consume
35    
36    #ifdef HAVE_CONFIG_H
37    #include "config.h"
38    #endif
39    
40  #include <stdio.h>  #include <stdio.h>
41  #include <cassert>  #include <cassert>
42  #include <vector>  #include <vector>
 #include "config.h"  
43  #include "pcrecpp.h"  #include "pcrecpp.h"
44    
45  using pcrecpp::StringPiece;  using pcrecpp::StringPiece;
# Line 107  static void LeakTest() { Line 110  static void LeakTest() {
110        initial_size = VirtualProcessSize();        initial_size = VirtualProcessSize();
111        printf("Size after 50000: %llu\n", initial_size);        printf("Size after 50000: %llu\n", initial_size);
112      }      }
113      char buf[100];      char buf[100];  // definitely big enough
114      snprintf(buf, sizeof(buf), "pat%09d", i);      sprintf(buf, "pat%09d", i);
115      RE newre(buf);      RE newre(buf);
116    }    }
117    uint64 final_size = VirtualProcessSize();    uint64 final_size = VirtualProcessSize();
# Line 210  static void TestReplace() { Line 213  static void TestReplace() {
213      const char *original;      const char *original;
214      const char *single;      const char *single;
215      const char *global;      const char *global;
216        int global_count;         // the expected return value from ReplaceAll
217    };    };
218    static const ReplaceTest tests[] = {    static const ReplaceTest tests[] = {
219      { "(qu|[b-df-hj-np-tv-z]*)([a-z]+)",      { "(qu|[b-df-hj-np-tv-z]*)([a-z]+)",
220        "\\2\\1ay",        "\\2\\1ay",
221        "the quick brown fox jumps over the lazy dogs.",        "the quick brown fox jumps over the lazy dogs.",
222        "ethay quick brown fox jumps over the lazy dogs.",        "ethay quick brown fox jumps over the lazy dogs.",
223        "ethay ickquay ownbray oxfay umpsjay overay ethay azylay ogsday." },        "ethay ickquay ownbray oxfay umpsjay overay ethay azylay ogsday.",
224          9 },
225      { "\\w+",      { "\\w+",
226        "\\0-NOSPAM",        "\\0-NOSPAM",
227        "paul.haahr@google.com",        "paul.haahr@google.com",
228        "paul-NOSPAM.haahr@google.com",        "paul-NOSPAM.haahr@google.com",
229        "paul-NOSPAM.haahr-NOSPAM@google-NOSPAM.com-NOSPAM" },        "paul-NOSPAM.haahr-NOSPAM@google-NOSPAM.com-NOSPAM",
230          4 },
231      { "^",      { "^",
232        "(START)",        "(START)",
233        "foo",        "foo",
234        "(START)foo",        "(START)foo",
235        "(START)foo" },        "(START)foo",
236          1 },
237      { "^",      { "^",
238        "(START)",        "(START)",
239        "",        "",
240        "(START)",        "(START)",
241        "(START)" },        "(START)",
242          1 },
243      { "$",      { "$",
244        "(END)",        "(END)",
245        "",        "",
246        "(END)",        "(END)",
247        "(END)" },        "(END)",
248          1 },
249      { "b",      { "b",
250        "bb",        "bb",
251        "ababababab",        "ababababab",
252        "abbabababab",        "abbabababab",
253        "abbabbabbabbabb" },        "abbabbabbabbabb",
254           5 },
255      { "b",      { "b",
256        "bb",        "bb",
257        "bbbbbb",        "bbbbbb",
258        "bbbbbbb",        "bbbbbbb",
259        "bbbbbbbbbbbb" },        "bbbbbbbbbbbb",
260          6 },
261      { "b+",      { "b+",
262        "bb",        "bb",
263        "bbbbbb",        "bbbbbb",
264        "bb",        "bb",
265        "bb" },        "bb",
266          1 },
267      { "b*",      { "b*",
268        "bb",        "bb",
269        "bbbbbb",        "bbbbbb",
270        "bb",        "bb",
271        "bb" },        "bb",
272          1 },
273      { "b*",      { "b*",
274        "bb",        "bb",
275        "aaaaa",        "aaaaa",
276        "bbaaaaa",        "bbaaaaa",
277        "bbabbabbabbabbabb" },        "bbabbabbabbabbabb",
278          6 },
279      { "b*",      { "b*",
280        "bb",        "bb",
281        "aa\naa\n",        "aa\naa\n",
282        "bbaa\naa\n",        "bbaa\naa\n",
283        "bbabbabb\nbbabbabb\nbb" },        "bbabbabb\nbbabbabb\nbb",
284          7 },
285      { "b*",      { "b*",
286        "bb",        "bb",
287        "aa\raa\r",        "aa\raa\r",
288        "bbaa\raa\r",        "bbaa\raa\r",
289        "bbabbabb\rbbabbabb\rbb" },        "bbabbabb\rbbabbabb\rbb",
290          7 },
291      { "b*",      { "b*",
292        "bb",        "bb",
293        "aa\r\naa\r\n",        "aa\r\naa\r\n",
294        "bbaa\r\naa\r\n",        "bbaa\r\naa\r\n",
295        "bbabbabb\r\nbbabbabb\r\nbb" },        "bbabbabb\r\nbbabbabb\r\nbb",
296          7 },
297  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
298      { "b*",      { "b*",
299        "bb",        "bb",
300        "\xE3\x83\x9B\xE3\x83\xBC\xE3\x83\xA0\xE3\x81\xB8",   // utf8        "\xE3\x83\x9B\xE3\x83\xBC\xE3\x83\xA0\xE3\x81\xB8",   // utf8
301        "bb\xE3\x83\x9B\xE3\x83\xBC\xE3\x83\xA0\xE3\x81\xB8",        "bb\xE3\x83\x9B\xE3\x83\xBC\xE3\x83\xA0\xE3\x81\xB8",
302        "bb\xE3\x83\x9B""bb""\xE3\x83\xBC""bb""\xE3\x83\xA0""bb""\xE3\x81\xB8""bb" },        "bb\xE3\x83\x9B""bb""\xE3\x83\xBC""bb""\xE3\x83\xA0""bb""\xE3\x81\xB8""bb",
303          5 },
304      { "b*",      { "b*",
305        "bb",        "bb",
306        "\xE3\x83\x9B\r\n\xE3\x83\xBC\r\xE3\x83\xA0\n\xE3\x81\xB8\r\n",   // utf8        "\xE3\x83\x9B\r\n\xE3\x83\xBC\r\xE3\x83\xA0\n\xE3\x81\xB8\r\n",   // utf8
307        "bb\xE3\x83\x9B\r\n\xE3\x83\xBC\r\xE3\x83\xA0\n\xE3\x81\xB8\r\n",        "bb\xE3\x83\x9B\r\n\xE3\x83\xBC\r\xE3\x83\xA0\n\xE3\x81\xB8\r\n",
308        ("bb\xE3\x83\x9B""bb\r\nbb""\xE3\x83\xBC""bb\rbb""\xE3\x83\xA0"        ("bb\xE3\x83\x9B""bb\r\nbb""\xE3\x83\xBC""bb\rbb""\xE3\x83\xA0"
309         "bb\nbb""\xE3\x81\xB8""bb\r\nbb") },         "bb\nbb""\xE3\x81\xB8""bb\r\nbb"),
310          9 },
311  #endif  #endif
312      { "", NULL, NULL, NULL, NULL }      { "", NULL, NULL, NULL, NULL, 0 }
313    };    };
314    
315  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 306  static void TestReplace() { Line 325  static void TestReplace() {
325      CHECK(re.Replace(t->rewrite, &one));      CHECK(re.Replace(t->rewrite, &one));
326      CHECK_EQ(one, t->single);      CHECK_EQ(one, t->single);
327      string all(t->original);      string all(t->original);
328      CHECK(re.GlobalReplace(t->rewrite, &all) > 0);      const int replace_count = re.GlobalReplace(t->rewrite, &all);
329      CHECK_EQ(all, t->global);      CHECK_EQ(all, t->global);
330        CHECK_EQ(replace_count, t->global_count);
331    }    }
332    
333    // One final test: test \r\n replacement when we're not in CRLF mode    // One final test: test \r\n replacement when we're not in CRLF mode
# Line 315  static void TestReplace() { Line 335  static void TestReplace() {
335      RE re("b*", RE_Options(PCRE_NEWLINE_CR).set_utf8(support_utf8));      RE re("b*", RE_Options(PCRE_NEWLINE_CR).set_utf8(support_utf8));
336      assert(re.error().empty());      assert(re.error().empty());
337      string all("aa\r\naa\r\n");      string all("aa\r\naa\r\n");
338      CHECK(re.GlobalReplace("bb", &all) > 0);      CHECK_EQ(re.GlobalReplace("bb", &all), 9);
339      CHECK_EQ(all, string("bbabbabb\rbb\nbbabbabb\rbb\nbb"));      CHECK_EQ(all, string("bbabbabb\rbb\nbbabbabb\rbb\nbb"));
340    }    }
341    {    {
342      RE re("b*", RE_Options(PCRE_NEWLINE_LF).set_utf8(support_utf8));      RE re("b*", RE_Options(PCRE_NEWLINE_LF).set_utf8(support_utf8));
343      assert(re.error().empty());      assert(re.error().empty());
344      string all("aa\r\naa\r\n");      string all("aa\r\naa\r\n");
345      CHECK(re.GlobalReplace("bb", &all) > 0);      CHECK_EQ(re.GlobalReplace("bb", &all), 9);
346      CHECK_EQ(all, string("bbabbabb\rbb\nbbabbabb\rbb\nbb"));      CHECK_EQ(all, string("bbabbabb\rbb\nbbabbabb\rbb\nbb"));
347    }    }
348    // TODO: test what happens when no PCRE_NEWLINE_* flag is set.    // TODO: test what happens when no PCRE_NEWLINE_* flag is set.
# Line 806  int main(int argc, char** argv) { Line 826  int main(int argc, char** argv) {
826    /***** FullMatch with no args *****/    /***** FullMatch with no args *****/
827    
828    CHECK(RE("h.*o").FullMatch("hello"));    CHECK(RE("h.*o").FullMatch("hello"));
829    CHECK(!RE("h.*o").FullMatch("othello"));    CHECK(!RE("h.*o").FullMatch("othello"));     // Must be anchored at front
830    CHECK(!RE("h.*o").FullMatch("hello!"));    CHECK(!RE("h.*o").FullMatch("hello!"));      // Must be anchored at end
831      CHECK(RE("a*").FullMatch("aaaa"));           // Fullmatch with normal op
832      CHECK(RE("a*?").FullMatch("aaaa"));          // Fullmatch with nongreedy op
833      CHECK(RE("a*?\\z").FullMatch("aaaa"));       // Two unusual ops
834    
835    /***** FullMatch with args *****/    /***** FullMatch with args *****/
836    
# Line 851  int main(int argc, char** argv) { Line 874  int main(int argc, char** argv) {
874    CHECK_EQ(s, string("ruby"));    CHECK_EQ(s, string("ruby"));
875    CHECK_EQ(i, 1234);    CHECK_EQ(i, 1234);
876    
877      // Ignore non-void* NULL arg
878      CHECK(RE("he(.*)lo").FullMatch("hello", (char*)NULL));
879      CHECK(RE("h(.*)o").FullMatch("hello", (string*)NULL));
880      CHECK(RE("h(.*)o").FullMatch("hello", (StringPiece*)NULL));
881      CHECK(RE("(.*)").FullMatch("1234", (int*)NULL));
882    #ifdef HAVE_LONG_LONG
883      CHECK(RE("(.*)").FullMatch("1234567890123456", (long long*)NULL));
884    #endif
885      CHECK(RE("(.*)").FullMatch("123.4567890123456", (double*)NULL));
886      CHECK(RE("(.*)").FullMatch("123.4567890123456", (float*)NULL));
887    
888      // Fail on non-void* NULL arg if the match doesn't parse for the given type.
889      CHECK(!RE("h(.*)lo").FullMatch("hello", &s, (char*)NULL));
890      CHECK(!RE("(.*)").FullMatch("hello", (int*)NULL));
891      CHECK(!RE("(.*)").FullMatch("1234567890123456", (int*)NULL));
892      CHECK(!RE("(.*)").FullMatch("hello", (double*)NULL));
893      CHECK(!RE("(.*)").FullMatch("hello", (float*)NULL));
894    
895    // Ignored arg    // Ignored arg
896    CHECK(RE("(\\w+)(:)(\\d+)").FullMatch("ruby:1234", &s, (void*)NULL, &i));    CHECK(RE("(\\w+)(:)(\\d+)").FullMatch("ruby:1234", &s, (void*)NULL, &i));
897    CHECK_EQ(s, string("ruby"));    CHECK_EQ(s, string("ruby"));
# Line 902  int main(int argc, char** argv) { Line 943  int main(int argc, char** argv) {
943      CHECK(!RE("(\\d+)").FullMatch("4294967296", &v));      CHECK(!RE("(\\d+)").FullMatch("4294967296", &v));
944    }    }
945  #ifdef HAVE_LONG_LONG  #ifdef HAVE_LONG_LONG
946    # if defined(__MINGW__) || defined(__MINGW32__)
947    #   define LLD "%I64d"
948    #   define LLU "%I64u"
949    # else
950    #   define LLD "%lld"
951    #   define LLU "%llu"
952    # endif
953    {    {
954      long long v;      long long v;
955      static const long long max_value = 0x7fffffffffffffffLL;      static const long long max_value = 0x7fffffffffffffffLL;
956      static const long long min_value = -max_value - 1;      static const long long min_value = -max_value - 1;
957      char buf[32];      char buf[32];  // definitely big enough for a long long
958    
959      CHECK(RE("(-?\\d+)").FullMatch("100", &v)); CHECK_EQ(v, 100);      CHECK(RE("(-?\\d+)").FullMatch("100", &v)); CHECK_EQ(v, 100);
960      CHECK(RE("(-?\\d+)").FullMatch("-100",&v)); CHECK_EQ(v, -100);      CHECK(RE("(-?\\d+)").FullMatch("-100",&v)); CHECK_EQ(v, -100);
961    
962      snprintf(buf, sizeof(buf), "%lld", max_value);      sprintf(buf, LLD, max_value);
963      CHECK(RE("(-?\\d+)").FullMatch(buf,&v)); CHECK_EQ(v, max_value);      CHECK(RE("(-?\\d+)").FullMatch(buf,&v)); CHECK_EQ(v, max_value);
964    
965      snprintf(buf, sizeof(buf), "%lld", min_value);      sprintf(buf, LLD, min_value);
966      CHECK(RE("(-?\\d+)").FullMatch(buf,&v)); CHECK_EQ(v, min_value);      CHECK(RE("(-?\\d+)").FullMatch(buf,&v)); CHECK_EQ(v, min_value);
967    
968      snprintf(buf, sizeof(buf), "%lld", max_value);      sprintf(buf, LLD, max_value);
969      assert(buf[strlen(buf)-1] != '9');      assert(buf[strlen(buf)-1] != '9');
970      buf[strlen(buf)-1]++;      buf[strlen(buf)-1]++;
971      CHECK(!RE("(-?\\d+)").FullMatch(buf, &v));      CHECK(!RE("(-?\\d+)").FullMatch(buf, &v));
972    
973      snprintf(buf, sizeof(buf), "%lld", min_value);      sprintf(buf, LLD, min_value);
974      assert(buf[strlen(buf)-1] != '9');      assert(buf[strlen(buf)-1] != '9');
975      buf[strlen(buf)-1]++;      buf[strlen(buf)-1]++;
976      CHECK(!RE("(-?\\d+)").FullMatch(buf, &v));      CHECK(!RE("(-?\\d+)").FullMatch(buf, &v));
# Line 933  int main(int argc, char** argv) { Line 981  int main(int argc, char** argv) {
981      unsigned long long v;      unsigned long long v;
982      long long v2;      long long v2;
983      static const unsigned long long max_value = 0xffffffffffffffffULL;      static const unsigned long long max_value = 0xffffffffffffffffULL;
984      char buf[32];      char buf[32];  // definitely big enough for a unsigned long long
985    
986      CHECK(RE("(-?\\d+)").FullMatch("100",&v)); CHECK_EQ(v, 100);      CHECK(RE("(-?\\d+)").FullMatch("100",&v)); CHECK_EQ(v, 100);
987      CHECK(RE("(-?\\d+)").FullMatch("-100",&v2)); CHECK_EQ(v2, -100);      CHECK(RE("(-?\\d+)").FullMatch("-100",&v2)); CHECK_EQ(v2, -100);
988    
989      snprintf(buf, sizeof(buf), "%llu", max_value);      sprintf(buf, LLU, max_value);
990      CHECK(RE("(-?\\d+)").FullMatch(buf,&v)); CHECK_EQ(v, max_value);      CHECK(RE("(-?\\d+)").FullMatch(buf,&v)); CHECK_EQ(v, max_value);
991    
992      assert(buf[strlen(buf)-1] != '9');      assert(buf[strlen(buf)-1] != '9');
# Line 1119  int main(int argc, char** argv) { Line 1167  int main(int argc, char** argv) {
1167      printf("Testing UTF-8 handling\n");      printf("Testing UTF-8 handling\n");
1168    
1169      // Three Japanese characters (nihongo)      // Three Japanese characters (nihongo)
1170      const char utf8_string[] = {      const unsigned char utf8_string[] = {
1171           0xe6, 0x97, 0xa5, // 65e5           0xe6, 0x97, 0xa5, // 65e5
1172           0xe6, 0x9c, 0xac, // 627c           0xe6, 0x9c, 0xac, // 627c
1173           0xe8, 0xaa, 0x9e, // 8a9e           0xe8, 0xaa, 0x9e, // 8a9e
1174           0           0
1175      };      };
1176      const char utf8_pattern[] = {      const unsigned char utf8_pattern[] = {
1177           '.',           '.',
1178           0xe6, 0x9c, 0xac, // 627c           0xe6, 0x9c, 0xac, // 627c
1179           '.',           '.',

Legend:
Removed from v.96  
changed lines
  Added in v.302

  ViewVC Help
Powered by ViewVC 1.1.5