/[pcre]/code/branches/pcre16/pcre_jit_test.c
ViewVC logotype

Diff of /code/branches/pcre16/pcre_jit_test.c

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

revision 797 by zherczeg, Sat Dec 10 10:08:40 2011 UTC revision 798 by zherczeg, Sun Dec 11 18:07:25 2011 UTC
# Line 290  static struct regression_test_case regre Line 290  static struct regression_test_case regre
290          { MUAP, 0, "\\b[^\xc2\xa1]+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },          { MUAP, 0, "\\b[^\xc2\xa1]+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },
291          { CMUA, 0, "[^b]+(a*)([^c]?d{3})", "aaaaddd" },          { CMUA, 0, "[^b]+(a*)([^c]?d{3})", "aaaaddd" },
292          { CMUAP, 0, "\xe1\xbd\xb8{2}", "\xe1\xbf\xb8#\xe1\xbf\xb8\xe1\xbd\xb8" },          { CMUAP, 0, "\xe1\xbd\xb8{2}", "\xe1\xbf\xb8#\xe1\xbf\xb8\xe1\xbd\xb8" },
293            { CMUA, 0, "[^\xf0\x90\x90\x80]{2,4}@", "\xf0\x90\x90\xa8\xf0\x90\x90\x80###\xf0\x90\x90\x80@@@" },
294            { CMUA, 0, "[^\xe1\xbd\xb8][^\xc3\xa9]", "\xe1\xbd\xb8\xe1\xbf\xb8\xc3\xa9\xc3\x89#" },
295            { MUA, 0, "[^\xe1\xbd\xb8][^\xc3\xa9]", "\xe1\xbd\xb8\xe1\xbf\xb8\xc3\xa9\xc3\x89#" },
296            { MUA, 0, "[^\xe1\xbd\xb8]{3,}?", "##\xe1\xbd\xb8#\xe1\xbd\xb8#\xc3\x89#\xe1\xbd\xb8" },
297    
298          /* Basic character sets. */          /* Basic character sets. */
299          { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },          { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },
# Line 626  static struct regression_test_case regre Line 630  static struct regression_test_case regre
630          { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\x9f\xbf\xed\xa0\x83" },          { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\x9f\xbf\xed\xa0\x83" },
631          { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\xb4\x80\xed\xb3\xb0" },          { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\xb4\x80\xed\xb3\xb0" },
632          { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xef\xbf\xbf]+[\x1-\xed\xb0\x80]+#", "\xed\xa0\x85\xc3\x81\xed\xa0\x85\xef\xbf\xb0\xc2\x85\xed\xa9\x89#" },          { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xef\xbf\xbf]+[\x1-\xed\xb0\x80]+#", "\xed\xa0\x85\xc3\x81\xed\xa0\x85\xef\xbf\xb0\xc2\x85\xed\xa9\x89#" },
633            { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80][\xed\xb0\x80]{2,}", "\xed\xa0\x80\xed\xb0\x80\xed\xa0\x80\xed\xb0\x80\xed\xb0\x80\xed\xb0\x80" },
634            { MA, 0 | F_FORCECONV, "[^\xed\xb0\x80]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
635            { MA, 0 | F_NO8 | F_FORCECONV, "[^\\x{dc00}]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
636    
637          /* Deep recursion. */          /* Deep recursion. */
638          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
# Line 736  static int regression_tests(void) Line 743  static int regression_tests(void)
743  {  {
744          struct regression_test_case *current = regression_test_cases;          struct regression_test_case *current = regression_test_cases;
745          const char *error;          const char *error;
746          int i, err_offs, is_succesful;          int i, err_offs, is_successful;
747          int total = 0;          int total = 0;
748          int succesful = 0;          int successful = 0;
749          int counter = 0;          int counter = 0;
750  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
751          pcre *re8;          pcre *re8;
# Line 889  static int regression_tests(void) Line 896  static int regression_tests(void)
896                  /* If F_DIFF is set, just run the test, but do not compare the results.                  /* If F_DIFF is set, just run the test, but do not compare the results.
897                  Segfaults can still be captured. */                  Segfaults can still be captured. */
898    
899                  is_succesful = 1;                  is_successful = 1;
900                  if (!(current->start_offset & F_DIFF)) {                  if (!(current->start_offset & F_DIFF)) {
901  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
902                          if (utf8 == utf16 && !(current->start_offset & F_FORCECONV)) {                          if (utf8 == utf16 && !(current->start_offset & F_FORCECONV)) {
# Line 898  static int regression_tests(void) Line 905  static int regression_tests(void)
905                                          printf("\n8 and 16 bit: Return value differs(%d:%d:%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n8 and 16 bit: Return value differs(%d:%d:%d:%d): [%d] '%s' @ '%s'\n",
906                                                  return_value8_1, return_value8_2, return_value16_1, return_value16_2,                                                  return_value8_1, return_value8_2, return_value16_1, return_value16_2,
907                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
908                                          is_succesful = 0;                                          is_successful = 0;
909                                  } else if (return_value8_1 >= 0) {                                  } else if (return_value8_1 >= 0) {
910                                          return_value8_1 *= 2;                                          return_value8_1 *= 2;
911                                          /* Transform back the results. */                                          /* Transform back the results. */
# Line 916  static int regression_tests(void) Line 923  static int regression_tests(void)
923                                                          printf("\n8 and 16 bit: Ovector[%d] value differs(%d:%d:%d:%d): [%d] '%s' @ '%s' \n",                                                          printf("\n8 and 16 bit: Ovector[%d] value differs(%d:%d:%d:%d): [%d] '%s' @ '%s' \n",
924                                                                  i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],                                                                  i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
925                                                                  total, current->pattern, current->input);                                                                  total, current->pattern, current->input);
926                                                          is_succesful = 0;                                                          is_successful = 0;
927                                                  }                                                  }
928                                  }                                  }
929                          } else {                          } else {
# Line 926  static int regression_tests(void) Line 933  static int regression_tests(void)
933                                  if (return_value8_1 != return_value8_2) {                                  if (return_value8_1 != return_value8_2) {
934                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
935                                                  return_value8_1, return_value8_2, total, current->pattern, current->input);                                                  return_value8_1, return_value8_2, total, current->pattern, current->input);
936                                          is_succesful = 0;                                          is_successful = 0;
937                                  } else if (return_value8_1 >= 0) {                                  } else if (return_value8_1 >= 0) {
938                                          return_value8_1 *= 2;                                          return_value8_1 *= 2;
939                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value8_1; ++i)
940                                                  if (ovector8_1[i] != ovector8_2[i]) {                                                  if (ovector8_1[i] != ovector8_2[i]) {
941                                                          printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",                                                          printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
942                                                                  i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);                                                                  i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
943                                                          is_succesful = 0;                                                          is_successful = 0;
944                                                  }                                                  }
945                                  }                                  }
946  #endif  #endif
# Line 942  static int regression_tests(void) Line 949  static int regression_tests(void)
949                                  if (return_value16_1 != return_value16_2) {                                  if (return_value16_1 != return_value16_2) {
950                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
951                                                  return_value16_1, return_value16_2, total, current->pattern, current->input);                                                  return_value16_1, return_value16_2, total, current->pattern, current->input);
952                                          is_succesful = 0;                                          is_successful = 0;
953                                  } else if (return_value16_1 >= 0) {                                  } else if (return_value16_1 >= 0) {
954                                          return_value16_1 *= 2;                                          return_value16_1 *= 2;
955                                          for (i = 0; i < return_value16_1; ++i)                                          for (i = 0; i < return_value16_1; ++i)
956                                                  if (ovector16_1[i] != ovector16_2[i]) {                                                  if (ovector16_1[i] != ovector16_2[i]) {
957                                                          printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",                                                          printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
958                                                                  i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);                                                                  i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
959                                                          is_succesful = 0;                                                          is_successful = 0;
960                                                  }                                                  }
961                                  }                                  }
962  #endif  #endif
# Line 959  static int regression_tests(void) Line 966  static int regression_tests(void)
966  #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */  #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */
967                  }                  }
968    
969                  if (is_succesful) {                  if (is_successful) {
970  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
971                          if (!(current->start_offset & F_NO8)) {                          if (!(current->start_offset & F_NO8)) {
972                                  if (return_value8_1 < 0 && !(current->start_offset & F_NOMATCH)) {                                  if (return_value8_1 < 0 && !(current->start_offset & F_NOMATCH)) {
973                                          printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",                                          printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
974                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
975                                          is_succesful = 0;                                          is_successful = 0;
976                                  }                                  }
977    
978                                  if (return_value8_1 >= 0 && (current->start_offset & F_NOMATCH)) {                                  if (return_value8_1 >= 0 && (current->start_offset & F_NOMATCH)) {
979                                          printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",                                          printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
980                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
981                                          is_succesful = 0;                                          is_successful = 0;
982                                  }                                  }
983                          }                          }
984  #endif  #endif
# Line 980  static int regression_tests(void) Line 987  static int regression_tests(void)
987                                  if (return_value16_1 < 0 && !(current->start_offset & F_NOMATCH)) {                                  if (return_value16_1 < 0 && !(current->start_offset & F_NOMATCH)) {
988                                          printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",                                          printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
989                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
990                                          is_succesful = 0;                                          is_successful = 0;
991                                  }                                  }
992    
993                                  if (return_value16_1 >= 0 && (current->start_offset & F_NOMATCH)) {                                  if (return_value16_1 >= 0 && (current->start_offset & F_NOMATCH)) {
994                                          printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",                                          printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
995                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
996                                          is_succesful = 0;                                          is_successful = 0;
997                                  }                                  }
998                          }                          }
999  #endif  #endif
1000                  }                  }
1001    
1002                  if (is_succesful)                  if (is_successful)
1003                          succesful++;                          successful++;
1004    
1005  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1006                  if (re8) {                  if (re8) {
# Line 1014  static int regression_tests(void) Line 1021  static int regression_tests(void)
1021                  current++;                  current++;
1022          }          }
1023    
1024          if (total == succesful) {          if (total == successful) {
1025                  printf("\nAll JIT regression tests are successfully passed.\n");                  printf("\nAll JIT regression tests are successfully passed.\n");
1026                  return 0;                  return 0;
1027          } else {          } else {
1028                  printf("\nSuccessful test ratio: %d%%\n", succesful * 100 / total);                  printf("\nSuccessful test ratio: %d%% (%d failed)\n", successful * 100 / total, total - successful);
1029                  return 1;                  return 1;
1030          }          }
1031  }  }

Legend:
Removed from v.797  
changed lines
  Added in v.798

  ViewVC Help
Powered by ViewVC 1.1.5