Mercurial > hg > xemacs-beta
annotate tests/automated/regexp-tests.el @ 4965:d79e9cc6aeca
Fix lots of ChangeLog duplication
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Mon, 01 Feb 2010 13:36:26 -0600 |
| parents | 6ef8256a020a |
| children | 0f66906b6e37 |
| rev | line source |
|---|---|
| 446 | 1 ;;; -*- coding: iso-8859-1 -*- |
| 2 | |
| 1612 | 3 ;; Copyright (C) 2000, 2002, 2003 Free Software Foundation, Inc. |
| 446 | 4 |
| 5 ;; Author: Yoshiki Hayashi <yoshiki@xemacs.org> | |
| 1612 | 6 ;; Maintainer: Stephen J. Turnbull <stephen@xemacs.org> |
| 446 | 7 ;; Created: 2000 |
| 8 ;; Keywords: tests | |
| 9 | |
| 10 ;; This file is part of XEmacs. | |
| 11 | |
| 12 ;; XEmacs is free software; you can redistribute it and/or modify it | |
| 13 ;; under the terms of the GNU General Public License as published by | |
| 14 ;; the Free Software Foundation; either version 2, or (at your option) | |
| 15 ;; any later version. | |
| 16 | |
| 17 ;; XEmacs is distributed in the hope that it will be useful, but | |
| 18 ;; WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 20 ;; General Public License for more details. | |
| 21 | |
| 22 ;; You should have received a copy of the GNU General Public License | |
| 23 ;; along with XEmacs; see the file COPYING. If not, write to the Free | |
| 24 ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA | |
| 25 ;; 02111-1307, USA. | |
| 26 | |
| 27 ;;; Synched up with: Not in FSF. | |
| 28 | |
| 29 ;;; Commentary: | |
| 30 | |
|
4897
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
31 ;; Test regular expressions. |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
32 |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4900
diff
changeset
|
33 ;; NOTE NOTE NOTE: There is some domain overlap among case-tests.el, |
|
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4900
diff
changeset
|
34 ;; regexp-tests.el and search-tests.el. See case-tests.el. |
| 446 | 35 |
| 36 (Check-Error-Message error "Trailing backslash" | |
| 37 (string-match "\\" "a")) | |
| 38 (Check-Error-Message error "Invalid preceding regular expression" | |
| 39 (string-match "a++" "a")) | |
| 40 (Check-Error-Message error "Invalid preceding regular expression" | |
| 41 (string-match "a**" "a")) | |
| 42 (Check-Error-Message error "Invalid preceding regular expression" | |
| 43 (string-match "a???" "a")) | |
| 44 (Check-Error-Message error "Unmatched \\[ or \\[^" | |
| 45 (string-match "[" "a")) | |
| 46 (Check-Error-Message error "Unmatched \\[ or \\[^" | |
| 47 (string-match "[abc" "a")) | |
| 48 (Check-Error-Message error "Unmatched ) or \\\\)" | |
| 49 (string-match "\\)" "a")) | |
| 50 (Check-Error-Message error "Invalid regular expression" | |
| 51 (string-match "\\(?.\\)" "a")) | |
| 52 (Check-Error-Message error "Unmatched \\\\{" | |
| 53 (string-match "a\\{" "a")) | |
| 54 (Check-Error-Message error "Invalid content of \\\\{\\\\}" | |
| 55 (string-match "a\\{a\\}" "a")) | |
| 56 | |
| 57 ;; exactn | |
| 58 | |
| 59 ;; string-match | |
| 60 (with-temp-buffer | |
| 61 ;; case-insensitive | |
| 62 (Assert (string-match "ä" "ä")) | |
| 63 (Assert (string-match "ä" "Ä")) | |
| 64 (Assert (string-match "Ä" "Ä")) | |
| 65 (Assert (string-match "Ä" "ä")) | |
| 66 ;; case-sensitive | |
| 67 (setq case-fold-search nil) | |
| 68 (Assert (string-match "ä" "ä")) | |
| 69 (Assert (not (string-match "ä" "Ä"))) | |
| 70 (Assert (string-match "Ä" "Ä")) | |
| 71 (Assert (not (string-match "Ä" "ä")))) | |
| 72 | |
| 73 ;; looking-at | |
| 74 (with-temp-buffer | |
| 75 (insert "äÄ") | |
| 76 ;; case-insensitive | |
| 77 (goto-char (point-min)) | |
| 78 (Assert (looking-at "ä")) | |
| 79 (Assert (looking-at "Ä")) | |
| 80 (forward-char) | |
| 81 (Assert (looking-at "ä")) | |
| 82 (Assert (looking-at "Ä")) | |
| 83 ;; case-sensitive | |
| 84 (setq case-fold-search nil) | |
| 85 (goto-char (point-min)) | |
| 86 (Assert (looking-at "ä")) | |
| 87 (Assert (not (looking-at "Ä"))) | |
| 88 (forward-char) | |
| 89 (Assert (not (looking-at "ä"))) | |
| 90 (Assert (looking-at "Ä"))) | |
| 91 | |
| 92 ;; re-search-forward and re-search-backward | |
| 93 (with-temp-buffer | |
| 94 (insert "äÄ") | |
| 95 ;; case insensitive | |
| 96 ;; forward | |
| 97 (goto-char (point-min)) | |
| 98 ;; Avoid trivial regexp. | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
99 (Assert-eq 2 (re-search-forward "ä\\|a" nil t)) |
| 446 | 100 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
101 (Assert-eq 2 (re-search-forward "Ä\\|a" nil t)) |
| 446 | 102 (goto-char (1+ (point-min))) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
103 (Assert-eq 3 (re-search-forward "ä\\|a" nil t)) |
| 446 | 104 (goto-char (1+ (point-min))) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
105 (Assert-eq 3 (re-search-forward "Ä\\|a" nil t)) |
| 446 | 106 ;; backward |
| 107 (goto-char (point-max)) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
108 (Assert-eq 2 (re-search-backward "ä\\|a" nil t)) |
| 446 | 109 (goto-char (point-max)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
110 (Assert-eq 2 (re-search-backward "Ä\\|a" nil t)) |
| 446 | 111 (goto-char (1- (point-max))) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
112 (Assert-eq 1 (re-search-backward "ä\\|a" nil t)) |
| 446 | 113 (goto-char (1- (point-max))) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
114 (Assert-eq 1 (re-search-backward "Ä\\|a" nil t)) |
| 446 | 115 ;; case sensitive |
| 116 (setq case-fold-search nil) | |
| 117 ;; forward | |
| 118 (goto-char (point-min)) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
119 (Assert-eq 2 (re-search-forward "ä\\|a" nil t)) |
| 446 | 120 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
121 (Assert-eq 3 (re-search-forward "Ä\\|a" nil t)) |
| 446 | 122 (goto-char (1+ (point-min))) |
| 123 (Assert (not (re-search-forward "ä\\|a" nil t))) | |
| 124 (goto-char (1+ (point-min))) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
125 (Assert-eq 3 (re-search-forward "Ä\\|a" nil t)) |
| 446 | 126 ;; backward |
| 127 (goto-char (point-max)) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
128 (Assert-eq 1 (re-search-backward "ä\\|a" nil t)) |
| 446 | 129 (goto-char (point-max)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
130 (Assert-eq 2 (re-search-backward "Ä\\|a" nil t)) |
| 446 | 131 (goto-char (1- (point-max))) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
132 (Assert-eq 1 (re-search-backward "ä\\|a" nil t)) |
| 446 | 133 (goto-char (1- (point-max))) |
| 134 (Assert (not (re-search-backward "Ä\\|a" nil t)))) | |
| 135 | |
| 136 ;; duplicate | |
| 137 (with-temp-buffer | |
| 138 ;; case insensitive | |
| 139 (Assert (string-match "^\\(ä\\)\\1$" "ää")) | |
| 140 (Assert (string-match "^\\(ä\\)\\1$" "äÄ")) | |
| 141 (Assert (string-match "^\\(ä\\)\\1$" "ÄÄ")) | |
| 142 (Assert (string-match "^\\(ä\\)\\1$" "Ää")) | |
| 143 (Assert (string-match "^\\(Ä\\)\\1$" "ää")) | |
| 144 (Assert (string-match "^\\(Ä\\)\\1$" "äÄ")) | |
| 145 (Assert (string-match "^\\(Ä\\)\\1$" "ÄÄ")) | |
| 146 (Assert (string-match "^\\(Ä\\)\\1$" "Ää")) | |
| 147 ;; case sensitive | |
| 148 (setq case-fold-search nil) | |
| 149 (Assert (string-match "^\\(ä\\)\\1$" "ää")) | |
| 150 (Assert (not (string-match "^\\(ä\\)\\1$" "äÄ"))) | |
| 151 (Assert (not (string-match "^\\(ä\\)\\1$" "ÄÄ"))) | |
| 152 (Assert (not (string-match "^\\(ä\\)\\1$" "Ää"))) | |
| 153 (Assert (not (string-match "^\\(Ä\\)\\1$" "ää"))) | |
| 154 (Assert (not (string-match "^\\(Ä\\)\\1$" "äÄ"))) | |
| 155 (Assert (string-match "^\\(Ä\\)\\1$" "ÄÄ")) | |
| 156 (Assert (not (string-match "^\\(Ä\\)\\1$" "Ää")))) | |
| 157 | |
| 1714 | 158 ;; multiple-match |
| 159 ;; Thanks to Manfred Bartz <MBartz@xix.com> | |
| 160 ;; c.e.x <vn4rkkm7ouf3b5@corp.supernews.com> | |
| 161 ;; #### Need to do repetitions of more complex regexps | |
| 162 ;; #### WASH ME! | |
| 163 (with-temp-buffer | |
| 164 (Assert (not (string-match "^a\\{4,4\\}$" "aaa"))) | |
| 165 (Assert (string-match "^a\\{4,4\\}$" "aaaa")) | |
| 166 (Assert (not (string-match "^a\\{4,4\\}$" "aaaaa"))) | |
| 167 (Assert (not (string-match "^[a]\\{4,4\\}$" "aaa"))) | |
| 168 (Assert (string-match "^[a]\\{4,4\\}$" "aaaa")) | |
| 169 (Assert (not (string-match "^[a]\\{4,4\\}$" "aaaaa"))) | |
| 170 (Assert (not (string-match "^\\(a\\)\\{4,4\\}$" "aaa"))) | |
| 171 (Assert (string-match "^\\(a\\)\\{4,4\\}$" "aaaa")) | |
| 172 (Assert (not (string-match "^\\(a\\)\\{4,4\\}$" "aaaaa"))) | |
| 173 ;; Use class because repetition of single char broken in 21.5.15 | |
| 174 (Assert (not (string-match "^[a]\\{3,5\\}$" "aa"))) | |
| 175 (Assert (string-match "^[a]\\{3,5\\}$" "aaa")) | |
| 176 (Assert (string-match "^[a]\\{3,5\\}$" "aaaa")) | |
| 177 (Assert (string-match "^[a]\\{3,5\\}$" "aaaaa")) | |
| 178 (Assert (not (string-match "^[a]\\{3,5\\}$" "aaaaaa"))) | |
| 179 (insert "\ | |
| 180 aa | |
| 181 aaa | |
| 182 aaaa | |
| 183 aaaaa | |
| 184 aaaaaa | |
| 185 baaaa | |
| 186 ") | |
| 187 (goto-char (point-min)) | |
| 188 (forward-line 1) | |
| 189 (Assert (not (looking-at "^a\\{4,4\\}$"))) | |
| 190 (forward-line 1) | |
| 191 (Assert (looking-at "^a\\{4,4\\}$")) | |
| 192 (forward-line 1) | |
| 193 (Assert (not (looking-at "^a\\{4,4\\}$"))) | |
| 194 (goto-char (point-min)) | |
| 195 (forward-line 1) | |
| 196 (Assert (not (looking-at "^[a]\\{4,4\\}$"))) | |
| 197 (forward-line 1) | |
| 198 (Assert (looking-at "^[a]\\{4,4\\}$")) | |
| 199 (forward-line 1) | |
| 200 (Assert (not (looking-at "^[a]\\{4,4\\}$"))) | |
| 201 (goto-char (point-min)) | |
| 202 (forward-line 1) | |
| 203 (Assert (not (looking-at "^\\(a\\)\\{4,4\\}$"))) | |
| 204 (forward-line 1) | |
| 205 (Assert (looking-at "^\\(a\\)\\{4,4\\}$")) | |
| 206 (forward-line 1) | |
| 207 (Assert (not (looking-at "^\\(a\\)\\{4,4\\}$"))) | |
| 208 ;; Use class because repetition of single char broken in 21.5.15 | |
| 209 (goto-char (point-min)) | |
| 210 (Assert (not (looking-at "^[a]\\{3,5\\}$"))) | |
| 211 (forward-line 1) | |
| 212 (Assert (looking-at "^[a]\\{3,5\\}$")) | |
| 213 (forward-line 1) | |
| 214 (Assert (looking-at "^[a]\\{3,5\\}$")) | |
| 215 (forward-line 1) | |
| 216 (Assert (looking-at "^[a]\\{3,5\\}$")) | |
| 217 (forward-line 1) | |
| 218 (Assert (not (looking-at "^[a]\\{3,5\\}$"))) | |
| 219 (goto-char (point-min)) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
220 (Assert= 12 (re-search-forward "a\\{4,4\\}")) |
| 1714 | 221 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
222 (Assert= 12 (re-search-forward "b?a\\{4,4\\}")) |
| 1714 | 223 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
224 (Assert= 31 (re-search-forward "ba\\{4,4\\}")) |
| 1714 | 225 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
226 (Assert= 31 (re-search-forward "[b]a\\{4,4\\}")) |
| 1714 | 227 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
228 (Assert= 31 (re-search-forward "\\(b\\)a\\{4,4\\}")) |
| 1714 | 229 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
230 (Assert= 12 (re-search-forward "^a\\{4,4\\}")) |
| 1714 | 231 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
232 (Assert= 12 (re-search-forward "^a\\{4,4\\}$")) |
| 1714 | 233 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
234 (Assert= 12 (re-search-forward "[a]\\{4,4\\}")) |
| 1714 | 235 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
236 (Assert= 12 (re-search-forward "^[a]\\{4,4\\}")) |
| 1714 | 237 (goto-char (point-min)) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
238 (Assert= 12 (re-search-forward "^[a]\\{4,4\\}$")) |
| 1714 | 239 ) |
| 240 | |
| 446 | 241 ;; charset, charset_not |
| 242 ;; Not called because it takes too much time. | |
| 243 (defun test-regexp-charset-paranoid () | |
| 244 (let ((i 0) | |
| 245 (max (expt 2 (if (featurep 'mule) 19 8))) | |
| 246 (range "[a-z]") | |
| 247 (range-not "[^a-z]") | |
| 248 char string) | |
| 249 (while (< i max) | |
| 250 (when (setq char (int-to-char i)) | |
| 251 (setq string (char-to-string char)) | |
| 252 (if (or (and (<= 65 i) | |
| 253 (<= i 90)) | |
| 254 (and (<= 97 i) | |
| 255 (<= i 122))) | |
| 256 (progn | |
| 257 (Assert (string-match range string)) | |
| 258 (Assert (not (string-match range-not string)))) | |
| 259 (Assert (not (string-match range string))) | |
| 260 (Assert (string-match range-not string)))) | |
| 261 (setq i (1+ i))))) | |
| 262 | |
| 263 ;; (test-regexp-charset-paranoid) | |
| 264 | |
| 265 ;; charset_mule, charset_mule_not | |
| 266 ;; Not called because it takes too much time. | |
| 267 (defun test-regex-charset-mule-paranoid () | |
| 268 (if (featurep 'mule) | |
| 269 (let ((i 0) | |
| 270 (max (expt 2 19)) | |
| 271 (range (format "[%c-%c]" | |
| 272 (make-char 'japanese-jisx0208 36 34) | |
| 273 (make-char 'japanese-jisx0208 36 42))) | |
| 274 (range-not (format "[^%c-%c]" | |
| 275 (make-char 'japanese-jisx0208 36 34) | |
| 276 (make-char 'japanese-jisx0208 36 42))) | |
| 277 (min-int (char-to-int (make-char 'japanese-jisx0208 36 34))) | |
| 278 (max-int (char-to-int (make-char 'japanese-jisx0208 36 42))) | |
| 279 char string) | |
| 280 (while (< i max) | |
| 281 (when (setq char (int-to-char i)) | |
| 282 (setq string (char-to-string char)) | |
| 283 (if (and (<= min-int i) | |
| 284 (<= i max-int)) | |
| 285 (progn | |
| 286 (Assert (string-match range string)) | |
| 287 (Assert (not (string-match range-not string)))) | |
| 288 (Assert (not (string-match range string))) | |
| 289 (Assert (string-match range-not string)))) | |
| 290 (setq i (1+ i)))))) | |
| 291 | |
| 292 ;; (test-regex-charset-mule-paranoid) | |
| 448 | 293 |
| 1472 | 294 ;; Test that replace-match does not clobber registers after a failed match |
| 448 | 295 (with-temp-buffer |
| 296 (insert "This is a test buffer.") | |
| 297 (goto-char (point-min)) | |
| 298 (search-forward "this is a test ") | |
| 299 (looking-at "Unmatchable text") | |
| 1472 | 300 (replace-match "") |
| 301 (Assert (looking-at "^buffer.$"))) | |
| 1024 | 302 |
| 303 ;; Test that trivial regexps reset unused registers | |
| 304 ;; Thanks to Martin Sternholm for the report. | |
| 305 ;; xemacs-beta <5blm6h2ki5.fsf@lister.roxen.com> | |
| 306 (with-temp-buffer | |
| 307 (insert "ab") | |
| 308 (goto-char (point-min)) | |
| 309 (re-search-forward "\\(a\\)") | |
| 1175 | 310 ;; test the whole-match data, too -- one attempted fix scotched that, too! |
| 1024 | 311 (Assert (string= (match-string 0) "a")) |
| 312 (Assert (string= (match-string 1) "a")) | |
| 313 (re-search-forward "b") | |
| 314 (Assert (string= (match-string 0) "b")) | |
| 315 (Assert (string= (match-string 1) nil))) | |
| 316 | |
| 317 ;; Test word boundaries | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
318 (Assert= (string-match "\\<a" " a") 1) |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
319 (Assert= (string-match "a\\>" "a ") 0) |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
320 (Assert= (string-match "\\ba" " a") 1) |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
321 (Assert= (string-match "a\\b" "a ") 0) |
| 1024 | 322 ;; should work at target boundaries |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
323 (Assert= (string-match "\\<a" "a") 0) |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
324 (Assert= (string-match "a\\>" "a") 0) |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
325 (Assert= (string-match "\\ba" "a") 0) |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
326 (Assert= (string-match "a\\b" "a") 0) |
| 1095 | 327 ;; Check for weirdness |
| 328 (Assert (not (string-match " \\> " " "))) | |
| 329 (Assert (not (string-match " \\< " " "))) | |
| 330 (Assert (not (string-match " \\b " " "))) | |
| 1024 | 331 ;; but not if the "word" would be on the null side of the boundary! |
| 332 (Assert (not (string-match "\\<" ""))) | |
| 333 (Assert (not (string-match "\\>" ""))) | |
| 334 (Assert (not (string-match " \\<" " "))) | |
| 335 (Assert (not (string-match "\\> " " "))) | |
| 336 (Assert (not (string-match "a\\<" "a"))) | |
| 337 (Assert (not (string-match "\\>a" "a"))) | |
| 1389 | 338 ;; Added Known-Bug 2002-09-09 sjt |
| 339 ;; Fixed bug 2003-03-21 sjt | |
| 340 (Assert (not (string-match "\\b" ""))) | |
| 341 (Assert (not (string-match "\\b" " "))) | |
| 342 (Assert (not (string-match " \\b" " "))) | |
| 343 (Assert (not (string-match "\\b " " "))) | |
| 1175 | 344 |
| 345 ;; Character classes are broken in Mule as of 21.5.9 | |
| 346 ;; Added Known-Bug 2002-12-27 | |
| 1413 | 347 ;; Fixed by Daiki Ueno 2003-03-24 |
| 1175 | 348 (if (featurep 'mule) |
| 349 ;; note: (int-to-char 65) => ?A | |
| 350 (let ((ch0 (make-char 'japanese-jisx0208 52 65)) | |
| 351 (ch1 (make-char 'japanese-jisx0208 51 65))) | |
| 352 (Assert (not (string-match "A" (string ch0)))) | |
| 353 (Assert (not (string-match "[A]" (string ch0)))) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
354 (Assert-eq (string-match "[^A]" (string ch0)) 0) |
| 1175 | 355 (Assert (not (string-match "@A" (string ?@ ch0)))) |
| 1413 | 356 (Assert (not (string-match "@[A]" (string ?@ ch0)))) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
357 (Assert-eq (string-match "@[^A]" (string ?@ ch0)) 0) |
| 1175 | 358 (Assert (not (string-match "@?A" (string ?@ ch0)))) |
| 359 (Assert (not (string-match "A" (string ch1)))) | |
| 360 (Assert (not (string-match "[A]" (string ch1)))) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
361 (Assert-eq (string-match "[^A]" (string ch1)) 0) |
| 1175 | 362 (Assert (not (string-match "@A" (string ?@ ch1)))) |
| 363 (Assert (not (string-match "@[A]" (string ?@ ch1)))) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
364 (Assert-eq (string-match "@[^A]" (string ?@ ch1)) 0) |
| 1413 | 365 (Assert (not (string-match "@?A" (string ?@ ch1)))) |
| 366 ) | |
| 367 ) | |
| 1195 | 368 |
| 369 ;; More stale match data tests. | |
| 370 ;; Thanks to <bjacob@ca.metsci.com>. | |
| 1425 | 371 ;; These tests used to fail because we cleared match data only on success. |
| 372 ;; Fixed 2003-04-17. | |
| 1612 | 373 ;; Must change sense of failing tests 2003-05-09. Too much code depends on |
| 374 ;; failed matches preserving match-data. | |
| 1472 | 375 (let ((a "a")) |
| 376 (Assert (string= (progn (string-match "a" a) | |
| 377 (string-match "b" a) | |
| 378 (match-string 0 a)) | |
| 379 a)) | |
| 380 (Assert (not (progn (string-match "a" a) | |
| 381 (string-match "b" a) | |
| 382 (match-string 1 a)))) | |
| 383 ;; test both for the second match is a plain string match and a regexp match | |
| 384 (Assert (string= (progn (string-match "\\(a\\)" a) | |
| 385 (string-match "\\(b\\)" a) | |
| 386 (match-string 0 a)) | |
| 387 a)) | |
| 388 (Assert (string= (progn (string-match "\\(a\\)" a) | |
| 389 (string-match "b" a) | |
| 390 (match-string 0 a)) | |
| 391 a)) | |
| 392 (Assert (string= (progn (string-match "\\(a\\)" a) | |
| 393 (string-match "\\(b\\)" a) | |
| 394 (match-string 1 a)) | |
| 395 a)) | |
| 396 (Assert (string= (progn (string-match "\\(a\\)" a) | |
| 397 (string-match "b" a) | |
| 398 (match-string 1 a)) | |
| 2542 | 399 a)) |
| 400 ;; in 21.4.16, registers from num_shy_groups to num_groups were not cleared, | |
| 401 ;; resulting in stale match data | |
| 402 (Assert (progn (string-match "\\(a\\)" a) | |
| 403 (string-match "\\(?:a\\)" a) | |
| 404 (not (match-beginning 1)))) | |
| 405 ) | |
| 2254 | 406 |
| 407 ;; bug identified by Katsumi Yamaoka 2004-09-03 <b9ywtzbbpue.fsf_-_@jpl.org> | |
| 408 ;; fix submitted by sjt 2004-09-08 | |
| 409 ;; trailing comments are values from buggy 21.4.15 | |
| 410 (let ((text "abc")) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
411 (Assert-eq 0 (string-match "\\(?:ab+\\)*c" text)) ; 2 |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
412 (Assert-eq 0 (string-match "^\\(?:ab+\\)*c" text)) ; nil |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
413 (Assert-eq 0 (string-match "^\\(?:ab+\\)*" text)) ; 0 |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
414 (Assert-eq 0 (string-match "^\\(?:ab+\\)c" text)) ; 0 |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
415 (Assert-eq 0 (string-match "^\\(?:ab\\)*c" text)) ; 0 |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
416 (Assert-eq 0 (string-match "^\\(?:a+\\)*b" text)) ; nil |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
417 (Assert-eq 0 (string-match "^\\(?:a\\)*b" text)) ; 0 |
| 2254 | 418 ) |
| 419 | |
| 2324 | 420 ;; per Steve Youngs 2004-09-30 <microsoft-free.87ekkjhj7t.fsf@youngs.au.com> |
| 421 ;; fix submitted by sjt 2004-10-07 | |
| 422 ;; trailing comments are values from buggy 21.4.pre16 | |
| 423 (let ((text "abc")) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
424 (Assert-eq 0 (string-match "\\(?:a\\(b\\)\\)" text)) ; 0 |
| 2324 | 425 (Assert (string= (match-string 1 text) "b")) ; ab |
| 426 (Assert (null (match-string 2 text))) ; b | |
| 427 (Assert (null (match-string 3 text))) ; nil | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
428 (Assert-eq 0 (string-match "\\(?:a\\(?:b\\(c\\)\\)\\)" text)) ; 0 |
| 2324 | 429 (Assert (string= (match-string 1 text) "c")) ; abc |
| 430 (Assert (null (match-string 2 text))) ; ab | |
| 431 (Assert (null (match-string 3 text))) ; c | |
| 432 (Assert (null (match-string 4 text))) ; nil | |
| 433 ) | |
| 434 | |
| 2542 | 435 ;; trivial subpatterns and backreferences with shy groups |
| 436 (let ((text1 "abb") | |
| 437 (text2 "aba") | |
| 438 (re0 "\\(a\\)\\(b\\)\\2") | |
| 439 (re1 "\\(?:a\\)\\(b\\)\\2") | |
| 440 (re2 "\\(?:a\\)\\(b\\)\\1") | |
| 441 (re3 "\\(a\\)\\(?:b\\)\\1")) | |
| 442 | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
443 (Assert-eq 0 (string-match re0 text1)) |
| 2542 | 444 (Assert (string= text1 (match-string 0 text1))) |
| 445 (Assert (string= "a" (match-string 1 text1))) | |
| 446 (Assert (string= "b" (match-string 2 text1))) | |
| 447 (Assert (null (string-match re0 text2))) | |
| 448 | |
| 449 (Check-Error-Message 'invalid-regexp "Invalid back reference" | |
| 450 (string-match re1 text1)) | |
| 451 | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
452 (Assert-eq 0 (string-match re2 text1)) |
| 2542 | 453 (Assert (string= text1 (match-string 0 text1))) |
| 454 (Assert (string= "b" (match-string 1 text1))) | |
| 455 (Assert (null (match-string 2 text1))) | |
| 456 (Assert (null (string-match re2 text2))) | |
| 457 | |
| 458 (Assert (null (string-match re3 text1))) | |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
459 (Assert-eq 0 (string-match re3 text2)) |
| 2542 | 460 (Assert (string= text2 (match-string 0 text2))) |
| 461 (Assert (string= "a" (match-string 1 text2))) | |
| 462 (Assert (null (match-string 2 text2))) | |
| 463 ) | |
| 464 | |
| 4199 | 465 ;; replace-regexp-in-string (regexp rep source |
| 466 ;; fixedcase literal buf-or-subexp start) | |
| 467 | |
| 468 ;; Currently we test the following cases: | |
| 469 ;; where `cbuf' and `bar-or-empty' are bound below. | |
| 470 | |
| 471 ;; #### Tests for the various functional features (fixedcase, literal, start) | |
| 472 ;; should be added. | |
| 473 | |
| 474 (with-temp-buffer | |
| 475 (flet ((bar-or-empty (subexp) (if (string= subexp "foo") "bar" ""))) | |
| 476 (let ((cbuf (current-buffer))) | |
| 477 (dolist (test-case | |
| 478 ;; REP BUF-OR-SUBEXP EXPECTED RESULT | |
| 479 `(("bar" nil " bar") | |
| 480 ("bar" ,cbuf " bar") | |
| 481 ("bar" 0 " bar") | |
| 482 ("bar" 1 " bar foo") | |
| 483 (bar-or-empty nil " ") | |
| 484 (bar-or-empty ,cbuf " ") | |
| 485 (bar-or-empty 0 " ") | |
| 486 (bar-or-empty 1 " bar foo"))) | |
| 487 (Assert | |
| 488 (string= | |
| 489 (nth 2 test-case) | |
| 490 (replace-regexp-in-string "\\(foo\\).*\\'" (nth 0 test-case) | |
| 491 " foo foo" nil nil (nth 1 test-case))))) | |
| 492 ;; #### Why doesn't this loop work right? | |
| 493 ; (dolist (test-case | |
| 494 ; ;; REP BUF-OR-SUBEXP EXPECTED ERROR EXPECTED MESSAGE | |
| 495 ; `(;; expected message was "bufferp, symbol" up to 21.5.28 | |
| 496 ; ("bar" 'symbol wrong-type-argument "integerp, symbol") | |
| 497 ; ("bar" -1 invalid-argument | |
| 498 ; "match data register invalid, -1") | |
| 499 ; ("bar" 2 invalid-argument | |
| 500 ; "match data register not set, 2") | |
| 501 ; )) | |
| 502 ; (eval | |
| 503 ; `(Check-Error-Message ,(nth 2 test-case) ,(nth 3 test-case) | |
| 504 ; (replace-regexp-in-string "\\(foo\\).*\\'" ,(nth 0 test-case) | |
| 505 ; " foo foo" nil nil ,(nth 1 test-case))))) | |
| 506 ;; #### Can't test the message with w-t-a, see test-harness.el. | |
| 507 (Check-Error wrong-type-argument | |
| 508 (replace-regexp-in-string "\\(foo\\).*\\'" | |
| 509 "bar" | |
| 510 " foo foo" nil nil | |
| 511 'symbol)) | |
| 512 ;; #### Can't test the FROB (-1), see test-harness.el. | |
| 513 (Check-Error-Message invalid-argument | |
| 514 "match data register invalid" | |
| 515 (replace-regexp-in-string "\\(foo\\).*\\'" | |
| 516 "bar" | |
| 517 " foo foo" nil nil | |
| 518 -1)) | |
| 519 ;; #### Can't test the FROB (-1), see test-harness.el. | |
| 520 (Check-Error-Message invalid-argument | |
| 521 "match data register not set" | |
| 522 (replace-regexp-in-string "\\(foo\\).*\\'" | |
| 523 "bar" | |
| 524 " foo foo" nil nil | |
| 525 2)) | |
| 526 ))) | |
| 527 | |
|
4504
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
528 ;; Not very comprehensive tests of skip-chars-forward, skip-chars-background: |
|
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
529 |
|
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
530 (with-string-as-buffer-contents |
|
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
531 "-]-----------------------------][]]------------------------" |
|
4517
5e8f6469169f
Fix up initial condition for skip-chars test.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4504
diff
changeset
|
532 (goto-char (point-min)) |
|
4504
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
533 (skip-chars-forward (skip-chars-quote "-[]")) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
534 (Assert= (point) (point-max)) |
|
4504
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
535 (skip-chars-backward (skip-chars-quote "-[]")) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
536 (Assert= (point) (point-min)) |
|
4504
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
537 ;; Testing in passing for an old bug in #'skip-chars-forward where I |
|
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
538 ;; thought it was impossible to call it with a string containing only ?- |
|
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
539 ;; and ?]: |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
540 (Assert= (skip-chars-forward (skip-chars-quote "-]")) |
|
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
541 (position ?[ (buffer-string) :test #'=)) |
|
4504
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
542 ;; This used to error, incorrectly: |
|
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
543 (Assert (skip-chars-quote "[-"))) |
|
b82fdf7305ee
Correct the implementation, add a few basic tests for #'skip-chars-quote.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4199
diff
changeset
|
544 |
| 4199 | 545 ;; replace-match (REPLACEMENT &optional FIXEDCASE LITERAL STRING STRBUFFER) |
| 546 | |
| 547 ;; #### Write some tests! Much functionality is implicitly tested above | |
| 548 ;; via `replace-regexp-in-string', but we should specifically test bogus | |
| 549 ;; combinations of STRING and STRBUFFER. | |
| 550 | |
|
4518
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
551 ;; empty string at point |
|
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
552 ;; Thanks Julian Bradford on XEmacs Beta |
|
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
553 ;; <18652.54975.894512.880956@krk.inf.ed.ac.uk> |
|
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
554 (with-string-as-buffer-contents "aáa" |
|
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
555 (goto-char (point-min)) |
|
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
556 (Assert (looking-at "\\=")) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
557 (Assert= (re-search-forward "\\=") 1) |
|
4518
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
558 (forward-char 1) |
|
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
559 (Assert (looking-at "\\=")) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
560 (Assert= (re-search-forward "\\=") 2) |
|
4518
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
561 (forward-char 1) |
|
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
562 (Assert (looking-at "\\=")) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
563 (Assert= (re-search-forward "\\=") 3) |
|
4518
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
564 (forward-char 1) |
|
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
565 (Assert (looking-at "\\=")) |
|
4855
189fb67ca31a
Create Assert-eq, Assert-equal, etc.
Ben Wing <ben@xemacs.org>
parents:
4518
diff
changeset
|
566 (Assert= (re-search-forward "\\=") 4)) |
|
4518
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
567 |
|
e0a8c796f955
Add test for at_dot regexp.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4517
diff
changeset
|
568 |
|
4897
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
569 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
570 ;; Tests involving case-changing replace-match ;; |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
571 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
572 |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
573 (Assert (not (string-match "\\(\\.\\=\\)" "."))) |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
574 (Assert (string= "" (let ((str "test string")) |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
575 (if (string-match "^.*$" str) |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
576 (replace-match "\\U" t nil str))))) |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
577 (with-temp-buffer |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
578 (erase-buffer) |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
579 (insert "test string") |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
580 (re-search-backward "^.*$") |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
581 (replace-match "\\U" t) |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
582 (Assert (and (bobp) (eobp)))) |
|
91a023144e72
fix longstanding search bug involving searching for Control-1 chars
Ben Wing <ben@xemacs.org>
parents:
4855
diff
changeset
|
583 |
|
4900
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
584 ;; Control-1 characters were second-class citizens in regexp ranges |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
585 ;; for a while there. Addressed in Ben's Mercurial changeset |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
586 ;; 2e15c29cc2b3; attempt to ensure this doesn't happen again. |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
587 (Assert-eql (string-match "[\x00-\x7f\x80-\x9f]" "a") 0) |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
588 (Assert-eql (string-match "[\x00-\x7f\x80-\x9f]" "é") nil) |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
589 ;; Gave nil in 21.5 for a couple of years. |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
590 (Assert-eql (string-match "[\x00-\x7f\x80-\x9f]" "\x80") 0) |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
591 (Assert-eql (string-match "[\x00-\x7f]\\|[\x80-\x9f]" "\x80") 0) |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
592 ;; Gave nil |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
593 (Assert-eql (string-match "[\x7f\x80-\x9f]" "\x80") 0) |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
594 (Assert-eql (string-match "[\x80-\x9f]" "\x80") 0) |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
595 (Assert-eql (string-match "[\x7f\x80-\x9e]" "\x80") 0) |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
596 ;; Used to succeed even with the bug. |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
597 (Assert-eql (string-match "[\x7f\x80\x9f]" "\x80") 0) |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
598 (Assert-eql (string-match "[\x7e\x80-\x9f]" "\x80") 0) |
|
0eccfd4850d6
Add tests for the regexp-ranges-treat-control-1-chars badly bug.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4897
diff
changeset
|
599 (Assert-eql (string-match "[\x7f\x81-\x9f]" "\x81") 0) |