104494
|
1 ;;; semantic-utest.el --- Tests for semantic's parsing system.
|
|
2
|
|
3 ;;; Copyright (C) 2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
|
|
4
|
|
5 ;; Author: Eric M. Ludlam <zappo@gnu.org>
|
|
6
|
|
7 ;; This file is part of GNU Emacs.
|
|
8
|
|
9 ;; GNU Emacs is free software: you can redistribute it and/or modify
|
|
10 ;; it under the terms of the GNU General Public License as published by
|
|
11 ;; the Free Software Foundation, either version 3 of the License, or
|
|
12 ;; (at your option) any later version.
|
|
13
|
|
14 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
17 ;; GNU General Public License for more details.
|
|
18
|
|
19 ;; You should have received a copy of the GNU General Public License
|
|
20 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
|
|
21
|
|
22 ;;; Commentary:
|
|
23 ;;
|
|
24 ;; Semantic's parsing and partial parsing system is pretty complex.
|
|
25 ;; These unit tests attempt to emulate semantic's partial reparsing
|
|
26 ;; and full reparsing system, and anything else I may feel the urge
|
|
27 ;; to write a test for.
|
|
28
|
|
29 (require 'semantic)
|
|
30
|
|
31 (load-file "cedet-utests.el")
|
|
32
|
|
33 (defvar semantic-utest-temp-directory (if (fboundp 'temp-directory)
|
|
34 (temp-directory)
|
|
35 temporary-file-directory)
|
|
36 "Temporary directory to use when creating files.")
|
|
37
|
|
38 (defun semantic-utest-fname (name)
|
|
39 "Create a filename for NAME in /tmp."
|
|
40 (expand-file-name name semantic-utest-temp-directory))
|
|
41
|
|
42 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
43 ;; Data for C tests
|
|
44
|
|
45 (defvar semantic-utest-C-buffer-contents
|
|
46 "/* Test file for C language for Unit Tests */
|
|
47
|
|
48 #include <stdio.h>
|
|
49 #include \"sutest.h\"
|
|
50
|
|
51 struct mystruct1 {
|
|
52 int slot11;
|
|
53 char slot12;
|
|
54 float slot13;
|
|
55 };
|
|
56
|
|
57 int var1;
|
|
58
|
|
59 float funp1(char arg11, char arg12);
|
|
60
|
|
61 char fun2(int arg_21, int arg_22) /*1*/
|
|
62 {
|
|
63 struct mystruct1 *ms1 = malloc(sizeof(struct mystruct1));
|
|
64
|
|
65 char sv = calc_sv(var1);
|
|
66
|
|
67 if (var1 == 0) {
|
|
68 sv = 1;
|
|
69 } else if (arg_21 == 0) {
|
|
70 sv = 2;
|
|
71 } else if (arg_22 == 0) {
|
|
72 sv = 3;
|
|
73 } else {
|
|
74 sv = 4;
|
|
75 }
|
|
76
|
|
77 printf(\"SV = %d\\n\", sv);
|
|
78
|
|
79 /* Memory Leak */
|
|
80 ms1.slot1 = sv;
|
|
81
|
|
82 return 'A' + sv;
|
|
83 }
|
|
84 "
|
|
85 "Contents of a C buffer initialized by this unit test.
|
|
86 Be sure to change `semantic-utest-C-name-contents' when you
|
|
87 change this variable.")
|
|
88
|
|
89 (defvar semantic-utest-C-h-buffer-contents
|
|
90 "/* Test file for C language header file for Unit Tests */
|
|
91
|
|
92 int calc_sv(int);
|
|
93
|
|
94 "
|
|
95 "Contents of a C header file buffer initialized by this unit test.")
|
|
96
|
|
97 (defvar semantic-utest-C-filename (semantic-utest-fname "sutest.c")
|
|
98 "File to open and erase during this test for C.")
|
|
99
|
|
100 (defvar semantic-utest-C-filename-h
|
|
101 (concat (file-name-sans-extension semantic-utest-C-filename)
|
|
102 ".h")
|
|
103 "Header file filename for C")
|
|
104
|
|
105
|
|
106 (defvar semantic-utest-C-name-contents
|
|
107 '(("stdio.h" include
|
|
108 (:system-flag t)
|
|
109 nil (overlay 48 66 "sutest.c"))
|
|
110 ("sutest.h" include nil nil (overlay 67 86 "sutest.c"))
|
|
111 ("mystruct1" type
|
|
112 (:members
|
|
113 (("slot11" variable
|
|
114 (:type "int")
|
|
115 (reparse-symbol classsubparts)
|
|
116 (overlay 109 120 "sutest.c"))
|
|
117 ("slot12" variable
|
|
118 (:type "char")
|
|
119 (reparse-symbol classsubparts)
|
|
120 (overlay 123 135 "sutest.c"))
|
|
121 ("slot13" variable
|
|
122 (:type "float")
|
|
123 (reparse-symbol classsubparts)
|
|
124 (overlay 138 151 "sutest.c")))
|
|
125 :type "struct")
|
|
126 nil (overlay 88 154 "sutest.c"))
|
|
127 ("var1" variable
|
|
128 (:type "int")
|
|
129 nil (overlay 156 165 "sutest.c"))
|
|
130 ("funp1" function
|
|
131 (:prototype-flag t :arguments
|
|
132 (("arg11" variable
|
|
133 (:type "char")
|
|
134 (reparse-symbol arg-sub-list)
|
|
135 (overlay 179 190 "sutest.c"))
|
|
136 ("arg12" variable
|
|
137 (:type "char")
|
|
138 (reparse-symbol arg-sub-list)
|
|
139 (overlay 191 202 "sutest.c")))
|
|
140 :type "float")
|
|
141 nil (overlay 167 203 "sutest.c"))
|
|
142 ("fun2" function
|
|
143 (:arguments
|
|
144 (("arg_21" variable
|
|
145 (:type "int")
|
|
146 (reparse-symbol arg-sub-list)
|
|
147 (overlay 215 226 "sutest.c"))
|
|
148 ("arg_22" variable
|
|
149 (:type "int")
|
|
150 (reparse-symbol arg-sub-list)
|
|
151 (overlay 227 238 "sutest.c")))
|
|
152 :type "char")
|
|
153 nil (overlay 205 566 "sutest.c")))
|
|
154 "List of expected tag names for C.")
|
|
155
|
|
156
|
|
157 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
158 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
159 ;; Data for Python tests
|
|
160
|
|
161 (defvar semantic-utest-Python-buffer-contents
|
|
162 "
|
|
163 def fun1(a,b,c):
|
|
164 return a
|
|
165
|
|
166 def fun2(a,b,c): #1
|
|
167 return b
|
|
168
|
|
169 "
|
|
170
|
|
171
|
|
172 )
|
|
173 ; "pyhon test case. notice that python is indentation sensitive
|
|
174
|
|
175
|
|
176 (defvar semantic-utest-Python-name-contents
|
|
177 '(("fun1" function
|
|
178 (:arguments
|
|
179 (("a" variable nil
|
|
180 (reparse-symbol function_parameters)
|
|
181 (overlay 10 11 "tst.py"))
|
|
182 ("b" variable nil
|
|
183 (reparse-symbol function_parameters)
|
|
184 (overlay 12 13 "tst.py"))
|
|
185 ("c" variable nil
|
|
186 (reparse-symbol function_parameters)
|
|
187 (overlay 14 15 "tst.py"))))
|
|
188 nil (overlay 1 31 "tst.py"))
|
|
189 ("fun2" function
|
|
190 (:arguments
|
|
191 (("a" variable nil
|
|
192 (reparse-symbol function_parameters)
|
|
193 (overlay 41 42 "tst.py"))
|
|
194 ("b" variable nil
|
|
195 (reparse-symbol function_parameters)
|
|
196 (overlay 43 44 "tst.py"))
|
|
197 ("c" variable nil
|
|
198 (reparse-symbol function_parameters)
|
|
199 (overlay 45 46 "tst.py"))))
|
|
200 nil (overlay 32 65 "tst.py")))
|
|
201
|
|
202 "List of expected tag names for Python.")
|
|
203
|
|
204
|
|
205
|
|
206 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
207 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
208 ;; Data for Java tests
|
|
209
|
|
210 (defvar semantic-utest-Java-buffer-contents
|
|
211 "
|
|
212 class JavaTest{
|
|
213 void fun1(int a,int b){
|
|
214 return a;
|
|
215 }
|
|
216
|
|
217 void fun2(int a,int b){ //1
|
|
218 return b;
|
|
219 }
|
|
220
|
|
221 }
|
|
222 "
|
|
223 )
|
|
224
|
|
225 (defvar semantic-utest-Java-name-contents
|
|
226 '(("JavaTest" type
|
|
227 (:members
|
|
228 (("fun1" function
|
|
229 (:arguments
|
|
230 (("a" variable
|
|
231 (:type "int")
|
|
232 (reparse-symbol formal_parameters)
|
|
233 (overlay 30 35 "JavaTest.java"))
|
|
234 ("b" variable
|
|
235 (:type "int")
|
|
236 (reparse-symbol formal_parameters)
|
|
237 (overlay 36 41 "JavaTest.java")))
|
|
238 :type "void")
|
|
239 (reparse-symbol class_member_declaration)
|
|
240 (overlay 20 61 "JavaTest.java"))
|
|
241 ("fun2" function
|
|
242 (:arguments
|
|
243 (("a" variable
|
|
244 (:type "int")
|
|
245 (reparse-symbol formal_parameters)
|
|
246 (overlay 75 80 "JavaTest.java"))
|
|
247 ("b" variable
|
|
248 (:type "int")
|
|
249 (reparse-symbol formal_parameters)
|
|
250 (overlay 81 86 "JavaTest.java")))
|
|
251 :type "void")
|
|
252 (reparse-symbol class_member_declaration)
|
|
253 (overlay 65 110 "JavaTest.java")))
|
|
254 :type "class")
|
|
255 nil (overlay 2 113 "JavaTest.java")))
|
|
256 "List of expected tag names for Java."
|
|
257 )
|
|
258
|
|
259
|
|
260 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
261 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
262 ;; Data for Javascript tests
|
|
263
|
|
264 (defvar semantic-utest-Javascript-buffer-contents
|
|
265 "
|
|
266 function fun1(a, b){
|
|
267 return a;
|
|
268 }
|
|
269
|
|
270 function fun2(a,b){ //1
|
|
271 return b;
|
|
272 }
|
|
273 "
|
|
274 )
|
|
275
|
|
276
|
|
277 (defvar semantic-utest-Javascript-name-contents
|
|
278 '(("fun1" function
|
|
279 (:arguments
|
|
280 (("a" variable nil
|
|
281 (reparse-symbol FormalParameterList)
|
|
282 (overlay 15 16 "tst.js"))
|
|
283 ("b" variable nil
|
|
284 (reparse-symbol FormalParameterList)
|
|
285 (overlay 18 19 "tst.js"))))
|
|
286 nil (overlay 1 39 "tst.js"))
|
|
287 ("fun2" function
|
|
288 (:arguments
|
|
289 (("a" variable nil
|
|
290 (reparse-symbol FormalParameterList)
|
|
291 (overlay 55 56 "tst.js"))
|
|
292 ("b" variable nil
|
|
293 (reparse-symbol FormalParameterList)
|
|
294 (overlay 57 58 "tst.js"))))
|
|
295 nil (overlay 41 82 "tst.js")))
|
|
296
|
|
297 "List of expected tag names for Javascript.")
|
|
298
|
|
299
|
|
300
|
|
301 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
302 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
303 ;; Data for Makefile tests
|
|
304
|
|
305 (defvar semantic-utest-Makefile-buffer-contents
|
|
306 "
|
|
307 t1:
|
|
308 \techo t1
|
|
309
|
|
310 t2:t1 #1
|
|
311 \techo t2
|
|
312
|
|
313
|
|
314 "
|
|
315 )
|
|
316
|
|
317
|
|
318 (defvar semantic-utest-Makefile-name-contents
|
|
319 '(("t1" function nil nil (overlay 1 9 "Makefile"))
|
|
320 ("t2" function
|
|
321 (:arguments
|
|
322 ("t1"))
|
|
323 nil (overlay 18 28 "Makefile")))
|
|
324 "List of expected tag names for Makefile.")
|
|
325
|
|
326
|
|
327 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
328 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
329 ;; Data for Scheme tests
|
|
330
|
|
331 (defvar semantic-utest-Scheme-buffer-contents
|
|
332 "
|
|
333 (define fun1 2)
|
|
334
|
|
335 (define fun2 3 ;1
|
|
336 )
|
|
337 ")
|
|
338
|
|
339 (defvar semantic-utest-Scheme-name-contents
|
|
340 '(("fun1" variable
|
|
341 (:default-value ("2"))
|
|
342 nil (overlay 3 18 "tst.scm"))
|
|
343 ("fun2" variable
|
|
344 (:default-value ("3"))
|
|
345 nil (overlay 21 55 "tst.scm")))
|
|
346 )
|
|
347
|
|
348 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
349 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
350 ;; Data for Html tests
|
|
351
|
|
352 (defvar semantic-utest-Html-buffer-contents
|
|
353 "
|
|
354 <html>
|
|
355 <body>
|
|
356 <h1>hello</h1>
|
|
357 </body><!--1-->
|
|
358 </html>
|
|
359 "
|
|
360 )
|
|
361
|
|
362 (defvar semantic-utest-Html-name-contents
|
|
363 '(("hello" section
|
|
364 (:members
|
|
365 (("hello" section nil nil (overlay 21 24 "tst.html"))))
|
|
366 nil (overlay 10 15 "tst.html")))
|
|
367 )
|
|
368
|
|
369
|
|
370 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
371 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
372 ;; Data for PHP tests
|
|
373
|
|
374 (defvar semantic-utest-PHP-buffer-contents
|
|
375 "<?php
|
|
376
|
|
377 function fun1(){
|
|
378 return \"fun1\";
|
|
379 }
|
|
380
|
|
381 function fun2($arg1){
|
|
382 $output = \"argument to fun2: \" . $arg1;
|
|
383 return $output;
|
|
384 }
|
|
385
|
|
386 class aClass {
|
|
387 public function fun1($a, $b){
|
|
388 return $a;
|
|
389 }
|
|
390
|
|
391 public function fun2($a, $b){
|
|
392 return $b;
|
|
393 }
|
|
394 }
|
|
395 ?> "
|
|
396 )
|
|
397
|
|
398 (defvar semantic-utest-PHP-name-contents
|
|
399 '(("fun1" function nil
|
|
400 nil (overlay 9 45 "phptest.php"))
|
|
401 ("fun2" function
|
|
402 (:arguments (("$arg1" variable nil (reparse-symbol formal_parameters) (overlay 61 66 "phptest.php"))))
|
|
403 nil
|
|
404 (overlay 47 132 "phptest.php"))
|
|
405 ("aClass" type
|
|
406 (:members (("fun1" function
|
|
407 (:typemodifiers ("public") :arguments
|
|
408 (("$a" variable nil (reparse-symbol formal_parameters) (overlay 174 176 "phptest.php"))
|
|
409 ("$b" variable nil (reparse-symbol formal_parameters) (overlay 178 180 "phptest.php"))))
|
|
410
|
|
411 nil
|
|
412 (overlay 153 204 "phptest.php"))
|
|
413
|
|
414 ("fun2" function
|
|
415 (:typemodifiers ("public") :arguments
|
|
416 (("$a" variable nil (reparse-symbol formal_parameters) (overlay 230 232 "phptest.php"))
|
|
417 ("$b" variable nil (reparse-symbol formal_parameters) (overlay 234 236 "phptest.php"))
|
|
418 ))
|
|
419 nil
|
|
420 (overlay 209 260 "phptest.php"))) :type "class")
|
|
421 nil
|
|
422 (overlay 135 262 "phptest.php"))
|
|
423 )
|
|
424 "Expected results from the PHP Unit test"
|
|
425 )
|
|
426
|
|
427 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
428 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
429 ;; Data for Csharp C# tests
|
|
430
|
|
431 (defvar semantic-utest-Csharp-buffer-contents
|
|
432 "
|
|
433 class someClass {
|
|
434 int fun1(int a, int b) {
|
|
435 return a; }
|
|
436 int fun2(int a, int b) {
|
|
437 return b; }
|
|
438 }
|
|
439 ")
|
|
440
|
|
441 (defvar semantic-utest-Csharp-name-contents
|
|
442 '(("someClass" type
|
|
443 (:members
|
|
444 (("fun1" function
|
|
445 (:arguments
|
|
446 (("a" variable
|
|
447 (:type "int")
|
|
448 (reparse-symbol formal_parameters)
|
|
449 (overlay 30 35 "tst.cs"))
|
|
450 ("b" variable
|
|
451 (:type "int")
|
|
452 (reparse-symbol formal_parameters)
|
|
453 (overlay 37 42 "tst.cs")))
|
|
454 :type "int")
|
|
455 (reparse-symbol class_member_declaration)
|
|
456 (overlay 21 61 "tst.cs"))
|
|
457 ("fun2" function
|
|
458 (:arguments
|
|
459 (("a" variable
|
|
460 (:type "int")
|
|
461 (reparse-symbol formal_parameters)
|
|
462 (overlay 73 78 "tst.cs"))
|
|
463 ("b" variable
|
|
464 (:type "int")
|
|
465 (reparse-symbol formal_parameters)
|
|
466 (overlay 80 85 "tst.cs")))
|
|
467 :type "int")
|
|
468 (reparse-symbol class_member_declaration)
|
|
469 (overlay 64 104 "tst.cs")))
|
|
470 :type "class")
|
|
471 nil (overlay 1 106 "tst.cs")))
|
|
472 )
|
|
473
|
|
474
|
|
475 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
476 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
477
|
|
478
|
|
479
|
|
480 (defun semantic-utest-makebuffer (filename contents)
|
|
481 "Create a buffer for FILENAME for use in a unit test.
|
|
482 Pre-fill the buffer with CONTENTS."
|
|
483 (let ((buff (semantic-find-file-noselect filename)))
|
|
484 (set-buffer buff)
|
|
485 (setq buffer-offer-save nil)
|
|
486 (font-lock-mode -1) ;; Font lock has issues in Emacs 23
|
|
487 (toggle-read-only -1) ;; In case /tmp doesn't exist.
|
|
488 (erase-buffer)
|
|
489 (insert contents)
|
|
490 ;(semantic-fetch-tags) ;JAVE could this go here?
|
|
491 (set-buffer-modified-p nil)
|
|
492 buff
|
|
493 )
|
|
494 )
|
|
495
|
|
496 (defun semantic-utest-C ()
|
|
497 "Run semantic's C unit test."
|
|
498 (interactive)
|
|
499 (save-excursion
|
|
500 (let ((buff (semantic-utest-makebuffer semantic-utest-C-filename semantic-utest-C-buffer-contents))
|
|
501 (buff2 (semantic-utest-makebuffer semantic-utest-C-filename-h semantic-utest-C-h-buffer-contents))
|
|
502 )
|
|
503 (semantic-fetch-tags)
|
|
504 (set-buffer buff)
|
|
505
|
|
506 ;; Turn off a range of modes
|
|
507 (semantic-idle-scheduler-mode -1)
|
|
508
|
|
509 ;; Turn on some modes
|
|
510 (semantic-highlight-edits-mode 1)
|
|
511
|
|
512 ;; Update tags, and show it.
|
|
513 (semantic-fetch-tags)
|
|
514
|
|
515 (switch-to-buffer buff)
|
|
516 (sit-for 0)
|
|
517
|
|
518 ;; Run the tests.
|
|
519 ;;(message "First parsing test.")
|
|
520 (semantic-utest-verify-names semantic-utest-C-name-contents)
|
|
521
|
|
522 ;;(message "Invalid tag test.")
|
|
523 (semantic-utest-last-invalid semantic-utest-C-name-contents '("fun2") "/\\*1\\*/" "/* Deleted this line */")
|
|
524 (semantic-utest-verify-names semantic-utest-C-name-contents)
|
|
525
|
|
526 (set-buffer-modified-p nil)
|
|
527 ;; Clean up
|
|
528 ;; (kill-buffer buff)
|
|
529 ;; (kill-buffer buff2)
|
|
530 ))
|
|
531 (message "All C tests passed.")
|
|
532 )
|
|
533
|
|
534
|
|
535
|
|
536
|
|
537 (defun semantic-utest-generic (testname filename contents name-contents names-removed killme insertme)
|
|
538 "Generic unit test according to template.
|
|
539 Should work for languages withouth .h files, python javascript java.
|
|
540 TESTNAME is the name of the test.
|
|
541 FILENAME is the name of the file to create.
|
|
542 CONTENTS is the contents of the file to test.
|
|
543 NAME-CONTENTS is the list of names that should be in the contents.
|
|
544 NAMES-REMOVED is the list of names that gets removed in the removal step.
|
|
545 KILLME is the name of items to be killed.
|
|
546 INSERTME is the text to be inserted after the deletion."
|
|
547 (save-excursion
|
|
548 (let ((buff (semantic-utest-makebuffer filename contents))
|
|
549 )
|
|
550 ;; Turn off a range of modes
|
|
551 (semantic-idle-scheduler-mode -1)
|
|
552
|
|
553 ;; Turn on some modes
|
|
554 (semantic-highlight-edits-mode 1)
|
|
555
|
|
556 ;; Update tags, and show it.
|
|
557 (semantic-fetch-tags)
|
|
558 (switch-to-buffer buff)
|
|
559 (sit-for 0)
|
|
560
|
|
561 ;; Run the tests.
|
|
562 ;;(message "First parsing test %s." testname)
|
|
563 (semantic-utest-verify-names name-contents)
|
|
564
|
|
565 ;;(message "Invalid tag test %s." testname)
|
|
566 (semantic-utest-last-invalid name-contents names-removed killme insertme)
|
|
567 (semantic-utest-verify-names name-contents)
|
|
568
|
|
569 (set-buffer-modified-p nil)
|
|
570 ;; Clean up
|
|
571 ;; (kill-buffer buff)
|
|
572 ))
|
|
573 (message "All %s tests passed." testname)
|
|
574 )
|
|
575
|
|
576 (defun semantic-utest-Python()
|
|
577 (interactive)
|
|
578 (if (fboundp 'python-mode)
|
|
579 (semantic-utest-generic "Python" (semantic-utest-fname "pytest.py") semantic-utest-Python-buffer-contents semantic-utest-Python-name-contents '("fun2") "#1" "#deleted line")
|
|
580 (message "Skilling Python test: NO major mode."))
|
|
581 )
|
|
582
|
|
583
|
|
584 (defun semantic-utest-Javascript()
|
|
585 (interactive)
|
|
586 (if (fboundp 'javascript-mode)
|
|
587 (semantic-utest-generic "Javascript" (semantic-utest-fname "javascripttest.js") semantic-utest-Javascript-buffer-contents semantic-utest-Javascript-name-contents '("fun2") "//1" "//deleted line")
|
|
588 (message "Skipping JavaScript test: NO major mode."))
|
|
589 )
|
|
590
|
|
591 (defun semantic-utest-Java()
|
|
592 (interactive)
|
|
593 ;; If JDE is installed, it might mess things up depending on the version
|
|
594 ;; that was installed.
|
|
595 (let ((auto-mode-alist '(("\\.java\\'" . java-mode))))
|
|
596 (semantic-utest-generic "Java" (semantic-utest-fname "JavaTest.java") semantic-utest-Java-buffer-contents semantic-utest-Java-name-contents '("fun2") "//1" "//deleted line")
|
|
597 ))
|
|
598
|
|
599 (defun semantic-utest-Makefile()
|
|
600 (interactive)
|
|
601 (semantic-utest-generic "Makefile" (semantic-utest-fname "Makefile") semantic-utest-Makefile-buffer-contents semantic-utest-Makefile-name-contents '("fun2") "#1" "#deleted line")
|
|
602 )
|
|
603
|
|
604 (defun semantic-utest-Scheme()
|
|
605 (interactive)
|
|
606 (semantic-utest-generic "Scheme" (semantic-utest-fname "tst.scm") semantic-utest-Scheme-buffer-contents semantic-utest-Scheme-name-contents '("fun2") ";1" ";deleted line")
|
|
607 )
|
|
608
|
|
609
|
|
610 (defun semantic-utest-Html()
|
|
611 (interactive)
|
|
612 ;; Disable html-helper auto-fill-in mode.
|
|
613 (let ((html-helper-build-new-buffer nil))
|
|
614 (semantic-utest-generic "HTML" (semantic-utest-fname "tst.html") semantic-utest-Html-buffer-contents semantic-utest-Html-name-contents '("fun2") "<!--1-->" "<!--deleted line-->")
|
|
615 ))
|
|
616
|
|
617 (defun semantic-utest-PHP()
|
|
618 (interactive)
|
|
619 (if (fboundp 'php-mode)
|
|
620 (semantic-utest-generic "PHP" (semantic-utest-fname "phptest.php") semantic-utest-PHP-buffer-contents semantic-utest-PHP-name-contents '("fun1") "fun2" "%^@")
|
|
621 (message "Skipping PHP Test. No php-mode loaded."))
|
|
622 )
|
|
623
|
|
624 ;look at http://mfgames.com/linux/csharp-mode
|
|
625 (defun semantic-utest-Csharp() ;; hmm i dont even know how to edit a scharp file. need a csharp mode implementation i suppose
|
|
626 (interactive)
|
|
627 (if (fboundp 'csharp-mode)
|
|
628 (semantic-utest-generic "C#" (semantic-utest-fname "csharptest.cs") semantic-utest-Csharp-buffer-contents semantic-utest-Csharp-name-contents '("fun2") "//1" "//deleted line")
|
|
629 (message "Skipping C# test. No csharp-mode loaded."))
|
|
630 )
|
|
631
|
|
632 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
633 ;; stubs
|
|
634
|
|
635 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
636 ; stuff for Erlang
|
|
637 ;;-module(hello).
|
|
638 ;-export([hello_world/0]).
|
|
639 ;
|
|
640 ;hello_world()->
|
|
641 ; io:format("Hello World ~n").
|
|
642 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
643 ;(defun semantic-utest-Erlang()
|
|
644 ; (interactive)
|
|
645 ; (semantic-utest-generic "Erlang" (semantic-utest-fname "tst.erl") semantic-utest-Erlang-buffer-contents semantic-utest-Erlang-name-contents '("fun2") "//1" "//deleted line")
|
|
646 ; )
|
|
647 ;
|
|
648 ;;texi is also supported
|
|
649 ;(defun semantic-utest-Texi()
|
|
650 ; (interactive)
|
|
651 ; (semantic-utest-generic "texi" (semantic-utest-fname "tst.texi") semantic-utest-Texi-buffer-contents semantic-utest-Texi-name-contents '("fun2") "//1" "//deleted line")
|
|
652 ; )
|
|
653
|
|
654 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
655
|
|
656 ;;;###autoload
|
|
657 (defun semantic-utest-main()
|
|
658 (interactive)
|
|
659 "call all utests"
|
|
660 (cedet-utest-log-start "multi-lang parsing")
|
|
661 (cedet-utest-log " * C tests...")
|
|
662 (semantic-utest-C)
|
|
663 (cedet-utest-log " * Python tests...")
|
|
664 (semantic-utest-Python)
|
|
665 (cedet-utest-log " * Java tests...")
|
|
666 (semantic-utest-Java)
|
|
667 (cedet-utest-log " * Javascript tests...")
|
|
668 (semantic-utest-Javascript)
|
|
669 (cedet-utest-log " * Makefile tests...")
|
|
670 (semantic-utest-Makefile)
|
|
671 (cedet-utest-log " * Scheme tests...")
|
|
672 (semantic-utest-Scheme)
|
|
673 (cedet-utest-log " * Html tests...")
|
|
674 (semantic-utest-Html)
|
|
675 (cedet-utest-log " * PHP tests...")
|
|
676 (semantic-utest-PHP)
|
|
677 (cedet-utest-log " * Csharp tests...")
|
|
678 (semantic-utest-Csharp)
|
|
679
|
|
680 (cedet-utest-log-shutdown "multi-lang parsing")
|
|
681 )
|
|
682
|
|
683 ;;; Buffer contents validation
|
|
684 ;;
|
|
685 (defun semantic-utest-match-attributes (attr1 attr2 skipnames)
|
|
686 "Compare attribute lists ATTR1 and ATTR2.
|
|
687 Argument SKIPNAMES is a list of names that may be child nodes to skip."
|
|
688 (let ((res t))
|
|
689 (while (and res attr1 attr2)
|
|
690
|
|
691 ;; Compare
|
|
692 (setq res
|
|
693 (cond ((and (listp (car attr1))
|
|
694 (semantic-tag-p (car (car attr1))))
|
|
695 ;; Compare the list of tags...
|
|
696 (semantic-utest-taglists-equivalent-p
|
|
697 (car attr2) (car attr1) skipnames)
|
|
698 )
|
|
699 (t
|
|
700 (equal (car attr1) (car attr2)))))
|
|
701
|
|
702 (if (not res)
|
|
703 (error "TAG INTERNAL DIFF: %S %S"
|
|
704 (car attr1) (car attr2)))
|
|
705
|
|
706 (setq attr1 (cdr attr1)
|
|
707 attr2 (cdr attr2)))
|
|
708 res))
|
|
709
|
|
710 (defun semantic-utest-equivalent-tag-p (tag1 tag2 skipnames)
|
|
711 "Determine if TAG1 and TAG2 are the same.
|
|
712 SKIPNAMES includes lists of possible child nodes that should be missing."
|
|
713 (and (equal (semantic-tag-name tag1) (semantic-tag-name tag2))
|
|
714 (semantic-tag-of-class-p tag1 (semantic-tag-class tag2))
|
|
715 (semantic-utest-match-attributes
|
|
716 (semantic-tag-attributes tag1) (semantic-tag-attributes tag2)
|
|
717 skipnames)
|
|
718 ))
|
|
719
|
|
720 (defun semantic-utest-taglists-equivalent-p (table names skipnames)
|
|
721 "Compare TABLE and NAMES, where skipnames allow list1 to be different.
|
|
722 SKIPNAMES is a list of names that should be skipped in the NAMES list."
|
|
723 (let ((SN skipnames))
|
|
724 (while SN
|
|
725 (setq names (remove (car SN) names))
|
|
726 (setq SN (cdr SN))))
|
|
727 (while (and names table)
|
|
728 (if (not (semantic-utest-equivalent-tag-p (car names)
|
|
729 (car table)
|
|
730 skipnames))
|
|
731 (error "Expected %s, found %s"
|
|
732 (semantic-format-tag-prototype (car names))
|
|
733 (semantic-format-tag-prototype (car table))))
|
|
734 (setq names (cdr names)
|
|
735 table (cdr table)))
|
|
736 (when names (error "Items forgotten: %S"
|
|
737 (mapcar 'semantic-tag-name names)
|
|
738 ))
|
|
739 (when table (error "Items extra: %S"
|
|
740 (mapcar 'semantic-tag-name table)))
|
|
741 t)
|
|
742
|
|
743 (defun semantic-utest-verify-names (name-contents &optional skipnames)
|
|
744 "Verify the names of the test buffer from NAME-CONTENTS.
|
|
745 Argument SKIPNAMES is a list of names that should be skipped
|
|
746 when analyzing the file.
|
|
747
|
|
748 JAVE this thing would need to be recursive to handle java and csharp"
|
|
749 (let ((names name-contents)
|
|
750 (table (semantic-fetch-tags))
|
|
751 )
|
|
752 (semantic-utest-taglists-equivalent-p table names skipnames)
|
|
753 ))
|
|
754
|
|
755 ;;;;;;;;;;;;;;;;;;;;;;;;
|
|
756 ; JAVE redefine a new validation function
|
|
757 ; is not quite as good as the old one yet
|
|
758 (defun semantic-utest-verify-names-jave (name-contents &optional skipnames)
|
|
759 "JAVE version of `semantic-utest-verify-names'.
|
|
760 NAME-CONTENTS is a sample of the tags buffer to test against.
|
|
761 SKIPNAMES is a list of names to remove from NAME-CONTENTS"
|
|
762 (assert (semantic-utest-verify-names-2 name-contents (semantic-fetch-tags))
|
|
763 nil "failed test")
|
|
764 )
|
|
765
|
|
766 (defun semantic-utest-verify-names-2 (l1 l2)
|
|
767 (cond ( (and (consp l1) (equal (car l1) 'overlay))
|
|
768 (overlayp l2))
|
|
769 ((not (consp l1))
|
|
770 (equal l1 l2))
|
|
771 ((consp l1)
|
|
772 (and (semantic-utest-verify-names-2 (car l1) (car l2)) (semantic-utest-verify-names-2 (cdr l1) (cdr l2))))
|
|
773 (t (error "internal error"))))
|
|
774
|
|
775
|
|
776
|
|
777
|
|
778
|
|
779 ;;; Kill indicator line
|
|
780 ;;
|
|
781 (defvar semantic-utest-last-kill-text nil
|
|
782 "The text from the last kill.")
|
|
783
|
|
784 (defvar semantic-utest-last-kill-pos nil
|
|
785 "The position of the last kill.")
|
|
786
|
|
787 (defun semantic-utest-kill-indicator ( killme insertme)
|
|
788 "Kill the line with KILLME on it and insert INSERTME in its place."
|
|
789 (goto-char (point-min))
|
|
790 ; (re-search-forward (concat "/\\*" indicator "\\*/")); JAVE this isnt generic enough for different lagnuages
|
|
791 (re-search-forward killme)
|
|
792 (beginning-of-line)
|
|
793 (setq semantic-utest-last-kill-pos (point))
|
|
794 (setq semantic-utest-last-kill-text
|
|
795 (buffer-substring (point) (point-at-eol)))
|
|
796 (delete-region (point) (point-at-eol))
|
|
797 (insert insertme)
|
|
798 (sit-for 0)
|
|
799 )
|
|
800
|
|
801 (defun semantic-utest-unkill-indicator ()
|
|
802 "Unkill the last indicator."
|
|
803 (goto-char semantic-utest-last-kill-pos)
|
|
804 (delete-region (point) (point-at-eol))
|
|
805 (insert semantic-utest-last-kill-text)
|
|
806 (sit-for 0)
|
|
807 )
|
|
808
|
|
809 ;;; EDITING TESTS
|
|
810 ;;
|
|
811
|
|
812 (defun semantic-utest-last-invalid (name-contents names-removed killme insertme)
|
|
813 "Make the last fcn invalid."
|
|
814 (semantic-utest-kill-indicator killme insertme)
|
|
815 ; (semantic-utest-verify-names name-contents names-removed); verify its gone ;new validator doesnt handle skipnames yet
|
|
816 (semantic-utest-unkill-indicator);put back killed stuff
|
|
817 )
|
|
818
|
|
819
|
|
820
|
|
821
|
|
822 ;"#<overlay from \\([0-9]+\\) to \\([0-9]+\\) in \\([^>]*\\)>"
|
|
823 ;#<overlay from \([0-9]+\) to \([0-9]+\) in \([^>]*\)>
|
|
824 ;(overlay \1 \2 "\3")
|
|
825
|
|
826
|
|
827 ;; JAVE
|
|
828 ;; these are some unit tests for cedet that I got from Eric and modified a bit for:
|
|
829 ;; python
|
|
830 ;; javascript
|
|
831 ;; java
|
|
832 ;; I tried to generalize the structure of the tests a bit to make it easier to add languages
|
|
833
|
|
834 ;; Mail from Eric:
|
|
835 ;; Many items in the checklist look like:
|
|
836
|
|
837 ;; M-x global-semantic-highlight-edits-mode RET
|
|
838 ;; - Edit a file. See the highlight of newly inserted text.
|
|
839 ;; - Customize `semantic-edits-verbose-flag' to be non-nil.
|
|
840 ;; - Wait for the idle scheduler, it should clean up the edits.
|
|
841 ;; - observe messages from incremental parser. Do they relate
|
|
842 ;; to the edits?
|
|
843 ;; - M-x bovinate RET - verify your changes are reflected.
|
|
844
|
|
845 ;; It's all about watching the behavior. Timers go off, things get
|
|
846 ;; cleaned up, you type in new changes, etc. An example I tried to
|
|
847 ;; do is below, but covers only 1 language, and not very well at that.
|
|
848 ;; I seem to remember seeing a unit test framework going by one of the
|
|
849 ;; lists. I'm not sure if that would help.
|
|
850
|
|
851 ;; Another that might be automatable:
|
|
852
|
|
853 ;; M-x semantic-analyze-current-context RET
|
|
854 ;; - Do this in different contexts in your language
|
|
855 ;; files. Verify that reasonable results are returned
|
|
856 ;; such as identification of assignments, function arguments, etc.
|
|
857
|
|
858 ;; Anyway, those are some ideas. Any effort you put it will be helpful!
|
|
859
|
|
860 ;; Thanks
|
|
861 ;; Eric
|
|
862
|
|
863 ;; -----------
|
|
864
|
|
865
|
|
866
|
|
867 ;;; semantic-utest.el ends here
|