[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] emacs/test/cedet cedet-utests.el ede-tests.el s...
|
From: |
Chong Yidong |
|
Subject: |
[Emacs-diffs] emacs/test/cedet cedet-utests.el ede-tests.el s... |
|
Date: |
Mon, 28 Sep 2009 23:23:33 +0000 |
CVSROOT: /sources/emacs
Module name: emacs
Changes by: Chong Yidong <cyd> 09/09/28 23:23:32
Added files:
test/cedet : cedet-utests.el ede-tests.el
semantic-ia-utest.el semantic-tests.el
semantic-utest-c.el semantic-utest.el
srecode-tests.el
test/cedet/tests: scopetest.cpp scopetest.java templates.cpp
test.c test.cpp test.el test.make test.py
testdoublens.cpp testdoublens.hpp
testfriends.cpp testjavacomp.java testnsp.cpp
testpolymorph.cpp testspp.c testsppcomplete.c
testsppreplace.c testsppreplaced.c
teststruct.cpp testsubclass.cpp
testsubclass.hh testtemplates.cpp
testtypedefs.cpp testusing.cpp testusing.hh
testvarnames.c
Log message:
Add CEDET tests.
CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/cedet-utests.el?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/ede-tests.el?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/semantic-ia-utest.el?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/semantic-tests.el?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/semantic-utest-c.el?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/semantic-utest.el?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/srecode-tests.el?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/scopetest.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/scopetest.java?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/templates.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/test.c?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/test.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/test.el?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/test.make?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/test.py?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testdoublens.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testdoublens.hpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testfriends.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testjavacomp.java?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testnsp.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testpolymorph.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testspp.c?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testsppcomplete.c?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testsppreplace.c?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testsppreplaced.c?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/teststruct.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testsubclass.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testsubclass.hh?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testtemplates.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testtypedefs.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testusing.cpp?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testusing.hh?cvsroot=emacs&rev=1.2
http://cvs.savannah.gnu.org/viewcvs/emacs/test/cedet/tests/testvarnames.c?cvsroot=emacs&rev=1.2
Patches:
Index: cedet-utests.el
===================================================================
RCS file: cedet-utests.el
diff -N cedet-utests.el
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ cedet-utests.el 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,515 @@
+;;; cedet-utests.el --- Run all unit tests in the CEDET suite.
+
+;; Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+
+;; Author: Eric M. Ludlam <address@hidden>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; Remembering to run all the unit tests available in CEDET one at a
+;; time is a bit time consuming. This links all the tests together
+;; into one command.
+
+(require 'cedet)
+;;; Code:
+(defvar cedet-utest-test-alist
+ '(
+ ;;
+ ;; COMMON
+ ;;
+
+ ;; Test inversion
+ ("inversion" . inversion-unit-test)
+
+ ;; EZ Image dumping.
+ ("ezimage associations" . ezimage-image-association-dump)
+ ("ezimage images" . ezimage-image-dump)
+
+ ;; Pulse
+ ("pulse interactive test" . (lambda () (pulse-test t)))
+
+ ;; Files
+ ("cedet file conversion" . cedet-files-utest)
+
+ ;;
+ ;; EIEIO
+ ;;
+ ("eieio" . (lambda () (let ((lib (locate-library "eieio-tests.el"
+ t)))
+ (load-file lib))))
+ ("eieio: browser" . eieio-browse)
+ ("eieio: custom" . (lambda ()
+ (require 'eieio-custom)
+ (customize-variable 'eieio-widget-test)))
+ ("eieio: chart" . (lambda ()
+ (if (cedet-utest-noninteractive)
+ (message " ** Skipping test in noninteractive
mode.")
+ (chart-test-it-all))))
+ ;;
+ ;; EDE
+ ;;
+
+ ;; @todo - Currently handled in the integration tests. Need
+ ;; some simpler unit tests here.
+
+ ;;
+ ;; SEMANTIC
+ ;;
+ ("semantic: lex spp table write" . semantic-lex-spp-write-utest)
+ ("semantic: multi-lang parsing" . semantic-utest-main)
+ ("semantic: C preprocessor" . semantic-utest-c)
+ ("semantic: analyzer tests" . semantic-ia-utest)
+ ("semanticdb: data cache" . semantic-test-data-cache)
+ ("semantic: throw-on-input" .
+ (lambda ()
+ (if (cedet-utest-noninteractive)
+ (message " ** Skipping test in noninteractive mode.")
+ (semantic-test-throw-on-input))))
+
+ ("semantic: gcc: output parse test" . semantic-gcc-test-output-parser)
+ ;;
+ ;; SRECODE
+ ;;
+ ("srecode: fields" . srecode-field-utest)
+ ("srecode: templates" . srecode-utest-template-output)
+ ("srecode: show maps" . srecode-get-maps)
+ ("srecode: getset" . srecode-utest-getset-output)
+ )
+ "Alist of all the tests in CEDET we should run.")
+
+(defvar cedet-running-master-tests nil
+ "Non-nil when CEDET-utest is running all the tests.")
+
+(defun cedet-utest (&optional exit-on-error)
+ "Run the CEDET unittests.
+EXIT-ON-ERROR causes the test suite to exit on an error, instead
+of just logging the error."
+ (interactive)
+ (if (or (not (featurep 'semanticdb-mode))
+ (not (semanticdb-minor-mode-p)))
+ (error "CEDET Tests require: M-x semantic-load-enable-minimum-features"))
+ (cedet-utest-log-setup "ALL TESTS")
+ (let ((tl cedet-utest-test-alist)
+ (notes nil)
+ (err nil)
+ (start (current-time))
+ (end nil)
+ (cedet-running-master-tests t)
+ )
+ (dolist (T tl)
+ (cedet-utest-add-log-item-start (car T))
+ (setq notes nil err nil)
+ (condition-case Cerr
+ (progn
+ (funcall (cdr T))
+ )
+ (error
+ (setq err (format "ERROR: %S" Cerr))
+ ;;(message "Error caught: %s" Cerr)
+ ))
+
+ ;; Cleanup stray input and events that are in the way.
+ ;; Not doing this causes sit-for to not refresh the screen.
+ ;; Doing this causes the user to need to press keys more frequently.
+ (when (and (interactive-p) (input-pending-p))
+ (if (fboundp 'read-event)
+ (read-event)
+ (read-char)))
+
+ (cedet-utest-add-log-item-done notes err)
+ (when (and exit-on-error err)
+ (message "to debug this test point, execute:")
+ (message "%S" (cdr T))
+ (message "\n ** Exiting Test Suite. ** \n")
+ (throw 'cedet-utest-exit-on-error t)
+ )
+ )
+ (setq end (current-time))
+ (cedet-utest-log-shutdown-msg "ALL TESTS" start end)
+ nil))
+
+(defun cedet-utest-noninteractive ()
+ "Return non-nil if running non-interactively."
+ (if (featurep 'xemacs)
+ (noninteractive)
+ noninteractive))
+
+;;;###autoload
+(defun cedet-utest-batch ()
+ "Run the CEDET unit test in BATCH mode."
+ (unless (cedet-utest-noninteractive)
+ (error "`cedet-utest-batch' is to be used only with -batch"))
+ (condition-case err
+ (when (catch 'cedet-utest-exit-on-error
+ ;; Get basic semantic features up.
+ (semantic-load-enable-minimum-features)
+ ;; Disables all caches related to semantic DB so all
+ ;; tests run as if we have bootstrapped CEDET for the
+ ;; first time.
+ (setq-default semanticdb-new-database-class
'semanticdb-project-database)
+ (message "Disabling existing Semantic Database Caches.")
+
+ ;; Disabling the srecoder map, we won't load a pre-existing one
+ ;; and will be forced to bootstrap a new one.
+ (setq srecode-map-save-file nil)
+
+ ;; Run the tests
+ (cedet-utest t)
+ )
+ (kill-emacs 1))
+ (error
+ (error "Error in unit test harness:\n %S" err))
+ )
+ )
+
+;;; Logging utility.
+;;
+(defvar cedet-utest-frame nil
+ "Frame used during cedet unit test logging.")
+(defvar cedet-utest-buffer nil
+ "Frame used during cedet unit test logging.")
+(defvar cedet-utest-frame-parameters
+ '((name . "CEDET-UTEST")
+ (width . 80)
+ (height . 25)
+ (minibuffer . t))
+ "Frame parameters used for the cedet utest log frame.")
+
+(defvar cedet-utest-last-log-item nil
+ "Remember the last item we were logging for.")
+
+(defvar cedet-utest-log-timer nil
+ "During a test, track the start time.")
+
+(defun cedet-utest-log-setup (&optional title)
+ "Setup a frame and buffer for unit testing.
+Optional argument TITLE is the title of this testing session."
+ (setq cedet-utest-log-timer (current-time))
+ (if (cedet-utest-noninteractive)
+ (message "\n>> Setting up %s tests to run @ %s\n"
+ (or title "")
+ (current-time-string))
+
+ ;; Interactive mode needs a frame and buffer.
+ (when (or (not cedet-utest-frame) (not (frame-live-p cedet-utest-frame)))
+ (setq cedet-utest-frame (make-frame cedet-utest-frame-parameters)))
+ (when (or (not cedet-utest-buffer) (not (buffer-live-p
cedet-utest-buffer)))
+ (setq cedet-utest-buffer (get-buffer-create "*CEDET utest log*")))
+ (save-excursion
+ (set-buffer cedet-utest-buffer)
+ (setq cedet-utest-last-log-item nil)
+ (when (not cedet-running-master-tests)
+ (erase-buffer))
+ (insert "\n\nSetting up "
+ (or title "")
+ " tests to run @ " (current-time-string) "\n\n"))
+ (let ((oframe (selected-frame)))
+ (unwind-protect
+ (progn
+ (select-frame cedet-utest-frame)
+ (switch-to-buffer cedet-utest-buffer t))
+ (select-frame oframe)))
+ ))
+
+(defun cedet-utest-elapsed-time (start end)
+ "Copied from elp.el. Was elp-elapsed-time.
+Argument START and END bound the time being calculated."
+ (+ (* (- (car end) (car start)) 65536.0)
+ (- (car (cdr end)) (car (cdr start)))
+ (/ (- (car (cdr (cdr end))) (car (cdr (cdr start)))) 1000000.0)))
+
+(defun cedet-utest-log-shutdown (title &optional errorcondition)
+ "Shut-down a larger test suite.
+TITLE is the section that is done.
+ERRORCONDITION is some error that may have occured durinig testing."
+ (let ((endtime (current-time))
+ )
+ (cedet-utest-log-shutdown-msg title cedet-utest-log-timer endtime)
+ (setq cedet-utest-log-timer nil)
+ ))
+
+(defun cedet-utest-log-shutdown-msg (title startime endtime)
+ "Show a shutdown message with TITLE, STARTIME, and ENDTIME."
+ (if (cedet-utest-noninteractive)
+ (progn
+ (message "\n>> Test Suite %s ended at @ %s"
+ title
+ (format-time-string "%c" endtime))
+ (message " Elapsed Time %.2f Seconds\n"
+ (cedet-utest-elapsed-time startime endtime)))
+
+ (save-excursion
+ (set-buffer cedet-utest-buffer)
+ (goto-char (point-max))
+ (insert "\n>> Test Suite " title " ended at @ "
+ (format-time-string "%c" endtime) "\n"
+ " Elapsed Time "
+ (number-to-string
+ (cedet-utest-elapsed-time startime endtime))
+ " Seconds\n * "))
+ ))
+
+(defun cedet-utest-show-log-end ()
+ "Show the end of the current unit test log."
+ (unless (cedet-utest-noninteractive)
+ (let* ((cb (current-buffer))
+ (cf (selected-frame))
+ (bw (or (get-buffer-window cedet-utest-buffer t)
+ (get-buffer-window (switch-to-buffer cedet-utest-buffer) t)))
+ (lf (window-frame bw))
+ )
+ (select-frame lf)
+ (select-window bw)
+ (goto-char (point-max))
+ (select-frame cf)
+ (set-buffer cb)
+ )))
+
+(defun cedet-utest-post-command-hook ()
+ "Hook run after the current log command was run."
+ (if (cedet-utest-noninteractive)
+ (message "")
+ (save-excursion
+ (set-buffer cedet-utest-buffer)
+ (goto-char (point-max))
+ (insert "\n\n")))
+ (setq cedet-utest-last-log-item nil)
+ (remove-hook 'post-command-hook 'cedet-utest-post-command-hook)
+ )
+
+(defun cedet-utest-add-log-item-start (item)
+ "Add ITEM into the log as being started."
+ (unless (equal item cedet-utest-last-log-item)
+ (setq cedet-utest-last-log-item item)
+ ;; This next line makes sure we clear out status during logging.
+ (add-hook 'post-command-hook 'cedet-utest-post-command-hook)
+
+ (if (cedet-utest-noninteractive)
+ (message " - Running %s ..." item)
+ (save-excursion
+ (set-buffer cedet-utest-buffer)
+ (goto-char (point-max))
+ (when (not (bolp)) (insert "\n"))
+ (insert "Running " item " ... ")
+ (sit-for 0)
+ ))
+ (cedet-utest-show-log-end)
+ ))
+
+(defun cedet-utest-add-log-item-done (&optional notes err precr)
+ "Add into the log that the last item is done.
+Apply NOTES to the doneness of the log.
+Apply ERR if there was an error in previous item.
+Optional argument PRECR indicates to prefix the done msg w/ a newline."
+ (if (cedet-utest-noninteractive)
+ ;; Non-interactive-mode - show a message.
+ (if notes
+ (message " * %s {%s}" (or err "done") notes)
+ (message " * %s" (or err "done")))
+ ;; Interactive-mode - insert into the buffer.
+ (save-excursion
+ (set-buffer cedet-utest-buffer)
+ (goto-char (point-max))
+ (when precr (insert "\n"))
+ (if err
+ (insert err)
+ (insert "done")
+ (when notes (insert " (" notes ")")))
+ (insert "\n")
+ (setq cedet-utest-last-log-item nil)
+ (sit-for 0)
+ )))
+
+;;; INDIVIDUAL TEST API
+;;
+;; Use these APIs to start and log information.
+;;
+;; The other fcns will be used to log across all the tests at once.
+(defun cedet-utest-log-start (testname)
+ "Setup the log for the test TESTNAME."
+ ;; Make sure we have a log buffer.
+ (save-window-excursion
+ (when (or (not cedet-utest-buffer)
+ (not (buffer-live-p cedet-utest-buffer))
+ (not (get-buffer-window cedet-utest-buffer t))
+ )
+ (cedet-utest-log-setup))
+ ;; Add our startup message.
+ (cedet-utest-add-log-item-start testname)
+ ))
+
+(defun cedet-utest-log(format &rest args)
+ "Log the text string FORMAT.
+The rest of the ARGS are used to fill in FORMAT with `format'."
+ (if (cedet-utest-noninteractive)
+ (apply 'message format args)
+ (save-excursion
+ (set-buffer cedet-utest-buffer)
+ (goto-char (point-max))
+ (when (not (bolp)) (insert "\n"))
+ (insert (apply 'format format args))
+ (insert "\n")
+ (sit-for 0)
+ ))
+ (cedet-utest-show-log-end)
+ )
+
+;;; Inversion tests
+
+(defun inversion-unit-test ()
+ "Test inversion to make sure it can identify different version strings."
+ (interactive)
+ (let ((c1 (inversion-package-version 'inversion))
+ (c1i (inversion-package-incompatibility-version 'inversion))
+ (c2 (inversion-decode-version "1.3alpha2"))
+ (c3 (inversion-decode-version "1.3beta4"))
+ (c4 (inversion-decode-version "1.3 beta5"))
+ (c5 (inversion-decode-version "1.3.4"))
+ (c6 (inversion-decode-version "2.3alpha"))
+ (c7 (inversion-decode-version "1.3"))
+ (c8 (inversion-decode-version "1.3pre1"))
+ (c9 (inversion-decode-version "2.4 (patch 2)"))
+ (c10 (inversion-decode-version "2.4 (patch 3)"))
+ (c11 (inversion-decode-version "2.4.2.1"))
+ (c12 (inversion-decode-version "2.4.2.2"))
+ )
+ (if (not (and
+ (inversion-= c1 c1)
+ (inversion-< c1i c1)
+ (inversion-< c2 c3)
+ (inversion-< c3 c4)
+ (inversion-< c4 c5)
+ (inversion-< c5 c6)
+ (inversion-< c2 c4)
+ (inversion-< c2 c5)
+ (inversion-< c2 c6)
+ (inversion-< c3 c5)
+ (inversion-< c3 c6)
+ (inversion-< c7 c6)
+ (inversion-< c4 c7)
+ (inversion-< c2 c7)
+ (inversion-< c8 c6)
+ (inversion-< c8 c7)
+ (inversion-< c4 c8)
+ (inversion-< c2 c8)
+ (inversion-< c9 c10)
+ (inversion-< c10 c11)
+ (inversion-< c11 c12)
+ ;; Negatives
+ (not (inversion-< c3 c2))
+ (not (inversion-< c4 c3))
+ (not (inversion-< c5 c4))
+ (not (inversion-< c6 c5))
+ (not (inversion-< c7 c2))
+ (not (inversion-< c7 c8))
+ (not (inversion-< c12 c11))
+ ;; Test the tester on inversion
+ (not (inversion-test 'inversion inversion-version))
+ ;; Test that we throw an error
+ (inversion-test 'inversion "0.0.0")
+ (inversion-test 'inversion "1000.0")
+ ))
+ (error "Inversion tests failed")
+ (message "Inversion tests passed."))))
+
+;;; cedet-files unit test
+
+(defvar cedet-files-utest-list
+ '(
+ ( "/home/me/src/myproj/src/foo.c" . "!home!me!src!myproj!src!foo.c" )
+ ( "c:/work/myproj/foo.el" . "!drive_c!work!myproj!foo.el" )
+ ( "//windows/proj/foo.java" . "!!windows!proj!foo.java" )
+ ( "/home/me/proj!bang/foo.c" . "!home!me!proj!!bang!foo.c" )
+ )
+ "List of different file names to test.
+Each entry is a cons cell of ( FNAME . CONVERTED )
+where FNAME is some file name, and CONVERTED is what it should be
+converted into.")
+
+(defun cedet-files-utest ()
+ "Test out some file name conversions."
+ (interactive)
+ (let ((idx 0))
+ (dolist (FT cedet-files-utest-list)
+
+ (setq idx (+ idx 1))
+
+ (let ((dir->file (cedet-directory-name-to-file-name (car FT) t))
+ (file->dir (cedet-file-name-to-directory-name (cdr FT) t))
+ )
+
+ (unless (string= (cdr FT) dir->file)
+ (error "Failed: %d. Found: %S Wanted: %S"
+ idx dir->file (cdr FT))
+ )
+
+ (unless (string= file->dir (car FT))
+ (error "Failed: %d. Found: %S Wanted: %S"
+ idx file->dir (car FT)))))))
+
+;;; pulse test
+
+(defun pulse-test (&optional no-error)
+ "Test the lightening function for pulsing a line.
+When optional NO-ERROR Don't throw an error if we can't run tests."
+ (interactive)
+ (if (or (not pulse-flag) (not (pulse-available-p)))
+ (if no-error
+ nil
+ (error (concat "Pulse test only works on versions of Emacs"
+ " that support pulsing")))
+ ;; Run the tests
+ (when (interactive-p)
+ (message "<Press a key> Pulse one line.")
+ (read-char))
+ (pulse-momentary-highlight-one-line (point))
+ (when (interactive-p)
+ (message "<Press a key> Pulse a region.")
+ (read-char))
+ (pulse-momentary-highlight-region (point)
+ (save-excursion
+ (condition-case nil
+ (forward-char 30)
+ (error nil))
+ (point)))
+ (when (interactive-p)
+ (message "<Press a key> Pulse line a specific color.")
+ (read-char))
+ (pulse-momentary-highlight-one-line (point) 'modeline)
+ (when (interactive-p)
+ (message "<Press a key> Pulse a pre-existing overlay.")
+ (read-char))
+ (let* ((start (point-at-bol))
+ (end (save-excursion
+ (end-of-line)
+ (when (not (eobp))
+ (forward-char 1))
+ (point)))
+ (o (make-overlay start end))
+ )
+ (pulse-momentary-highlight-overlay o)
+ (if (overlay-buffer o)
+ (delete-overlay o)
+ (error "Non-temporary overlay was deleted!"))
+ )
+ (when (interactive-p)
+ (message "Done!"))))
+
+(provide 'cedet-utests)
+
+;;; cedet-utests.el ends here
Index: ede-tests.el
===================================================================
RCS file: ede-tests.el
diff -N ede-tests.el
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ ede-tests.el 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,58 @@
+;;; From ede-locate:
+
+(require 'ede/locate)
+
+;;; TESTS
+;;
+;; Some testing routines.
+(defun ede-locate-test-locate (file)
+ "Test EDE Locate on FILE using LOCATE type.
+The search is done with the current EDE root."
+ (interactive "sFile: ")
+ (let ((loc (ede-locate-locate
+ "test"
+ :root (ede-project-root-directory
+ (ede-toplevel)))))
+ (data-debug-new-buffer "*EDE Locate ADEBUG*")
+ (ede-locate-file-in-project loc file)
+ (data-debug-insert-object-slots loc "]"))
+ )
+
+(defun ede-locate-test-global (file)
+ "Test EDE Locate on FILE using GNU Global type.
+The search is done with the current EDE root."
+ (interactive "sFile: ")
+ (let ((loc (ede-locate-global
+ "test"
+ :root (ede-project-root-directory
+ (ede-toplevel)))))
+ (data-debug-new-buffer "*EDE Locate ADEBUG*")
+ (ede-locate-file-in-project loc file)
+ (data-debug-insert-object-slots loc "]"))
+ )
+
+(defun ede-locate-test-idutils (file)
+ "Test EDE Locate on FILE using ID Utils type.
+The search is done with the current EDE root."
+ (interactive "sFile: ")
+ (let ((loc (ede-locate-idutils
+ "test"
+ :root (ede-project-root-directory
+ (ede-toplevel)))))
+ (data-debug-new-buffer "*EDE Locate ADEBUG*")
+ (ede-locate-file-in-project loc file)
+ (data-debug-insert-object-slots loc "]"))
+ )
+
+(defun ede-locate-test-cscope (file)
+ "Test EDE Locate on FILE using CScope type.
+The search is done with the current EDE root."
+ (interactive "sFile: ")
+ (let ((loc (ede-locate-cscope
+ "test"
+ :root (ede-project-root-directory
+ (ede-toplevel)))))
+ (data-debug-new-buffer "*EDE Locate ADEBUG*")
+ (ede-locate-file-in-project loc file)
+ (data-debug-insert-object-slots loc "]"))
+ )
Index: semantic-ia-utest.el
===================================================================
RCS file: semantic-ia-utest.el
diff -N semantic-ia-utest.el
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ semantic-ia-utest.el 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,509 @@
+;;; semantic-ia-utest.el --- Analyzer unit tests
+
+;; Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+
+;; Author: Eric M. Ludlam <address@hidden>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; Use marked-up files in the test directory and run the analyzer
+;; on them. Make sure the answers are correct.
+;;
+;; Each file has cursor keys in them of the form:
+;; // -#- ("ans1" "ans2" )
+;; where # is 1, 2, 3, etc, and some sort of answer list.
+
+;;; Code:
+(require 'semantic)
+(require 'semantic/analyze)
+(require 'semantic/analyze/refs)
+(require 'semantic/symref)
+(require 'semantic/symref/filter)
+
+(load-file "cedet-utests.el")
+
+(defvar semantic-ia-utest-file-list
+ '(
+ "tests/testdoublens.cpp"
+ "tests/testsubclass.cpp"
+ "tests/testtypedefs.cpp"
+ "tests/teststruct.cpp"
+ "tests/testtemplates.cpp"
+ "tests/testfriends.cpp"
+ "tests/testusing.cpp"
+ "tests/testnsp.cpp"
+ "tests/testsppcomplete.c"
+ "tests/testvarnames.c"
+ "tests/testjavacomp.java"
+ )
+ "List of files with analyzer completion test points.")
+
+(defvar semantic-ia-utest-error-log-list nil
+ "List of errors occuring during a run.")
+
+;;;###autoload
+(defun semantic-ia-utest (&optional arg)
+ "Run the semantic ia unit test against stored sources.
+Argument ARG specifies which set of tests to run.
+ 1 - ia utests
+ 2 - regs utests
+ 3 - symrefs utests
+ 4 - symref count utests"
+ (interactive "P")
+ (save-excursion
+
+ (let ((fl semantic-ia-utest-file-list)
+ (semantic-ia-utest-error-log-list nil)
+ )
+
+ (cedet-utest-log-setup "ANALYZER")
+
+ (set-buffer (semantic-find-file-noselect
+ (or (locate-library "semantic-ia-utest.el")
+ "semantic-ia-utest.el")))
+
+ (while fl
+
+ ;; Make sure we have the files we think we have.
+ (when (not (file-exists-p (car fl)))
+ (error "Cannot find unit test file: %s" (car fl)))
+
+ ;; Run the tests.
+ (let ((fb (find-buffer-visiting (car fl)))
+ (b (semantic-find-file-noselect (car fl) t)))
+
+ ;; Run the test on it.
+ (save-excursion
+ (set-buffer b)
+
+ ;; This line will also force the include, scope, and typecache.
+ (semantic-clear-toplevel-cache)
+ ;; Force tags to be parsed.
+ (semantic-fetch-tags)
+
+ (semantic-ia-utest-log " ** Starting tests in %s"
+ (buffer-name))
+
+ (when (or (not arg) (= arg 1))
+ (semantic-ia-utest-buffer))
+
+ (when (or (not arg) (= arg 2))
+ (set-buffer b)
+ (semantic-ia-utest-buffer-refs))
+
+ (when (or (not arg) (= arg 3))
+ (set-buffer b)
+ (semantic-sr-utest-buffer-refs))
+
+ (when (or (not arg) (= arg 4))
+ (set-buffer b)
+ (semantic-src-utest-buffer-refs))
+
+ (semantic-ia-utest-log " ** Completed tests in %s\n"
+ (buffer-name))
+ )
+
+ ;; If it wasn't already in memory, whack it.
+ (when (not fb)
+ (kill-buffer b))
+ )
+ (setq fl (cdr fl)))
+
+ (cedet-utest-log-shutdown
+ "ANALYZER"
+ (when semantic-ia-utest-error-log-list
+ (format "%s Failures found."
+ (length semantic-ia-utest-error-log-list))))
+ (when semantic-ia-utest-error-log-list
+ (error "Failures found during analyzer unit tests"))
+ ))
+ )
+
+(defun semantic-ia-utest-buffer ()
+ "Run analyzer completion unit-test pass in the current buffer."
+
+ (let* ((idx 1)
+ (regex-p nil)
+ (regex-a nil)
+ (p nil)
+ (a nil)
+ (pass nil)
+ (fail nil)
+ (actual nil)
+ (desired nil)
+ ;; Exclude unpredictable system files in the
+ ;; header include list.
+ (semanticdb-find-default-throttle
+ (remq 'system semanticdb-find-default-throttle))
+ )
+ ;; Keep looking for test points until we run out.
+ (while (save-excursion
+ (setq regex-p (concat "//\\s-*-" (number-to-string idx) "-" )
+ regex-a (concat "//\\s-*#" (number-to-string idx) "#" ))
+ (goto-char (point-min))
+ (save-match-data
+ (when (re-search-forward regex-p nil t)
+ (setq p (match-beginning 0))))
+ (save-match-data
+ (when (re-search-forward regex-a nil t)
+ (setq a (match-end 0))))
+ (and p a))
+
+ (save-excursion
+
+ (goto-char p)
+
+ (let* ((ctxt (semantic-analyze-current-context))
+ (acomp
+ (condition-case nil
+ (semantic-analyze-possible-completions ctxt)
+ (error nil))))
+ (setq actual (mapcar 'semantic-tag-name acomp)))
+
+ (goto-char a)
+
+ (let ((bss (buffer-substring-no-properties (point) (point-at-eol))))
+ (condition-case nil
+ (setq desired (read bss))
+ (error (setq desired (format " FAILED TO PARSE: %S"
+ bss)))))
+
+ (if (equal actual desired)
+ (setq pass (cons idx pass))
+ (setq fail (cons idx fail))
+ (semantic-ia-utest-log
+ " Failed %d. Desired: %S Actual %S"
+ idx desired actual)
+ (add-to-list 'semantic-ia-utest-error-log-list
+ (list (buffer-name) idx desired actual)
+ )
+
+ )
+ )
+
+ (setq p nil a nil)
+ (setq idx (1+ idx)))
+
+ (if fail
+ (progn
+ (semantic-ia-utest-log
+ " Unit tests (completions) failed tests %S"
+ (reverse fail))
+ )
+ (semantic-ia-utest-log " Unit tests (completions) passed (%d total)"
+ (- idx 1)))
+
+ ))
+
+(defun semantic-ia-utest-buffer-refs ()
+ "Run a analyze-refs unit-test pass in the current buffer."
+
+ (let* ((idx 1)
+ (regex-p nil)
+ (p nil)
+ (pass nil)
+ (fail nil)
+ ;; Exclude unpredictable system files in the
+ ;; header include list.
+ (semanticdb-find-default-throttle
+ (remq 'system semanticdb-find-default-throttle))
+ )
+ ;; Keep looking for test points until we run out.
+ (while (save-excursion
+ (setq regex-p (concat "//\\s-*\\^" (number-to-string idx) "^" )
+ )
+ (goto-char (point-min))
+ (save-match-data
+ (when (re-search-forward regex-p nil t)
+ (setq p (match-beginning 0))))
+ p)
+
+ (save-excursion
+
+ (goto-char p)
+ (forward-char -1)
+
+ (let* ((ct (semantic-current-tag))
+ (refs (semantic-analyze-tag-references ct))
+ (impl (semantic-analyze-refs-impl refs t))
+ (proto (semantic-analyze-refs-proto refs t))
+ (pf nil)
+ )
+ (setq
+ pf
+ (catch 'failed
+ (if (and impl proto (car impl) (car proto))
+ (let (ct2 ref2 impl2 proto2
+ newstart)
+ (cond
+ ((semantic-equivalent-tag-p (car impl) ct)
+ ;; We are on an IMPL. Go To the proto, and find matches.
+ (semantic-go-to-tag (car proto))
+ (setq newstart (car proto))
+ )
+ ((semantic-equivalent-tag-p (car proto) ct)
+ ;; We are on a PROTO. Go to the imple, and find matches
+ (semantic-go-to-tag (car impl))
+ (setq newstart (car impl))
+ )
+ (t
+ ;; No matches is a fail.
+ (throw 'failed t)
+ ))
+ ;; Get the new tag, does it match?
+ (setq ct2 (semantic-current-tag))
+
+ ;; Does it match?
+ (when (not (semantic-equivalent-tag-p ct2 newstart))
+ (throw 'failed t))
+
+ ;; Can we double-jump?
+ (setq ref2 (semantic-analyze-tag-references ct)
+ impl2 (semantic-analyze-refs-impl ref2 t)
+ proto2 (semantic-analyze-refs-proto ref2 t))
+
+ (when (or (not (and impl2 proto2))
+ (not
+ (and (semantic-equivalent-tag-p
+ (car impl) (car impl2))
+ (semantic-equivalent-tag-p
+ (car proto) (car proto2)))))
+ (throw 'failed t))
+ )
+
+ ;; Else, no matches at all, so another fail.
+ (throw 'failed t)
+ )))
+
+ (if (not pf)
+ ;; We passed
+ (setq pass (cons idx pass))
+ ;; We failed.
+ (setq fail (cons idx fail))
+ (semantic-ia-utest-log
+ " Failed %d. For %s (Num impls %d) (Num protos %d)"
+ idx (if ct (semantic-tag-name ct) "<No tag found>")
+ (length impl) (length proto))
+ (add-to-list 'semantic-ia-utest-error-log-list
+ (list (buffer-name) idx)
+ )
+ ))
+
+ (setq p nil)
+ (setq idx (1+ idx))
+
+ ))
+
+ (if fail
+ (progn
+ (semantic-ia-utest-log
+ " Unit tests (refs) failed tests")
+ )
+ (semantic-ia-utest-log " Unit tests (refs) passed (%d total)"
+ (- idx 1)))
+
+ ))
+
+(defun semantic-sr-utest-buffer-refs ()
+ "Run a symref unit-test pass in the current buffer."
+
+ ;; This line will also force the include, scope, and typecache.
+ (semantic-clear-toplevel-cache)
+ ;; Force tags to be parsed.
+ (semantic-fetch-tags)
+
+ (let* ((idx 1)
+ (tag nil)
+ (regex-p nil)
+ (desired nil)
+ (actual-result nil)
+ (actual nil)
+ (pass nil)
+ (fail nil)
+ (symref-tool-used nil)
+ ;; Exclude unpredictable system files in the
+ ;; header include list.
+ (semanticdb-find-default-throttle
+ (remq 'system semanticdb-find-default-throttle))
+ )
+ ;; Keep looking for test points until we run out.
+ (while (save-excursion
+ (setq regex-p (concat "//\\s-*\\%" (number-to-string idx) "%" )
+ )
+ (goto-char (point-min))
+ (save-match-data
+ (when (re-search-forward regex-p nil t)
+ (setq tag (semantic-current-tag))
+ (goto-char (match-end 0))
+ (setq desired (read (buffer-substring (point) (point-at-eol))))
+ ))
+ tag)
+
+ (setq actual-result (semantic-symref-find-references-by-name
+ (semantic-tag-name tag) 'target
+ 'symref-tool-used))
+
+ (if (not actual-result)
+ (progn
+ (setq fail (cons idx fail))
+ (semantic-ia-utest-log
+ " Failed FNames %d: No results." idx)
+ (semantic-ia-utest-log
+ " Failed Tool: %s" (object-name symref-tool-used))
+
+ (add-to-list 'semantic-ia-utest-error-log-list
+ (list (buffer-name) idx)
+ )
+ )
+
+ (setq actual (list (sort (mapcar
+ 'file-name-nondirectory
+ (semantic-symref-result-get-files
actual-result))
+ 'string<)
+ (sort
+ (mapcar
+ 'semantic-format-tag-canonical-name
+ (semantic-symref-result-get-tags actual-result))
+ 'string<)))
+
+
+ (if (equal desired actual)
+ ;; We passed
+ (setq pass (cons idx pass))
+ ;; We failed.
+ (setq fail (cons idx fail))
+ (when (not (equal (car actual) (car desired)))
+ (semantic-ia-utest-log
+ " Failed FNames %d: Actual: %S Desired: %S"
+ idx (car actual) (car desired))
+ (semantic-ia-utest-log
+ " Failed Tool: %s" (object-name symref-tool-used))
+ )
+ (when (not (equal (car (cdr actual)) (car (cdr desired))))
+ (semantic-ia-utest-log
+ " Failed TNames %d: Actual: %S Desired: %S"
+ idx (car (cdr actual)) (car (cdr desired)))
+ (semantic-ia-utest-log
+ " Failed Tool: %s" (object-name symref-tool-used))
+ )
+ (add-to-list 'semantic-ia-utest-error-log-list
+ (list (buffer-name) idx)
+ )
+ ))
+
+ (setq idx (1+ idx))
+ (setq tag nil))
+
+ (if fail
+ (progn
+ (semantic-ia-utest-log
+ " Unit tests (symrefs) failed tests")
+ )
+ (semantic-ia-utest-log " Unit tests (symrefs) passed (%d total)"
+ (- idx 1)))
+
+ ))
+
+(defun semantic-src-utest-buffer-refs ()
+ "Run a sym-ref counting unit-test pass in the current buffer."
+
+ ;; This line will also force the include, scope, and typecache.
+ (semantic-clear-toplevel-cache)
+ ;; Force tags to be parsed.
+ (semantic-fetch-tags)
+
+ (let* ((idx 1)
+ (start nil)
+ (regex-p nil)
+ (desired nil)
+ (actual nil)
+ (pass nil)
+ (fail nil)
+ ;; Exclude unpredictable system files in the
+ ;; header include list.
+ (semanticdb-find-default-throttle
+ (remq 'system semanticdb-find-default-throttle))
+ )
+ ;; Keep looking for test points until we run out.
+ (while (save-excursion
+ (setq regex-p (concat "//\\s-*@"
+ (number-to-string idx)
+ "@\\s-+\\(\\w+\\)" ))
+ (goto-char (point-min))
+ (save-match-data
+ (when (re-search-forward regex-p nil t)
+ (goto-char (match-beginning 1))
+ (setq desired (read (buffer-substring (point) (point-at-eol))))
+ (setq start (match-beginning 0))
+ (goto-char start)
+ (setq actual (semantic-symref-test-count-hits-in-tag))
+ start)))
+
+ (if (not actual)
+ (progn
+ (setq fail (cons idx fail))
+ (semantic-ia-utest-log
+ " Failed symref count %d: No results." idx)
+
+ (add-to-list 'semantic-ia-utest-error-log-list
+ (list (buffer-name) idx)
+ )
+ )
+
+ (if (equal desired actual)
+ ;; We passed
+ (setq pass (cons idx pass))
+ ;; We failed.
+ (setq fail (cons idx fail))
+ (when (not (equal actual desired))
+ (semantic-ia-utest-log
+ " Failed symref count %d: Actual: %S Desired: %S"
+ idx actual desired)
+ )
+
+ (add-to-list 'semantic-ia-utest-error-log-list
+ (list (buffer-name) idx)
+ )
+ ))
+
+ (setq idx (1+ idx))
+ )
+
+ (if fail
+ (progn
+ (semantic-ia-utest-log
+ " Unit tests (symrefs counter) failed tests")
+ )
+ (semantic-ia-utest-log " Unit tests (symrefs counter) passed (%d
total)"
+ (- idx 1)))
+
+ ))
+
+(defun semantic-ia-utest-start-log ()
+ "Start up a testlog for a run."
+ ;; Redo w/ CEDET utest framework.
+ (cedet-utest-log-start "semantic: analyzer tests"))
+
+(defun semantic-ia-utest-log (&rest args)
+ "Log some test results.
+Pass ARGS to format to create the log message."
+ ;; Forward to CEDET utest framework.
+ (apply 'cedet-utest-log args))
+
+(provide 'semantic-ia-utest)
+;;; semantic-ia-utest.el ends here
Index: semantic-tests.el
===================================================================
RCS file: semantic-tests.el
diff -N semantic-tests.el
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ semantic-tests.el 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,436 @@
+;;; semantic-utest.el --- Miscellaneous Semantic tests.
+
+;;; Copyright (C) 2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
+
+;; Author: Eric M. Ludlam <address@hidden>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Originally, there are many test functions scattered among the
+;; Semantic source files. This file consolidates them.
+
+(require 'data-debug)
+
+;;; From semantic-complete
+
+(require 'semantic/complete)
+
+(defun semantic-complete-test ()
+ "Test completion mechanisms."
+ (interactive)
+ (message "%S"
+ (semantic-format-tag-prototype
+ (semantic-complete-read-tag-project "Symbol: "))))
+
+;;; From semanticdb-ebrowse
+
+(require 'semantic/db-ebrowse)
+
+(defun semanticdb-ebrowse-run-tests ()
+ "Run some tests of the semanticdb-ebrowse system.
+All systems are different. Ask questions along the way."
+ (interactive)
+ (let ((doload nil))
+ (when (y-or-n-p "Create a system database to test with? ")
+ (call-interactively 'semanticdb-create-ebrowse-database)
+ (setq doload t))
+ ;; Should we load in caches
+ (when (if doload
+ (y-or-n-p "New database created. Reload system databases? ")
+ (y-or-n-p "Load in all system databases? "))
+ (semanticdb-load-ebrowse-caches)))
+ ;; Ok, databases were creatd. Lets try some searching.
+ (when (not (or (eq major-mode 'c-mode)
+ (eq major-mode 'c++-mode)))
+ (error "Please make your default buffer be a C or C++ file, then
+run the test again..")))
+
+(defun semanticdb-ebrowse-dump ()
+ "Find the first loaded ebrowse table, and dump out the contents."
+ (interactive)
+ (let ((db semanticdb-database-list)
+ (ab nil))
+ (while db
+ (when (semanticdb-project-database-ebrowse-p (car db))
+ (setq ab (data-debug-new-buffer "*EBROWSE Database*"))
+ (data-debug-insert-thing (car db) "*" "")
+ (setq db nil)
+ )
+ (setq db (cdr db)))))
+
+;;; From semanticdb-global:
+
+(require 'semantic/db-global)
+
+(defvar semanticdb-test-gnu-global-startfile
"~/src/global-5.7.3/global/global.c"
+ "File to use for testing.")
+
+(defun semanticdb-test-gnu-global (searchfor &optional standardfile)
+ "Test the GNU Global semanticdb.
+Argument SEARCHFOR is the text to search for.
+If optional arg STANDARDFILE is non nil, use a standard file w/ global
enabled."
+ (interactive "sSearch For Tag: \nP")
+
+ (require 'data-debug)
+ (save-excursion
+ (when standardfile
+ (save-match-data
+ (set-buffer (find-file-noselect semanticdb-test-gnu-global-startfile))))
+
+ (condition-case err
+ (semanticdb-enable-gnu-global-in-buffer)
+ (error (if standardfile
+ (error err)
+ (save-match-data
+ (set-buffer (find-file-noselect
semanticdb-test-gnu-global-startfile)))
+ (semanticdb-enable-gnu-global-in-buffer))))
+
+ (let* ((db (semanticdb-project-database-global "global"))
+ (tab (semanticdb-file-table db (buffer-file-name)))
+ (result (semanticdb-deep-find-tags-for-completion-method tab
searchfor))
+ )
+ (data-debug-new-buffer "*SemanticDB Gnu Global Result*")
+ (data-debug-insert-thing result "?" ""))))
+
+;;; From semantic-find
+
+(require 'semantic/find)
+
+(defun semantic-find-benchmark ()
+ "Run some simple benchmarks to see how we are doing.
+Optional argument ARG is the number of iterations to run."
+ (interactive)
+ (require 'benchmark)
+ (let ((f-name nil)
+ (b-name nil)
+ (f-comp)
+ (b-comp)
+ (f-regex)
+ )
+ (garbage-collect)
+ (setq f-name
+ (benchmark-run-compiled
+ 1000 (semantic-find-first-tag-by-name "class3"
+ "test/test.cpp")))
+ (garbage-collect)
+ (setq b-name
+ (benchmark-run-compiled
+ 1000 (semantic-brute-find-first-tag-by-name "class3"
+ "test/test.cpp")))
+ (garbage-collect)
+ (setq f-comp
+ (benchmark-run-compiled
+ 1000 (semantic-find-tags-for-completion "method"
+ "test/test.cpp")))
+ (garbage-collect)
+ (setq b-comp
+ (benchmark-run-compiled
+ 1000 (semantic-brute-find-tag-by-name-regexp "^method"
+ "test/test.cpp")))
+ (garbage-collect)
+ (setq f-regex
+ (benchmark-run-compiled
+ 1000 (semantic-find-tags-by-name-regexp "^method"
+ "test/test.cpp")))
+
+ (message "Name [new old] [ %.3f %.3f ] Complete [newc/new old] [ %.3f/%.3f
%.3f ]"
+ (car f-name) (car b-name)
+ (car f-comp) (car f-regex)
+ (car b-comp))
+ ))
+
+;;; From semantic-format
+
+(require 'semantic/format)
+
+(defun semantic-test-all-format-tag-functions (&optional arg)
+ "Test all outputs from `semantic-format-tag-functions'.
+Output is generated from the function under `point'.
+Optional argument ARG specifies not to use color."
+ (interactive "P")
+ (semantic-fetch-tags)
+ (let* ((tag (semantic-current-tag))
+ (par (semantic-current-tag-parent))
+ (fns semantic-format-tag-functions))
+ (with-output-to-temp-buffer "*format-tag*"
+ (princ "Tag->format function tests:")
+ (while fns
+ (princ "\n")
+ (princ (car fns))
+ (princ ":\n ")
+ (let ((s (funcall (car fns) tag par (not arg))))
+ (save-excursion
+ (set-buffer "*format-tag*")
+ (goto-char (point-max))
+ (insert s)))
+ (setq fns (cdr fns))))
+ ))
+
+;;; From semantic-fw:
+
+(require 'semantic/fw)
+
+(defun semantic-test-data-cache ()
+ "Test the data cache."
+ (interactive)
+ (let ((data '(a b c)))
+ (save-excursion
+ (set-buffer (get-buffer-create " *semantic-test-data-cache*"))
+ (erase-buffer)
+ (insert "The Moose is Loose")
+ (goto-char (point-min))
+ (semantic-cache-data-to-buffer (current-buffer) (point) (+ (point) 5)
+ data 'moose 'exit-cache-zone)
+ (if (equal (semantic-get-cache-data 'moose) data)
+ (message "Successfully retrieved cached data.")
+ (error "Failed to retrieve cached data")))))
+
+(defun semantic-test-throw-on-input ()
+ "Test that throw on input will work."
+ (interactive)
+ (semantic-throw-on-input 'done-die)
+ (message "Exit Code: %s"
+ (semantic-exit-on-input 'testing
+ (let ((inhibit-quit nil)
+ (message-log-max nil))
+ (while t
+ (message "Looping ... press a key to test")
+ (semantic-throw-on-input 'test-inner-loop))
+ 'exit)))
+ (when (input-pending-p)
+ (if (fboundp 'read-event)
+ (read-event)
+ (read-char))))
+
+;;; From semantic-idle:
+
+(require 'semantic/idle)
+
+(defun semantic-idle-pnf-test ()
+ "Test `semantic-idle-scheduler-work-parse-neighboring-files' and time it."
+ (interactive)
+ (let ((start (current-time))
+ (junk (semantic-idle-scheduler-work-parse-neighboring-files))
+ (end (current-time)))
+ (message "Work took %.2f seconds." (semantic-elapsed-time start end))))
+
+;;; From semantic-lex:
+
+(require 'semantic/lex)
+
+(defun semantic-lex-test-full-depth (arg)
+ "Test the semantic lexer in the current buffer parsing through lists.
+Usually the lexer parses
+If universal argument ARG, then try the whole buffer."
+ (interactive "P")
+ (let* ((start (current-time))
+ (result (semantic-lex
+ (if arg (point-min) (point))
+ (point-max)
+ 100))
+ (end (current-time)))
+ (message "Elapsed Time: %.2f seconds."
+ (semantic-elapsed-time start end))
+ (pop-to-buffer "*Lexer Output*")
+ (require 'pp)
+ (erase-buffer)
+ (insert (pp-to-string result))
+ (goto-char (point-min))))
+
+(defun semantic-lex-test-region (beg end)
+ "Test the semantic lexer in the current buffer.
+Analyze the area between BEG and END."
+ (interactive "r")
+ (let ((result (semantic-lex beg end)))
+ (pop-to-buffer "*Lexer Output*")
+ (require 'pp)
+ (erase-buffer)
+ (insert (pp-to-string result))
+ (goto-char (point-min))))
+
+;;; From semantic-lex-spp:
+
+(require 'semantic/lex-spp)
+
+(defun semantic-lex-spp-write-test ()
+ "Test the semantic tag writer against the current buffer."
+ (interactive)
+ (with-output-to-temp-buffer "*SPP Write Test*"
+ (semantic-lex-spp-table-write-slot-value
+ (semantic-lex-spp-save-table))))
+
+(defun semantic-lex-spp-write-utest ()
+ "Unit test using the test spp file to test the slot write fcn."
+ (interactive)
+ (let* ((sem (locate-library "semantic-lex-spp.el"))
+ (dir (file-name-directory sem)))
+ (save-excursion
+ (set-buffer (find-file-noselect
+ (expand-file-name "tests/testsppreplace.c"
+ dir)))
+ (semantic-lex-spp-write-test))))
+
+;;; From semantic-tag-write:
+
+;;; TESTING.
+
+(require 'semantic/tag-write)
+
+(defun semantic-tag-write-test ()
+ "Test the semantic tag writer against the tag under point."
+ (interactive)
+ (with-output-to-temp-buffer "*Tag Write Test*"
+ (semantic-tag-write-one-tag (semantic-current-tag))))
+
+(defun semantic-tag-write-list-test ()
+ "Test the semantic tag writer against the tag under point."
+ (interactive)
+ (with-output-to-temp-buffer "*Tag Write Test*"
+ (semantic-tag-write-tag-list (semantic-fetch-tags))))
+
+;;; From semantic-symref-filter:
+
+(require 'semantic/symref/filter)
+
+(defun semantic-symref-test-count-hits-in-tag ()
+ "Lookup in the current tag the symbol under point.
+the count all the other references to the same symbol within the
+tag that contains point, and return that."
+ (interactive)
+ (let* ((ctxt (semantic-analyze-current-context))
+ (target (car (reverse (oref ctxt prefix))))
+ (tag (semantic-current-tag))
+ (start (current-time))
+ (Lcount 0))
+ (when (semantic-tag-p target)
+ (semantic-symref-hits-in-region
+ target (lambda (start end prefix) (setq Lcount (1+ Lcount)))
+ (semantic-tag-start tag)
+ (semantic-tag-end tag))
+ (when (interactive-p)
+ (message "Found %d occurances of %s in %.2f seconds"
+ Lcount (semantic-tag-name target)
+ (semantic-elapsed-time start (current-time))))
+ Lcount)))
+
+;;; From bovine-gcc:
+
+(require 'semantic/bovine/gcc)
+
+;; Example output of "gcc -v"
+(defvar semantic-gcc-test-strings
+ '(;; My old box:
+ "Reading specs from /usr/lib/gcc-lib/i386-redhat-linux/3.2.2/specs
+Configured with: ../configure --prefix=/usr --mandir=/usr/share/man
--infodir=/usr/share/info --enable-shared --enable-threads=posix
--disable-checking --with-system-zlib --enable-__cxa_atexit
--host=i386-redhat-linux
+Thread model: posix
+gcc version 3.2.2 20030222 (Red Hat Linux 3.2.2-5)"
+ ;; Alex Ott:
+ "Using built-in specs.
+Target: i486-linux-gnu
+Configured with: ../src/configure -v --with-pkgversion='Ubuntu 4.3.1-9ubuntu1'
--with-bugurl=file:///usr/share/doc/gcc-4.3/README.Bugs
--enable-languages=c,c++,fortran,objc,obj-c++ --prefix=/usr --enable-shared
--with-system-zlib --libexecdir=/usr/lib --without-included-gettext
--enable-threads=posix --enable-nls --with-gxx-include-dir=/usr/include/c++/4.3
--program-suffix=-4.3 --enable-clocale=gnu --enable-libstdcxx-debug
--enable-objc-gc --enable-mpfr --enable-targets=all --enable-checking=release
--build=i486-linux-gnu --host=i486-linux-gnu --target=i486-linux-gnu
+Thread model: posix
+gcc version 4.3.1 (Ubuntu 4.3.1-9ubuntu1)"
+ ;; My debian box:
+ "Using built-in specs.
+Target: x86_64-unknown-linux-gnu
+Configured with: ../../../sources/gcc/configure
--prefix=/usr/local/glibc-2.3.6/x86_64/apps/gcc-4.2.3
--with-gmp=/usr/local/gcc/gmp --with-mpfr=/usr/local/gcc/mpfr
--enable-languages=c,c++,fortran
--with-as=/usr/local/glibc-2.3.6/x86_64/apps/gcc-4.2.3/bin/as
--with-ld=/usr/local/glibc-2.3.6/x86_64/apps/gcc-4.2.3/bin/ld --disable-multilib
+Thread model: posix
+gcc version 4.2.3"
+ ;; My mac:
+ "Using built-in specs.
+Target: i686-apple-darwin8
+Configured with: /private/var/tmp/gcc/gcc-5341.obj~1/src/configure
--disable-checking -enable-werror --prefix=/usr --mandir=/share/man
--enable-languages=c,objc,c++,obj-c++
--program-transform-name=/^[cg][^.-]*$/s/$/-4.0/
--with-gxx-include-dir=/include/c++/4.0.0 --with-slibdir=/usr/lib
--build=powerpc-apple-darwin8 --with-arch=pentium-m --with-tune=prescott
--program-prefix= --host=i686-apple-darwin8 --target=i686-apple-darwin8
+Thread model: posix
+gcc version 4.0.1 (Apple Computer, Inc. build 5341)"
+ ;; Ubuntu Intrepid
+ "Using built-in specs.
+Target: x86_64-linux-gnu
+Configured with: ../src/configure -v --with-pkgversion='Ubuntu
4.3.2-1ubuntu12' --with-bugurl=file:///usr/share/doc/gcc-4.3/README.Bugs
--enable-languages=c,c++,fortran,objc,obj-c++ --prefix=/usr --enable-shared
--with-system-zlib --libexecdir=/usr/lib --without-included-gettext
--enable-threads=posix --enable-nls --with-gxx-include-dir=/usr/include/c++/4.3
--program-suffix=-4.3 --enable-clocale=gnu --enable-libstdcxx-debug
--enable-objc-gc --enable-mpfr --enable-checking=release
--build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
+Thread model: posix
+gcc version 4.3.2 (Ubuntu 4.3.2-1ubuntu12)"
+ ;; Red Hat EL4
+ "Reading specs from /usr/lib/gcc/x86_64-redhat-linux/3.4.6/specs
+Configured with: ../configure --prefix=/usr --mandir=/usr/share/man
--infodir=/usr/share/info --enable-shared --enable-threads=posix
--disable-checking --with-system-zlib --enable-__cxa_atexit
--disable-libunwind-exceptions --enable-java-awt=gtk --host=x86_64-redhat-linux
+Thread model: posix
+gcc version 3.4.6 20060404 (Red Hat 3.4.6-10)"
+ ;; Red Hat EL5
+ "Using built-in specs.
+Target: x86_64-redhat-linux
+Configured with: ../configure --prefix=/usr --mandir=/usr/share/man
--infodir=/usr/share/info --enable-shared --enable-threads=posix
--enable-checking=release --with-system-zlib --enable-__cxa_atexit
--disable-libunwind-exceptions --enable-libgcj-multifile
--enable-languages=c,c++,objc,obj-c++,java,fortran,ada --enable-java-awt=gtk
--disable-dssi --enable-plugin
--with-java-home=/usr/lib/jvm/java-1.4.2-gcj-1.4.2.0/jre --with-cpu=generic
--host=x86_64-redhat-linux
+Thread model: posix
+gcc version 4.1.2 20080704 (Red Hat 4.1.2-44)"
+ ;; David Engster's german gcc on ubuntu 4.3
+ "Es werden eingebaute Spezifikationen verwendet.
+Ziel: i486-linux-gnu
+Konfiguriert mit: ../src/configure -v --with-pkgversion='Ubuntu
4.3.2-1ubuntu12' --with-bugurl=file:///usr/share/doc/gcc-4.3/README.Bugs
--enable-languages=c,c++,fortran,objc,obj-c++ --prefix=/usr --enable-shared
--with-system-zlib --libexecdir=/usr/lib --without-included-gettext
--enable-threads=posix --enable-nls --with-gxx-include-dir=/usr/include/c++/4.3
--program-suffix=-4.3 --enable-clocale=gnu --enable-libstdcxx-debug
--enable-objc-gc --enable-mpfr --enable-targets=all --enable-checking=release
--build=i486-linux-gnu --host=i486-linux-gnu --target=i486-linux-gnu
+Thread-Modell: posix
+gcc-Version 4.3.2 (Ubuntu 4.3.2-1ubuntu12)"
+ ;; Damien Deville bsd
+ "Using built-in specs.
+Target: i386-undermydesk-freebsd
+Configured with: FreeBSD/i386 system compiler
+Thread model: posix
+gcc version 4.2.1 20070719 [FreeBSD]"
+ )
+ "A bunch of sample gcc -v outputs from different machines.")
+
+(defvar semantic-gcc-test-strings-fail
+ '(;; A really old solaris box I found
+ "Reading specs from
/usr/local/gcc-2.95.2/lib/gcc-lib/sparc-sun-solaris2.6/2.95.2/specs
+gcc version 2.95.2 19991024 (release)"
+ )
+ "A bunch of sample gcc -v outputs that fail to provide the info we want.")
+
+(defun semantic-gcc-test-output-parser ()
+ "Test the output parser against some collected strings."
+ (interactive)
+ (let ((fail nil))
+ (dolist (S semantic-gcc-test-strings)
+ (let* ((fields (semantic-gcc-fields S))
+ (v (cdr (assoc 'version fields)))
+ (h (or (cdr (assoc 'target fields))
+ (cdr (assoc '--target fields))
+ (cdr (assoc '--host fields))))
+ (p (cdr (assoc '--prefix fields)))
+ )
+ ;; No longer test for prefixes.
+ (when (not (and v h))
+ (let ((strs (split-string S "\n")))
+ (message "Test failed on %S\nV H P:\n%S %S %S" (car strs) v h p))
+ (setq fail t))
+ ))
+ (dolist (S semantic-gcc-test-strings-fail)
+ (let* ((fields (semantic-gcc-fields S))
+ (v (cdr (assoc 'version fields)))
+ (h (or (cdr (assoc '--host fields))
+ (cdr (assoc 'target fields))))
+ (p (cdr (assoc '--prefix fields)))
+ )
+ (when (and v h p)
+ (message "Negative test failed on %S" S)
+ (setq fail t))
+ ))
+ (if (not fail) (message "Tests passed."))
+ ))
+
+(defun semantic-gcc-test-output-parser-this-machine ()
+ "Test the output parser against the machine currently running Emacs."
+ (interactive)
+ (let ((semantic-gcc-test-strings (list (semantic-gcc-query "gcc" "-v"))))
+ (semantic-gcc-test-output-parser))
+ )
Index: semantic-utest-c.el
===================================================================
RCS file: semantic-utest-c.el
diff -N semantic-utest-c.el
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ semantic-utest-c.el 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,72 @@
+;;; semantic-utest-c.el --- C based parsing tests.
+
+;; Copyright (C) 2008, 2009 Eric M. Ludlam
+
+;; Author: Eric M. Ludlam <address@hidden>
+;; X-RCS: $Id: semantic-utest-c.el,v 1.2 2009/09/28 23:23:31 cyd Exp $
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2, or (at
+;; your option) any later version.
+
+;; This program is distributed in the hope that it will be useful, but
+;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+;; General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program; see the file COPYING. If not, write to
+;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+;;
+;; Run some C based parsing tests.
+
+(require 'semantic)
+
+(defvar semantic-utest-c-comparisons
+ '( ("testsppreplace.c" . "testsppreplaced.c")
+ )
+ "List of files to parse and compare against eachother.")
+
+;;; Code:
+;;;###autoload
+(defun semantic-utest-c ()
+ "Run parsing test for C from the test directory."
+ (interactive)
+ (dolist (fp semantic-utest-c-comparisons)
+ (let* ((sem (locate-library "semantic"))
+ (sdir (file-name-directory sem))
+ (semantic-lex-c-nested-namespace-ignore-second nil)
+ (tags-actual
+ (save-excursion
+ (set-buffer (find-file-noselect (expand-file-name (concat
"tests/" (car fp)) sdir)))
+ (semantic-clear-toplevel-cache)
+ (semantic-fetch-tags)))
+ (tags-expected
+ (save-excursion
+ (set-buffer (find-file-noselect (expand-file-name (concat
"tests/" (cdr fp)) sdir)))
+ (semantic-clear-toplevel-cache)
+ (semantic-fetch-tags))))
+ ;; Now that we have the tags, compare them for SPP accuracy.
+ (dolist (tag tags-actual)
+ (if (and (semantic-tag-of-class-p tag 'variable)
+ (semantic-tag-variable-constant-p tag))
+ nil ; skip the macros.
+ (if (semantic-tag-similar-with-subtags-p tag (car tags-expected))
+ (setq tags-expected (cdr tags-expected))
+ (with-mode-local c-mode
+ (error "Found: >> %s << Expected: >> %s <<"
+ (semantic-format-tag-prototype tag nil t)
+ (semantic-format-tag-prototype (car tags-expected) nil t)
+ )))
+ ))
+ ;; Passed?
+ (message "PASSED!")
+ )))
+
+
+(provide 'semantic-utest-c)
+;;; semantic-utest-c.el ends here
Index: semantic-utest.el
===================================================================
RCS file: semantic-utest.el
diff -N semantic-utest.el
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ semantic-utest.el 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,867 @@
+;;; semantic-utest.el --- Tests for semantic's parsing system.
+
+;;; Copyright (C) 2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
+
+;; Author: Eric M. Ludlam <address@hidden>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; Semantic's parsing and partial parsing system is pretty complex.
+;; These unit tests attempt to emulate semantic's partial reparsing
+;; and full reparsing system, and anything else I may feel the urge
+;; to write a test for.
+
+(require 'semantic)
+
+(load-file "cedet-utests.el")
+
+(defvar semantic-utest-temp-directory (if (fboundp 'temp-directory)
+ (temp-directory)
+ temporary-file-directory)
+ "Temporary directory to use when creating files.")
+
+(defun semantic-utest-fname (name)
+ "Create a filename for NAME in /tmp."
+ (expand-file-name name semantic-utest-temp-directory))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Data for C tests
+
+(defvar semantic-utest-C-buffer-contents
+ "/* Test file for C language for Unit Tests */
+
+#include <stdio.h>
+#include \"sutest.h\"
+
+struct mystruct1 {
+ int slot11;
+ char slot12;
+ float slot13;
+};
+
+int var1;
+
+float funp1(char arg11, char arg12);
+
+char fun2(int arg_21, int arg_22) /*1*/
+{
+ struct mystruct1 *ms1 = malloc(sizeof(struct mystruct1));
+
+ char sv = calc_sv(var1);
+
+ if (var1 == 0) {
+ sv = 1;
+ } else if (arg_21 == 0) {
+ sv = 2;
+ } else if (arg_22 == 0) {
+ sv = 3;
+ } else {
+ sv = 4;
+ }
+
+ printf(\"SV = %d\\n\", sv);
+
+ /* Memory Leak */
+ ms1.slot1 = sv;
+
+ return 'A' + sv;
+}
+"
+ "Contents of a C buffer initialized by this unit test.
+Be sure to change `semantic-utest-C-name-contents' when you
+change this variable.")
+
+(defvar semantic-utest-C-h-buffer-contents
+ "/* Test file for C language header file for Unit Tests */
+
+int calc_sv(int);
+
+"
+ "Contents of a C header file buffer initialized by this unit test.")
+
+(defvar semantic-utest-C-filename (semantic-utest-fname "sutest.c")
+ "File to open and erase during this test for C.")
+
+(defvar semantic-utest-C-filename-h
+ (concat (file-name-sans-extension semantic-utest-C-filename)
+ ".h")
+ "Header file filename for C")
+
+
+(defvar semantic-utest-C-name-contents
+ '(("stdio.h" include
+ (:system-flag t)
+ nil (overlay 48 66 "sutest.c"))
+ ("sutest.h" include nil nil (overlay 67 86 "sutest.c"))
+ ("mystruct1" type
+ (:members
+ (("slot11" variable
+ (:type "int")
+ (reparse-symbol classsubparts)
+ (overlay 109 120 "sutest.c"))
+ ("slot12" variable
+ (:type "char")
+ (reparse-symbol classsubparts)
+ (overlay 123 135 "sutest.c"))
+ ("slot13" variable
+ (:type "float")
+ (reparse-symbol classsubparts)
+ (overlay 138 151 "sutest.c")))
+ :type "struct")
+ nil (overlay 88 154 "sutest.c"))
+ ("var1" variable
+ (:type "int")
+ nil (overlay 156 165 "sutest.c"))
+ ("funp1" function
+ (:prototype-flag t :arguments
+ (("arg11" variable
+ (:type "char")
+ (reparse-symbol arg-sub-list)
+ (overlay 179 190 "sutest.c"))
+ ("arg12" variable
+ (:type "char")
+ (reparse-symbol arg-sub-list)
+ (overlay 191 202 "sutest.c")))
+ :type "float")
+ nil (overlay 167 203 "sutest.c"))
+ ("fun2" function
+ (:arguments
+ (("arg_21" variable
+ (:type "int")
+ (reparse-symbol arg-sub-list)
+ (overlay 215 226 "sutest.c"))
+ ("arg_22" variable
+ (:type "int")
+ (reparse-symbol arg-sub-list)
+ (overlay 227 238 "sutest.c")))
+ :type "char")
+ nil (overlay 205 566 "sutest.c")))
+ "List of expected tag names for C.")
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Data for Python tests
+
+(defvar semantic-utest-Python-buffer-contents
+"
+def fun1(a,b,c):
+ return a
+
+def fun2(a,b,c): #1
+ return b
+
+"
+
+
+)
+; "pyhon test case. notice that python is indentation sensitive
+
+
+(defvar semantic-utest-Python-name-contents
+ '(("fun1" function
+ (:arguments
+ (("a" variable nil
+ (reparse-symbol function_parameters)
+ (overlay 10 11 "tst.py"))
+ ("b" variable nil
+ (reparse-symbol function_parameters)
+ (overlay 12 13 "tst.py"))
+ ("c" variable nil
+ (reparse-symbol function_parameters)
+ (overlay 14 15 "tst.py"))))
+ nil (overlay 1 31 "tst.py"))
+ ("fun2" function
+ (:arguments
+ (("a" variable nil
+ (reparse-symbol function_parameters)
+ (overlay 41 42 "tst.py"))
+ ("b" variable nil
+ (reparse-symbol function_parameters)
+ (overlay 43 44 "tst.py"))
+ ("c" variable nil
+ (reparse-symbol function_parameters)
+ (overlay 45 46 "tst.py"))))
+ nil (overlay 32 65 "tst.py")))
+
+ "List of expected tag names for Python.")
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Data for Java tests
+
+(defvar semantic-utest-Java-buffer-contents
+"
+class JavaTest{
+ void fun1(int a,int b){
+ return a;
+ }
+
+ void fun2(int a,int b){ //1
+ return b;
+ }
+
+}
+"
+)
+
+(defvar semantic-utest-Java-name-contents
+ '(("JavaTest" type
+ (:members
+ (("fun1" function
+ (:arguments
+ (("a" variable
+ (:type "int")
+ (reparse-symbol formal_parameters)
+ (overlay 30 35 "JavaTest.java"))
+ ("b" variable
+ (:type "int")
+ (reparse-symbol formal_parameters)
+ (overlay 36 41 "JavaTest.java")))
+ :type "void")
+ (reparse-symbol class_member_declaration)
+ (overlay 20 61 "JavaTest.java"))
+ ("fun2" function
+ (:arguments
+ (("a" variable
+ (:type "int")
+ (reparse-symbol formal_parameters)
+ (overlay 75 80 "JavaTest.java"))
+ ("b" variable
+ (:type "int")
+ (reparse-symbol formal_parameters)
+ (overlay 81 86 "JavaTest.java")))
+ :type "void")
+ (reparse-symbol class_member_declaration)
+ (overlay 65 110 "JavaTest.java")))
+ :type "class")
+ nil (overlay 2 113 "JavaTest.java")))
+ "List of expected tag names for Java."
+ )
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Data for Javascript tests
+
+(defvar semantic-utest-Javascript-buffer-contents
+"
+function fun1(a, b){
+ return a;
+ }
+
+function fun2(a,b){ //1
+ return b;
+ }
+"
+)
+
+
+(defvar semantic-utest-Javascript-name-contents
+ '(("fun1" function
+ (:arguments
+ (("a" variable nil
+ (reparse-symbol FormalParameterList)
+ (overlay 15 16 "tst.js"))
+ ("b" variable nil
+ (reparse-symbol FormalParameterList)
+ (overlay 18 19 "tst.js"))))
+ nil (overlay 1 39 "tst.js"))
+ ("fun2" function
+ (:arguments
+ (("a" variable nil
+ (reparse-symbol FormalParameterList)
+ (overlay 55 56 "tst.js"))
+ ("b" variable nil
+ (reparse-symbol FormalParameterList)
+ (overlay 57 58 "tst.js"))))
+ nil (overlay 41 82 "tst.js")))
+
+ "List of expected tag names for Javascript.")
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Data for Makefile tests
+
+(defvar semantic-utest-Makefile-buffer-contents
+"
+t1:
+\techo t1
+
+t2:t1 #1
+\techo t2
+
+
+"
+)
+
+
+(defvar semantic-utest-Makefile-name-contents
+ '(("t1" function nil nil (overlay 1 9 "Makefile"))
+ ("t2" function
+ (:arguments
+ ("t1"))
+ nil (overlay 18 28 "Makefile")))
+ "List of expected tag names for Makefile.")
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Data for Scheme tests
+
+(defvar semantic-utest-Scheme-buffer-contents
+ "
+ (define fun1 2)
+
+ (define fun2 3 ;1
+ )
+")
+
+(defvar semantic-utest-Scheme-name-contents
+ '(("fun1" variable
+ (:default-value ("2"))
+ nil (overlay 3 18 "tst.scm"))
+ ("fun2" variable
+ (:default-value ("3"))
+ nil (overlay 21 55 "tst.scm")))
+ )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Data for Html tests
+
+(defvar semantic-utest-Html-buffer-contents
+ "
+<html>
+ <body>
+ <h1>hello</h1>
+ </body><!--1-->
+</html>
+"
+ )
+
+(defvar semantic-utest-Html-name-contents
+ '(("hello" section
+ (:members
+ (("hello" section nil nil (overlay 21 24 "tst.html"))))
+ nil (overlay 10 15 "tst.html")))
+ )
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Data for PHP tests
+
+(defvar semantic-utest-PHP-buffer-contents
+ "<?php
+
+function fun1(){
+ return \"fun1\";
+}
+
+function fun2($arg1){
+ $output = \"argument to fun2: \" . $arg1;
+ return $output;
+}
+
+class aClass {
+ public function fun1($a, $b){
+ return $a;
+ }
+
+ public function fun2($a, $b){
+ return $b;
+ }
+}
+?> "
+ )
+
+(defvar semantic-utest-PHP-name-contents
+ '(("fun1" function nil
+ nil (overlay 9 45 "phptest.php"))
+ ("fun2" function
+ (:arguments (("$arg1" variable nil (reparse-symbol formal_parameters)
(overlay 61 66 "phptest.php"))))
+ nil
+ (overlay 47 132 "phptest.php"))
+ ("aClass" type
+ (:members (("fun1" function
+ (:typemodifiers ("public") :arguments
+ (("$a" variable nil (reparse-symbol
formal_parameters) (overlay 174 176 "phptest.php"))
+ ("$b" variable nil (reparse-symbol
formal_parameters) (overlay 178 180 "phptest.php"))))
+
+ nil
+ (overlay 153 204 "phptest.php"))
+
+ ("fun2" function
+ (:typemodifiers ("public") :arguments
+ (("$a" variable nil (reparse-symbol
formal_parameters) (overlay 230 232 "phptest.php"))
+ ("$b" variable nil (reparse-symbol
formal_parameters) (overlay 234 236 "phptest.php"))
+ ))
+ nil
+ (overlay 209 260 "phptest.php"))) :type "class")
+ nil
+ (overlay 135 262 "phptest.php"))
+ )
+ "Expected results from the PHP Unit test"
+ )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Data for Csharp C# tests
+
+(defvar semantic-utest-Csharp-buffer-contents
+"
+class someClass {
+ int fun1(int a, int b) {
+ return a; }
+ int fun2(int a, int b) {
+ return b; }
+}
+")
+
+(defvar semantic-utest-Csharp-name-contents
+ '(("someClass" type
+ (:members
+ (("fun1" function
+ (:arguments
+ (("a" variable
+ (:type "int")
+ (reparse-symbol formal_parameters)
+ (overlay 30 35 "tst.cs"))
+ ("b" variable
+ (:type "int")
+ (reparse-symbol formal_parameters)
+ (overlay 37 42 "tst.cs")))
+ :type "int")
+ (reparse-symbol class_member_declaration)
+ (overlay 21 61 "tst.cs"))
+ ("fun2" function
+ (:arguments
+ (("a" variable
+ (:type "int")
+ (reparse-symbol formal_parameters)
+ (overlay 73 78 "tst.cs"))
+ ("b" variable
+ (:type "int")
+ (reparse-symbol formal_parameters)
+ (overlay 80 85 "tst.cs")))
+ :type "int")
+ (reparse-symbol class_member_declaration)
+ (overlay 64 104 "tst.cs")))
+ :type "class")
+ nil (overlay 1 106 "tst.cs")))
+ )
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+
+(defun semantic-utest-makebuffer (filename contents)
+ "Create a buffer for FILENAME for use in a unit test.
+Pre-fill the buffer with CONTENTS."
+ (let ((buff (semantic-find-file-noselect filename)))
+ (set-buffer buff)
+ (setq buffer-offer-save nil)
+ (font-lock-mode -1) ;; Font lock has issues in Emacs 23
+ (toggle-read-only -1) ;; In case /tmp doesn't exist.
+ (erase-buffer)
+ (insert contents)
+ ;(semantic-fetch-tags) ;JAVE could this go here?
+ (set-buffer-modified-p nil)
+ buff
+ )
+ )
+
+(defun semantic-utest-C ()
+ "Run semantic's C unit test."
+ (interactive)
+ (save-excursion
+ (let ((buff (semantic-utest-makebuffer semantic-utest-C-filename
semantic-utest-C-buffer-contents))
+ (buff2 (semantic-utest-makebuffer semantic-utest-C-filename-h
semantic-utest-C-h-buffer-contents))
+ )
+ (semantic-fetch-tags)
+ (set-buffer buff)
+
+ ;; Turn off a range of modes
+ (semantic-idle-scheduler-mode -1)
+
+ ;; Turn on some modes
+ (semantic-highlight-edits-mode 1)
+
+ ;; Update tags, and show it.
+ (semantic-fetch-tags)
+
+ (switch-to-buffer buff)
+ (sit-for 0)
+
+ ;; Run the tests.
+ ;;(message "First parsing test.")
+ (semantic-utest-verify-names semantic-utest-C-name-contents)
+
+ ;;(message "Invalid tag test.")
+ (semantic-utest-last-invalid semantic-utest-C-name-contents '("fun2")
"/\\*1\\*/" "/* Deleted this line */")
+ (semantic-utest-verify-names semantic-utest-C-name-contents)
+
+ (set-buffer-modified-p nil)
+ ;; Clean up
+ ;; (kill-buffer buff)
+ ;; (kill-buffer buff2)
+ ))
+ (message "All C tests passed.")
+ )
+
+
+
+
+(defun semantic-utest-generic (testname filename contents name-contents
names-removed killme insertme)
+ "Generic unit test according to template.
+Should work for languages withouth .h files, python javascript java.
+TESTNAME is the name of the test.
+FILENAME is the name of the file to create.
+CONTENTS is the contents of the file to test.
+NAME-CONTENTS is the list of names that should be in the contents.
+NAMES-REMOVED is the list of names that gets removed in the removal step.
+KILLME is the name of items to be killed.
+INSERTME is the text to be inserted after the deletion."
+ (save-excursion
+ (let ((buff (semantic-utest-makebuffer filename contents))
+ )
+ ;; Turn off a range of modes
+ (semantic-idle-scheduler-mode -1)
+
+ ;; Turn on some modes
+ (semantic-highlight-edits-mode 1)
+
+ ;; Update tags, and show it.
+ (semantic-fetch-tags)
+ (switch-to-buffer buff)
+ (sit-for 0)
+
+ ;; Run the tests.
+ ;;(message "First parsing test %s." testname)
+ (semantic-utest-verify-names name-contents)
+
+ ;;(message "Invalid tag test %s." testname)
+ (semantic-utest-last-invalid name-contents names-removed killme insertme)
+ (semantic-utest-verify-names name-contents)
+
+ (set-buffer-modified-p nil)
+ ;; Clean up
+ ;; (kill-buffer buff)
+ ))
+ (message "All %s tests passed." testname)
+ )
+
+(defun semantic-utest-Python()
+ (interactive)
+ (if (fboundp 'python-mode)
+ (semantic-utest-generic "Python" (semantic-utest-fname "pytest.py")
semantic-utest-Python-buffer-contents semantic-utest-Python-name-contents
'("fun2") "#1" "#deleted line")
+ (message "Skilling Python test: NO major mode."))
+ )
+
+
+(defun semantic-utest-Javascript()
+ (interactive)
+ (if (fboundp 'javascript-mode)
+ (semantic-utest-generic "Javascript" (semantic-utest-fname
"javascripttest.js") semantic-utest-Javascript-buffer-contents
semantic-utest-Javascript-name-contents '("fun2") "//1" "//deleted line")
+ (message "Skipping JavaScript test: NO major mode."))
+ )
+
+(defun semantic-utest-Java()
+ (interactive)
+ ;; If JDE is installed, it might mess things up depending on the version
+ ;; that was installed.
+ (let ((auto-mode-alist '(("\\.java\\'" . java-mode))))
+ (semantic-utest-generic "Java" (semantic-utest-fname "JavaTest.java")
semantic-utest-Java-buffer-contents semantic-utest-Java-name-contents
'("fun2") "//1" "//deleted line")
+ ))
+
+(defun semantic-utest-Makefile()
+ (interactive)
+ (semantic-utest-generic "Makefile" (semantic-utest-fname "Makefile")
semantic-utest-Makefile-buffer-contents semantic-utest-Makefile-name-contents
'("fun2") "#1" "#deleted line")
+ )
+
+(defun semantic-utest-Scheme()
+ (interactive)
+ (semantic-utest-generic "Scheme" (semantic-utest-fname "tst.scm")
semantic-utest-Scheme-buffer-contents semantic-utest-Scheme-name-contents
'("fun2") ";1" ";deleted line")
+ )
+
+
+(defun semantic-utest-Html()
+ (interactive)
+ ;; Disable html-helper auto-fill-in mode.
+ (let ((html-helper-build-new-buffer nil))
+ (semantic-utest-generic "HTML" (semantic-utest-fname "tst.html")
semantic-utest-Html-buffer-contents semantic-utest-Html-name-contents
'("fun2") "<!--1-->" "<!--deleted line-->")
+ ))
+
+(defun semantic-utest-PHP()
+ (interactive)
+ (if (fboundp 'php-mode)
+ (semantic-utest-generic "PHP" (semantic-utest-fname "phptest.php")
semantic-utest-PHP-buffer-contents semantic-utest-PHP-name-contents '("fun1")
"fun2" "%^@")
+ (message "Skipping PHP Test. No php-mode loaded."))
+ )
+
+;look at http://mfgames.com/linux/csharp-mode
+(defun semantic-utest-Csharp() ;; hmm i dont even know how to edit a scharp
file. need a csharp mode implementation i suppose
+ (interactive)
+ (if (fboundp 'csharp-mode)
+ (semantic-utest-generic "C#" (semantic-utest-fname "csharptest.cs")
semantic-utest-Csharp-buffer-contents semantic-utest-Csharp-name-contents
'("fun2") "//1" "//deleted line")
+ (message "Skipping C# test. No csharp-mode loaded."))
+ )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; stubs
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; stuff for Erlang
+;;-module(hello).
+;-export([hello_world/0]).
+;
+;hello_world()->
+; io:format("Hello World ~n").
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;(defun semantic-utest-Erlang()
+; (interactive)
+; (semantic-utest-generic "Erlang" (semantic-utest-fname "tst.erl")
semantic-utest-Erlang-buffer-contents semantic-utest-Erlang-name-contents
'("fun2") "//1" "//deleted line")
+; )
+;
+;;texi is also supported
+;(defun semantic-utest-Texi()
+; (interactive)
+; (semantic-utest-generic "texi" (semantic-utest-fname "tst.texi")
semantic-utest-Texi-buffer-contents semantic-utest-Texi-name-contents
'("fun2") "//1" "//deleted line")
+; )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;###autoload
+(defun semantic-utest-main()
+ (interactive)
+ "call all utests"
+ (cedet-utest-log-start "multi-lang parsing")
+ (cedet-utest-log " * C tests...")
+ (semantic-utest-C)
+ (cedet-utest-log " * Python tests...")
+ (semantic-utest-Python)
+ (cedet-utest-log " * Java tests...")
+ (semantic-utest-Java)
+ (cedet-utest-log " * Javascript tests...")
+ (semantic-utest-Javascript)
+ (cedet-utest-log " * Makefile tests...")
+ (semantic-utest-Makefile)
+ (cedet-utest-log " * Scheme tests...")
+ (semantic-utest-Scheme)
+ (cedet-utest-log " * Html tests...")
+ (semantic-utest-Html)
+ (cedet-utest-log " * PHP tests...")
+ (semantic-utest-PHP)
+ (cedet-utest-log " * Csharp tests...")
+ (semantic-utest-Csharp)
+
+ (cedet-utest-log-shutdown "multi-lang parsing")
+ )
+
+;;; Buffer contents validation
+;;
+(defun semantic-utest-match-attributes (attr1 attr2 skipnames)
+ "Compare attribute lists ATTR1 and ATTR2.
+Argument SKIPNAMES is a list of names that may be child nodes to skip."
+ (let ((res t))
+ (while (and res attr1 attr2)
+
+ ;; Compare
+ (setq res
+ (cond ((and (listp (car attr1))
+ (semantic-tag-p (car (car attr1))))
+ ;; Compare the list of tags...
+ (semantic-utest-taglists-equivalent-p
+ (car attr2) (car attr1) skipnames)
+ )
+ (t
+ (equal (car attr1) (car attr2)))))
+
+ (if (not res)
+ (error "TAG INTERNAL DIFF: %S %S"
+ (car attr1) (car attr2)))
+
+ (setq attr1 (cdr attr1)
+ attr2 (cdr attr2)))
+ res))
+
+(defun semantic-utest-equivalent-tag-p (tag1 tag2 skipnames)
+ "Determine if TAG1 and TAG2 are the same.
+SKIPNAMES includes lists of possible child nodes that should be missing."
+ (and (equal (semantic-tag-name tag1) (semantic-tag-name tag2))
+ (semantic-tag-of-class-p tag1 (semantic-tag-class tag2))
+ (semantic-utest-match-attributes
+ (semantic-tag-attributes tag1) (semantic-tag-attributes tag2)
+ skipnames)
+ ))
+
+(defun semantic-utest-taglists-equivalent-p (table names skipnames)
+ "Compare TABLE and NAMES, where skipnames allow list1 to be different.
+SKIPNAMES is a list of names that should be skipped in the NAMES list."
+ (let ((SN skipnames))
+ (while SN
+ (setq names (remove (car SN) names))
+ (setq SN (cdr SN))))
+ (while (and names table)
+ (if (not (semantic-utest-equivalent-tag-p (car names)
+ (car table)
+ skipnames))
+ (error "Expected %s, found %s"
+ (semantic-format-tag-prototype (car names))
+ (semantic-format-tag-prototype (car table))))
+ (setq names (cdr names)
+ table (cdr table)))
+ (when names (error "Items forgotten: %S"
+ (mapcar 'semantic-tag-name names)
+ ))
+ (when table (error "Items extra: %S"
+ (mapcar 'semantic-tag-name table)))
+ t)
+
+(defun semantic-utest-verify-names (name-contents &optional skipnames)
+ "Verify the names of the test buffer from NAME-CONTENTS.
+Argument SKIPNAMES is a list of names that should be skipped
+when analyzing the file.
+
+JAVE this thing would need to be recursive to handle java and csharp"
+ (let ((names name-contents)
+ (table (semantic-fetch-tags))
+ )
+ (semantic-utest-taglists-equivalent-p table names skipnames)
+ ))
+
+;;;;;;;;;;;;;;;;;;;;;;;;
+; JAVE redefine a new validation function
+; is not quite as good as the old one yet
+(defun semantic-utest-verify-names-jave (name-contents &optional skipnames)
+ "JAVE version of `semantic-utest-verify-names'.
+NAME-CONTENTS is a sample of the tags buffer to test against.
+SKIPNAMES is a list of names to remove from NAME-CONTENTS"
+ (assert (semantic-utest-verify-names-2 name-contents (semantic-fetch-tags))
+ nil "failed test")
+)
+
+(defun semantic-utest-verify-names-2 (l1 l2)
+ (cond ( (and (consp l1) (equal (car l1) 'overlay))
+ (overlayp l2))
+ ((not (consp l1))
+ (equal l1 l2))
+ ((consp l1)
+ (and (semantic-utest-verify-names-2 (car l1) (car l2))
(semantic-utest-verify-names-2 (cdr l1) (cdr l2))))
+ (t (error "internal error"))))
+
+
+
+
+
+;;; Kill indicator line
+;;
+(defvar semantic-utest-last-kill-text nil
+ "The text from the last kill.")
+
+(defvar semantic-utest-last-kill-pos nil
+ "The position of the last kill.")
+
+(defun semantic-utest-kill-indicator ( killme insertme)
+ "Kill the line with KILLME on it and insert INSERTME in its place."
+ (goto-char (point-min))
+; (re-search-forward (concat "/\\*" indicator "\\*/")); JAVE this isnt
generic enough for different lagnuages
+ (re-search-forward killme)
+ (beginning-of-line)
+ (setq semantic-utest-last-kill-pos (point))
+ (setq semantic-utest-last-kill-text
+ (buffer-substring (point) (point-at-eol)))
+ (delete-region (point) (point-at-eol))
+ (insert insertme)
+ (sit-for 0)
+)
+
+(defun semantic-utest-unkill-indicator ()
+ "Unkill the last indicator."
+ (goto-char semantic-utest-last-kill-pos)
+ (delete-region (point) (point-at-eol))
+ (insert semantic-utest-last-kill-text)
+ (sit-for 0)
+ )
+
+;;; EDITING TESTS
+;;
+
+(defun semantic-utest-last-invalid (name-contents names-removed killme
insertme)
+ "Make the last fcn invalid."
+ (semantic-utest-kill-indicator killme insertme)
+; (semantic-utest-verify-names name-contents names-removed); verify its gone
;new validator doesnt handle skipnames yet
+ (semantic-utest-unkill-indicator);put back killed stuff
+ )
+
+
+
+
+;"#<overlay from \\([0-9]+\\) to \\([0-9]+\\) in \\([^>]*\\)>"
+;#<overlay from \([0-9]+\) to \([0-9]+\) in \([^>]*\)>
+;(overlay \1 \2 "\3")
+
+
+;; JAVE
+;; these are some unit tests for cedet that I got from Eric and modified a bit
for:
+;; python
+;; javascript
+;; java
+;; I tried to generalize the structure of the tests a bit to make it easier to
add languages
+
+;; Mail from Eric:
+;; Many items in the checklist look like:
+
+;; M-x global-semantic-highlight-edits-mode RET
+;; - Edit a file. See the highlight of newly inserted text.
+;; - Customize `semantic-edits-verbose-flag' to be non-nil.
+;; - Wait for the idle scheduler, it should clean up the edits.
+;; - observe messages from incremental parser. Do they relate
+;; to the edits?
+;; - M-x bovinate RET - verify your changes are reflected.
+
+;; It's all about watching the behavior. Timers go off, things get
+;; cleaned up, you type in new changes, etc. An example I tried to
+;; do is below, but covers only 1 language, and not very well at that.
+;; I seem to remember seeing a unit test framework going by one of the
+;; lists. I'm not sure if that would help.
+
+;; Another that might be automatable:
+
+;; M-x semantic-analyze-current-context RET
+;; - Do this in different contexts in your language
+;; files. Verify that reasonable results are returned
+;; such as identification of assignments, function arguments, etc.
+
+;; Anyway, those are some ideas. Any effort you put it will be helpful!
+
+;; Thanks
+;; Eric
+
+;; -----------
+
+
+
+;;; semantic-utest.el ends here
Index: srecode-tests.el
===================================================================
RCS file: srecode-tests.el
diff -N srecode-tests.el
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ srecode-tests.el 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,266 @@
+;;; From srecode-fields:
+
+(require 'srecode/fields)
+
+(defvar srecode-field-utest-text
+ "This is a test buffer.
+
+It is filled with some text."
+ "Text for tests.")
+
+(defun srecode-field-utest ()
+ "Test the srecode field manager."
+ (interactive)
+ (if (featurep 'xemacs)
+ (message "There is no XEmacs support for SRecode Fields.")
+ (srecode-field-utest-impl)))
+
+(defun srecode-field-utest-impl ()
+ "Implementation of the SRecode field utest."
+ (save-excursion
+ (find-file "/tmp/srecode-field-test.txt")
+
+ (erase-buffer)
+ (goto-char (point-min))
+ (insert srecode-field-utest-text)
+ (set-buffer-modified-p nil)
+
+ ;; Test basic field generation.
+ (let ((srecode-field-archive nil)
+ (f nil))
+
+ (end-of-line)
+ (forward-word -1)
+
+ (setq f (srecode-field "Test"
+ :name "TEST"
+ :start 6
+ :end 8))
+
+ (when (or (not (slot-boundp f 'overlay)) (not (oref f overlay)))
+ (error "Field test: Overlay info not created for field"))
+
+ (when (and (overlay-p (oref f overlay))
+ (not (overlay-get (oref f overlay) 'srecode-init-only)))
+ (error "Field creation overlay is not tagged w/ init flag"))
+
+ (srecode-overlaid-activate f)
+
+ (when (or (not (overlay-p (oref f overlay)))
+ (overlay-get (oref f overlay) 'srecode-init-only))
+ (error "New field overlay not created during activation"))
+
+ (when (not (= (length srecode-field-archive) 1))
+ (error "Field test: Incorrect number of elements in the field archive"))
+ (when (not (eq f (car srecode-field-archive)))
+ (error "Field test: Field did not auto-add itself to the field
archive"))
+
+ (when (not (overlay-get (oref f overlay) 'keymap))
+ (error "Field test: Overlay keymap not set"))
+
+ (when (not (string= "is" (srecode-overlaid-text f)))
+ (error "Field test: Expected field text 'is', not %s"
+ (srecode-overlaid-text f)))
+
+ ;; Test deletion.
+ (srecode-delete f)
+
+ (when (slot-boundp f 'overlay)
+ (error "Field test: Overlay not deleted after object delete"))
+ )
+
+ ;; Test basic region construction.
+ (let* ((srecode-field-archive nil)
+ (reg nil)
+ (fields
+ (list
+ (srecode-field "Test1" :name "TEST-1" :start 5 :end 10)
+ (srecode-field "Test2" :name "TEST-2" :start 15 :end 20)
+ (srecode-field "Test3" :name "TEST-3" :start 25 :end 30)
+
+ (srecode-field "Test4" :name "TEST-4" :start 35 :end 35))
+ ))
+
+ (when (not (= (length srecode-field-archive) 4))
+ (error "Region Test: Found %d fields. Expected 4"
+ (length srecode-field-archive)))
+
+ (setq reg (srecode-template-inserted-region "REG"
+ :start 4
+ :end 40))
+
+ (srecode-overlaid-activate reg)
+
+ ;; Make sure it was cleared.
+ (when srecode-field-archive
+ (error "Region Test: Did not clear field archive"))
+
+ ;; Auto-positioning.
+ (when (not (eq (point) 5))
+ (error "Region Test: Did not reposition on first field"))
+
+ ;; Active region
+ (when (not (eq (srecode-active-template-region) reg))
+ (error "Region Test: Active region not set"))
+
+ ;; Various sizes
+ (mapc (lambda (T)
+ (if (string= (object-name-string T) "Test4")
+ (progn
+ (when (not (srecode-empty-region-p T))
+ (error "Field %s is not empty"
+ (object-name T)))
+ )
+ (when (not (= (srecode-region-size T) 5))
+ (error "Calculated size of %s was not 5"
+ (object-name T)))))
+ fields)
+
+ ;; Make sure things stay up after a 'command'.
+ (srecode-field-post-command)
+ (when (not (eq (srecode-active-template-region) reg))
+ (error "Region Test: Active region did not stay up"))
+
+ ;; Test field movement.
+ (when (not (eq (srecode-overlaid-at-point 'srecode-field)
+ (nth 0 fields)))
+ (error "Region Test: Field %s not under point"
+ (object-name (nth 0 fields))))
+
+ (srecode-field-next)
+
+ (when (not (eq (srecode-overlaid-at-point 'srecode-field)
+ (nth 1 fields)))
+ (error "Region Test: Field %s not under point"
+ (object-name (nth 1 fields))))
+
+ (srecode-field-prev)
+
+ (when (not (eq (srecode-overlaid-at-point 'srecode-field)
+ (nth 0 fields)))
+ (error "Region Test: Field %s not under point"
+ (object-name (nth 0 fields))))
+
+ ;; Move cursor out of the region and have everything cleaned up.
+ (goto-char 42)
+ (srecode-field-post-command)
+ (when (srecode-active-template-region)
+ (error "Region Test: Active region did not clear on move out"))
+
+ (mapc (lambda (T)
+ (when (slot-boundp T 'overlay)
+ (error "Overlay did not clear off of of field %s"
+ (object-name T))))
+ fields)
+
+ ;; End of LET
+ )
+
+ ;; Test variable linkage.
+ (let* ((srecode-field-archive nil)
+ (f1 (srecode-field "Test1" :name "TEST" :start 6 :end 8))
+ (f2 (srecode-field "Test2" :name "TEST" :start 28 :end 30))
+ (f3 (srecode-field "Test3" :name "NOTTEST" :start 35 :end 40))
+ (reg (srecode-template-inserted-region "REG" :start 4 :end 40))
+ )
+ (srecode-overlaid-activate reg)
+
+ (when (not (string= (srecode-overlaid-text f1)
+ (srecode-overlaid-text f2)))
+ (error "Linkage Test: Init strings are not ="))
+ (when (string= (srecode-overlaid-text f1)
+ (srecode-overlaid-text f3))
+ (error "Linkage Test: Init string on dissimilar fields is now the
same"))
+
+ (goto-char 7)
+ (insert "a")
+
+ (when (not (string= (srecode-overlaid-text f1)
+ (srecode-overlaid-text f2)))
+ (error "Linkage Test: mid-insert strings are not ="))
+ (when (string= (srecode-overlaid-text f1)
+ (srecode-overlaid-text f3))
+ (error "Linkage Test: mid-insert string on dissimilar fields is now the
same"))
+
+ (goto-char 9)
+ (insert "t")
+
+ (when (not (string= (srecode-overlaid-text f1) "iast"))
+ (error "Linkage Test: tail-insert failed to captured added char"))
+ (when (not (string= (srecode-overlaid-text f1)
+ (srecode-overlaid-text f2)))
+ (error "Linkage Test: tail-insert strings are not ="))
+ (when (string= (srecode-overlaid-text f1)
+ (srecode-overlaid-text f3))
+ (error "Linkage Test: tail-insert string on dissimilar fields is now
the same"))
+
+ (goto-char 6)
+ (insert "b")
+
+ (when (not (string= (srecode-overlaid-text f1) "biast"))
+ (error "Linkage Test: tail-insert failed to captured added char"))
+ (when (not (string= (srecode-overlaid-text f1)
+ (srecode-overlaid-text f2)))
+ (error "Linkage Test: tail-insert strings are not ="))
+ (when (string= (srecode-overlaid-text f1)
+ (srecode-overlaid-text f3))
+ (error "Linkage Test: tail-insert string on dissimilar fields is now
the same"))
+
+ ;; Cleanup
+ (srecode-delete reg)
+ )
+
+ (set-buffer-modified-p nil)
+
+ (message " All field tests passed.")
+ ))
+
+;;; From srecode-document:
+
+(require 'srecode/doc)
+
+(defun srecode-document-function-comment-extract-test ()
+ "Test old comment extraction.
+Dump out the extracted dictionary."
+ (interactive)
+
+ (srecode-load-tables-for-mode major-mode)
+ (srecode-load-tables-for-mode major-mode 'document)
+
+ (if (not (srecode-table))
+ (error "No template table found for mode %s" major-mode))
+
+ (let* ((temp (srecode-template-get-table (srecode-table)
+ "function-comment"
+ "declaration"
+ 'document))
+ (fcn-in (semantic-current-tag)))
+
+ (if (not temp)
+ (error "No templates for function comments"))
+
+ ;; Try to figure out the tag we want to use.
+ (when (or (not fcn-in)
+ (not (semantic-tag-of-class-p fcn-in 'function)))
+ (error "No tag of class 'function to insert comment for"))
+
+ (let ((lextok (semantic-documentation-comment-preceeding-tag fcn-in 'lex))
+ )
+
+ (when (not lextok)
+ (error "No comment to attempt an extraction"))
+
+ (let ((s (semantic-lex-token-start lextok))
+ (e (semantic-lex-token-end lextok))
+ (extract nil))
+
+ (pulse-momentary-highlight-region s e)
+
+ ;; Extract text from the existing comment.
+ (setq extract (srecode-extract temp s e))
+
+ (with-output-to-temp-buffer "*SRECODE DUMP*"
+ (princ "EXTRACTED DICTIONARY FOR ")
+ (princ (semantic-tag-name fcn-in))
+ (princ "\n--------------------------------------------\n")
+ (srecode-dump extract))))))
Index: tests/scopetest.cpp
===================================================================
RCS file: tests/scopetest.cpp
diff -N tests/scopetest.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/scopetest.cpp 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,47 @@
+/* Test scoping rules for c++ in the analyzer. */
+
+namespace {
+
+ class aclass2; // Forward reference.
+
+ class aclass1 {
+ private:
+ int attrp1;
+ int amethodp1(int argp1);
+ aclass2 areference;
+ protected:
+ int attrpr1;
+ public:
+ int attr1;
+ int amethod1(int arg1);
+ };
+}
+
+namespace {
+ class aclass2 : public aclass1
+ {
+ private:
+ int attrp2;
+ int amethodp2(int argp1);
+ public:
+ aclass2(int aninitvalue);
+ ~aclass2();
+ int attr2;
+ int amethod2(int arg2);
+ };
+}
+
+aclass2::aclass2(init aninitvalue)
+{
+ /* This is a comment that talks about aclass1 */
+ aclass1;
+}
+
+int aclass2::amethod2(int arg2)
+{
+ int alocalvar;
+ float q;
+
+ ac;
+}
+
Index: tests/scopetest.java
===================================================================
RCS file: tests/scopetest.java
diff -N tests/scopetest.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/scopetest.java 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,25 @@
+class Foo {
+
+ public void a1() {}
+
+ class Bar {
+
+ public int a2() {}
+
+ public void b() {
+ a // -1-
+ }
+
+ class Baz {
+
+ public int a3() {}
+
+ public Baz(int a4) {
+ a // -2-
+ }
+
+ }
+
+ }
+
+}
\ No newline at end of file
Index: tests/templates.cpp
===================================================================
RCS file: tests/templates.cpp
diff -N tests/templates.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/templates.cpp 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,129 @@
+// C++ examples and requests from Klaus Berndl
+
+// template in a unnamed namespace
+namespace
+{
+ template<typename Target, typename Source>
+ Target lexical_cast(Source arg)
+ {
+ std::stringstream interpreter;
+ Target result;
+
+ if(!(interpreter << arg) || !(interpreter >> result) ||
+ !(interpreter >> std::ws).eof())
+ throw bad_lexical_cast();
+
+ return result;
+ }
+}
+
+
+template <class T, FOO> class Vector
+{
+private:
+ static T* v;
+ int sz;
+
+public:
+ T& elem(int i) {return v[i];}
+ virtual ~Vector ();
+
+protected:
+ Vector ();
+};
+
+template <> class Vector <void*>
+{
+private:
+ void** v;
+ int sz;
+
+public:
+ Vector ();
+ virtual int func1(int i);
+ virtual int func2(int i) = 0;
+ static virtual int func3(int i) = 0;
+ void*& elem(int i) {return v[i];}
+ //...
+};
+
+// template contains namespace
+typedef vector<CzkUtilities::Action*> ActionList;
+
+// declaration of some template-types
+map<XXX, Test::YYY>** map_var;
+
+map_with_size<XXX, Test::YYY, size> map_size_var;
+typedef map_with_size<XXX, Test::YYY, size> SizedMap;
+
+map_with_10_size<XXX, Test::YYY, 10>* pMap_size10_var;
+typedef map_with_10_size<XXX, Test::YYY, 10> Size10Map;
+
+// a function which such a template-argument
+void* test_function(map<ClassX, Test::ClassY, 10>* pMap);
+
+
+template <class T> class Vector <T*> : private Vector <void*>
+{
+public:
+ typedef Vector <void*> Base;
+
+ Vector () : Base() {}
+
+ T*& elem(int i) {return static_cast<T*&>(Base::elem(i));}
+ //...
+};
+
+// outside method implementation of a template-class
+template<class T> T& Vector<T*>::elem(int i)
+{
+ return C;
+}
+
+// same but qualified with a namespace Testnamespace
+template<class T> T& Testnamespace::Vector<T*>::elem(int i)
+{
+ return C;
+}
+
+// function templates with keyword typename
+template<typename Target, typename Source>
+Target lexical_cast(Source arg)
+{
+ std::stringstream interpreter;
+ Target result;
+
+ if(!(interpreter << arg) || !(interpreter >> result) ||
+ !(interpreter >> std::ws).eof())
+ throw bad_lexical_cast();
+
+ return result;
+}
+
+template<class T>
+static
+typename T::_ptr_type
+getService(const std::string& pServiceName, const int pRetries=20)
+{
+ return T::_narrow(getServiceObject(pServiceName, pRetries));
+}
+
+// function template declaration
+template<class T> void sort(vector<T>&);
+// complex function template definition
+template<class T, class S, const NamespaceY::ClassX<TestClass, &s> volatile
***&i>
+map<ClassY, ClassX, 10>
+sort(const vector<T>& v)
+{
+ return;
+}
+
+// variable declarations of template-types
+foo<TClass, Testnamespace::XClass, i> *bar1;
+foo<TClass, Testnamespace::XClass, **&i> *bar2;
+foo<TClass, Testnamespace::XClass, *Namespace::ClassX::i> bar3;
+foo<0> bar0;
+
+class SomeName;
+class OtherName;
+
Index: tests/test.c
===================================================================
RCS file: tests/test.c
diff -N tests/test.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/test.c 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,222 @@
+/* Test file for C language.
+ * Attempt to include as many aspects of the C language as possible.
+ *
+ * $Id: test.c,v 1.2 2009/09/28 23:23:31 cyd Exp $
+ *
+ */
+/* types of include files */
+#include "includeme1.h"
+#include <includeme2.h>
+#include <subdir/includeme3.h>
+#include <includeme.notanhfile>
+#include <stdlib.h>
+#include <cmath>
+
+#if 0
+int dont_show_function()
+{
+}
+#endif
+
+/* Global types */
+struct mystruct1 {
+ int slot11;
+ char slot12;
+ float slot13;
+};
+
+struct mystruct2 {
+ int slot21;
+ char slot22;
+ float slot23;
+} var_of_type_mystruct2;
+
+struct {
+ int slot31;
+ char slot32;
+ float slot33;
+} var_of_anonymous_struct;
+
+typedef struct mystruct1 typedef_of_mystruct1;
+typedef struct mystruct1 *typedef_of_pointer_mystruct1;
+typedef struct { int slot_a; } typedef_of_anonymous_struct;
+typedef struct A {
+} B;
+
+typedef struct mystruct1 td1, td2;
+
+union myunion1 {
+ int slot41;
+ char slot42;
+ float slot43;
+};
+
+union myunion2 {
+ int slot51;
+ char slot52;
+ float slot53;
+} var_of_type_myunion2;
+
+struct {
+ int slot61;
+ char slot72;
+ float slot83;
+} var_of_anonymous_union;
+
+typedef union myunion1 typedef_of_myunion1;
+typedef union myunion1 *typedef_of_pointer_myunion1;
+typedef union { int slot_a; } typedef_of_anonymous_union;
+
+enum myenum1 { enum11 = 1, enum12 };
+enum myenum2 { enum21, enum22 = 2 } var_of_type_myenum2;
+enum { enum31, enum32 } var_of_anonymous_enum;
+
+typedef enum myenum1 typedef_of_myenum1;
+typedef enum myenum1 *typedef_of_pointer_myenum1;
+typedef enum { enum_a = 3, enum_b } typedef_of_anonymous_enum;
+
+typedef int typedef_of_int;
+
+/* Here are some simpler variable types */
+int var1;
+int varbit1:1;
+char var2;
+float var3;
+mystruct1 var3;
+struct mystruct1 var4;
+union myunion1 var5;
+enum myenum1 var6;
+
+char *varp1;
+char **varp2;
+char varv1[1];
+char varv2[1][2];
+
+char *varpa1 = "moose";
+struct mystruct2 vara2 = { 1, 'a', 0.0 };
+enum myenum1 vara3 = enum11;
+int vara4 = (int)0.0;
+int vara5 = funcall();
+
+int mvar1, mvar2, mvar3;
+char *mvarp1, *mvarp2, *mvarp3;
+char *mvarpa1 = 'a', *mvarpa2 = 'b', *mvarpa3 = 'c';
+char mvaras1[10], mvaras2[12][13], *mvaras3 = 'd';
+
+static register const unsigned int tmvar1;
+
+#define MACRO1 1
+#define MACRO2(foo) (1+foo)
+
+/* Here are some function prototypes */
+
+/* This is legal, but I decided not to support inferred integer
+ * types on functions and variables.
+ */
+fun0();
+int funp1();
+char funp2(int arg11);
+float funp3(char arg21, char arg22);
+struct mystrct1 funp4(struct mystruct2 arg31, union myunion2 arg32);
+enum myenum1 funp5(char *arg41, union myunion1 *arg42);
+
+char funpp1 __P(char argp1, struct mystruct2 argp2, char *arg4p);
+
+int fun1();
+
+/* Here is a function pointer */
+int (*funcptr)(int a, int b);
+
+/* Function Definitions */
+
+/* This is legal, but I decided not to support inferred integer
+ * types on functions and variables.
+ */
+fun0()
+{
+ int sv = 0;
+}
+
+int fun1 ()
+{
+ int sv = 1;
+}
+
+int fun1p1 (void)
+{
+ int sv = 1;
+}
+
+char fun2(int arg_11)
+{
+ char sv = 2;
+}
+
+float fun3(char arg_21, char arg_22)
+{
+ char sv = 3;
+}
+
+struct mystrct1 fun4(struct mystruct2 arg31, union myunion2 arg32)
+{
+ sv = 4;
+}
+
+enum myenum1 fun5(char *arg41, union myunion1 *arg42)
+{
+ sv = 5;
+}
+
+/* Functions with K&R syntax. */
+struct mystrct1 funk1(arg_31, arg_32)
+ struct mystruct2 arg_31;
+ union myunion2 arg32;
+{
+ sv = 4;
+}
+
+enum myenum1 *funk2(arg_41, arg_42)
+ char *arg_41;
+ union myunion1 *arg_42;
+{
+ sv = 5;
+
+ if(foo) {
+ }
+}
+
+int funk3(arg_51, arg_53)
+ int arg_51;
+ char arg_53;
+{
+ char q = 'a';
+ int sv = 6;
+ td1 ms1;
+ enum myenum1 testconst;
+
+ /* Function argument analysis */
+ funk3(ms1.slot11, arg_53 );
+ sv = 7;
+
+ /* Slot deref on assignee */
+ ms1.slot11 = s;
+
+ /* Enum/const completion */
+ testconst = e;
+
+ /* Bad var/slot and param */
+ blah.notafunction(moose);
+
+ /* Print something. */
+ printf("Moose", );
+
+ tan();
+}
+
+int funk4_fixme(arg_61, arg_62)
+ int arg_61, arg_62;
+{
+
+}
+
+/* End of C tests */
Index: tests/test.cpp
===================================================================
RCS file: tests/test.cpp
diff -N tests/test.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/test.cpp 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,593 @@
+/* Test file for C++ language.
+ * Attempt to include as many aspects of the C++ language as possible.
+ * Do not include things tested in test.c since that shares the
+ * same language.
+ *
+ * $Id: test.cpp,v 1.2 2009/09/28 23:23:31 cyd Exp $
+ *
+ */
+
+/* An include test */
+#include <stdio.h>
+
+#include <cmath>
+
+#include "c++-test.hh"
+
+#include <c++-test.hh>
+
+double var1 = 1.2;
+
+int simple1(int a) {
+
+}
+
+struct foo1 {
+ int test;
+};
+
+struct foo2 : public foo1 {
+ const int foo21(int a, int b);
+ const int foo22(int a, int b) { return 1 }
+};
+
+/* Classes */
+class class1 {
+private:
+ int var11;
+ struct foo1 var12;
+public:
+ int p_var11;
+ struct foo p_var12;
+};
+
+class i_class1 : public class1 {
+private:
+ int var11;
+ struct foo var12;
+public:
+ int p_var11;
+ struct foo p_var12;
+};
+
+class class2 {
+private:
+ int var21;
+ struct foo var22;
+public:
+ int p_var21;
+ struct foo p_var22;
+};
+
+class i_class2 : public class1, public class2 {
+private:
+ int var21;
+ struct foo var22;
+protected:
+ int pt_var21;
+public:
+ int p_var21;
+ struct foo p_var22;
+};
+
+class class3 {
+ /* A class with strange things in it */
+public:
+ class3(); /* A constructor */
+ enum embedded_foo_enum {
+ a, b, c
+ } embed1;
+ struct embedded_bar_struct {
+ int a;
+ int b;
+ } embed2;
+ class embedded_baz_class {
+ embedded_baz_class();
+ ~embedded_baz_class();
+ } embed3;
+ ~class3(); /* destructor */
+
+ /* Methods */
+ int method_for_class3(int a, char b);
+
+ int inline_method(int c) { return c; }
+
+ /* Operators */
+ class3& operator^= (const class3& something);
+
+ /* Funny declmods */
+ const class3 * const method_const_ptr_ptr(const int * const argconst) const
= 0;
+};
+
+class3::class3()
+{
+ /* Constructor outside the definition. */
+}
+
+int class3::method_for_class3(int a, char b)
+{
+}
+
+int class3::method1_for_class3( int a, int &b)
+{
+ int cvariablename;
+ class3 fooy[];
+ class3 moose = new class3;
+
+ // Complktion testing line should find external members.
+ a = fooy[1].me ;
+ b = cv ;
+
+ if (fooy.emb) {
+ simple1(c);
+ }
+
+ cos(10);
+ abs(10);
+
+ return 1;
+}
+
+char class3::method2_for_class3( int a, int b) throw ( exception1 )
+{
+ return 'a';
+}
+
+void *class3::method3_for_class3( int a, int b) throw ( exception1, exception2
)
+{
+ int q = a;
+ return "Moose";
+}
+
+void *class3::method31_for_class3( int a, int b) throw ( )
+{
+ int q = a;
+ return "Moose";
+}
+
+void *class3::method4_for_class3( int a, int b) reentrant
+{
+ class3 ct;
+
+ ct.method5_for_class3(1,a);
+
+ pritf();
+}
+
+/*
+ * A method on class3.
+ */
+void *class3::method5_for_class3( int a, int b) const
+{
+}
+
+/*
+ * Namespace parsing tests
+ */
+namespace NS {
+ class class_in_namespace {
+ int equiv(const NS::class_in_namespace *) const;
+ };
+}
+
+int NS::class_in_namespace::equiv(const NS::class_in_namespace *cin) const
+{
+ return 0;
+}
+
+// Stuff Klaus found.
+// Inheritance w/out a specifying for public.
+class class4 : class1 {
+ // Pure virtual methods.
+ void virtual print () const = 0;
+
+public:
+ // The whacky constructor type
+ class4()
+ try : class1(args)
+ {
+ // constructor body
+ }
+ catch ()
+ {
+
+ }
+
+
+};
+
+class class5 : public virtual class4 {
+ // Virtual inheritance
+};
+
+class class6 : class1 {
+ // Mutable
+ mutable int i;
+};
+
+/* Namespaces */
+namespace namespace1 {
+ void ns_method1() { }
+
+ class n_class1 {
+ public:
+ void method11(int a) { }
+ };
+
+ /* This shouldn't parse due to missing semicolon. */
+ class _n_class2 : public n_class1 {
+ void n_c2_method1(int a, int b) { }
+ };
+
+ // Macros in the namespace
+#define NSMACRO 1
+
+ // Template in the namespace
+ template<class T> T nsti1(const Foo& foo);
+ template<> int nsti1<int>(const Foo& foo);
+
+}
+
+namespace namespace2 {
+
+ using namespace1::n_class1;
+
+}
+
+/* Initializers */
+void tinitializers1(): inita1(False),
+ inita2(False)
+{
+ inita1= 1;
+}
+
+/* How about Extern C type things. */
+int funny_prototype(int ,int b,float c)
+{
+
+}
+
+extern "C"
+int extern_c_1(int a, int b)
+{
+
+ funny_prototype(1,2,3.4);
+
+ printf("Moose", );
+
+ return 1;
+}
+
+extern "C" {
+
+ int extern_c_2(int a, int b)
+ {
+ return 1;
+ }
+
+}
+
+// Some operator stuff
+class Action
+{
+ // Problems!! operator() and operator[] can not be parsed with semantic
+ // 1.4.2 but with latest c.by
+ virtual void operator()(int i, char *p ) = 0;
+ virtual String& operator[]() = 0;
+ virtual void operator!() = 0;
+ virtual void operator->() = 0;
+ virtual T& operator+=();
+ virtual T& operator*();
+ virtual T& operator*=();
+};
+
+// class with namespace qualified parents
+class Multiinherit : public virtual POA::Parent,
+ public virtual POA::Parent1,
+ Parent
+{
+private:
+ int i;
+
+public:
+ Multiinherit();
+ ~Multiinherit();
+
+ // method with a list of qualified exceptions
+ void* throwtest()
+ throw(Exception0,
+ Testnamespace::Exception1,
+ Testnamespace::Excpetion2,
+ Testnamespace::testnamespace1::Exception3);
+
+};
+
+void*
+Multiinherit::throwtest()
+ throw (Exception0,
+ Testnamespace::Exception1,
+ Testnamespace::Excpetion2,
+ Testnamespace::testnamespace1::Exception3)
+{
+ return;
+}
+
+// Jens Rock <address@hidden>: Nested classes or structs defined
+// outside of the containing class/struct.
+class container
+{
+ public:
+ struct contained;
+ container();
+ ~container();
+};
+
+struct container::contained
+{
+ public:
+ contained();
+ ~contained();
+};
+
+/*
+ * Ok, how about some template stuff.
+ */
+template <class CT, class container = vector<CT> >
+const CT& max (const CT& a, const CT& b)
+{
+ return a < b ? b : a;
+}
+
+// Arne Schmitz found this one
+std::vector<int> &a, &b, &c;
+
+class TemplateUsingClass
+{
+ typedef TestClassMap::iterator iterator;
+ typedef map<long, long> TestClassMap;
+
+ // typedefs with const and volatile
+ typedef const map<long, long> const_TestClassMap;
+ typedef TestClassMap<string>::iterator volatile volatile_iterator;
+
+ map<int, int> mapclassvarthingy;
+};
+
+template<class T> T ti1(const Foo& foo);
+template<> int ti1<int>(const Foo& foo);
+
+
+// -----------------------------------
+// Now some namespace and related stuff
+// -----------------------------------
+
+using CORBA::LEX::get_token;
+using Namespace1;
+
+using namespace POA::std;
+using namespace Test;
+
+
+
+namespace Parser
+{
+ namespace
+ {
+ using Lexer::get_test;
+ string str = "";
+ }
+
+ namespace XXX
+ {
+
+ class Foobar : public virtual POA::Parent,
+ public virtual POA::Parent1,
+ private POA::list<fact>,
+ private map<string>
+ {
+ ini i;
+ list <shared_ptr<item> >::const_iterator l;
+ public:
+
+ Foobar();
+ ~Foobar();
+ };
+ }
+
+
+ void test_function(int i);
+
+};
+
+// unnamed namespaces - even nested
+namespace
+{
+ namespace
+ {
+ using Lexer::get_test;
+ string str = "";
+ }
+
+ // some builtin types
+ long long ll = 0;
+ long double d = 0.0;
+ unsigned test;
+ unsigned long int **uli = 0;
+ signed si = 0;
+ signed short ss = 0;
+ short int i = 0;
+ long int li = 0;
+
+ // expressions with namespace/class-qualifyiers
+ ORB_var cGlobalOrb = ORB::_nil();
+ ORB_var1 cGlobalOrb1 = ORB::_test;
+
+ class Testclass
+ {
+ #define TEST 0
+ ini i;
+
+ public:
+
+ Testclass();
+ ~Testclass();
+ };
+
+ static void test_function(unsigned int i);
+
+};
+
+
+// outside method implementations which should be grouped to type Test
+XXX&
+Test::waiting()
+{
+ return;
+}
+
+void
+Test::print()
+{
+ return;
+}
+
+// outside method implementations with namespaces which should be grouped to
+// their complete (incl. namespace) types
+void*
+Parser::XXX::Foobar::wait(int i, const char const * const * p)
+{
+ return;
+}
+
+void*
+Namespace1::Test::wait1(int i)
+{
+ return;
+}
+
+int
+Namespace1::Test::waiting(int i)
+{
+ return;
+}
+
+// a class with some outside implementations which should all be grouped to
+// this class declaration
+class ClassWithExternals
+{
+private:
+ int i;
+
+public:
+ ClassWithExternals();
+ ~ClassWithExternals();
+ void non_nil();
+};
+
+
+// Foobar is not displayed; seems that semantic tries to add this to the class
+// Foobar but can not find/display it, because contained in the namespace
above.
+void
+Foobar::non_nil()
+{
+ return;
+}
+
+// are correctly grouped to the ClassWithExternals class
+void
+ClassWithExternals::non_nil()
+{
+ String s = "lödfjg dlfgkdlfkgjdl";
+ return;
+}
+
+ClassWithExternals::ClassWithExternals()
+{
+ return;
+}
+
+void
+ClassWithExternals::~ClassWithExternals()
+{
+ return;
+}
+
+
+// -------------------------------
+// Now some macro and define stuff
+// -------------------------------
+
+#define TEST 0
+#define TEST1 "String"
+
+// The first backslash makes this macro unmatched syntax with semantic 1.4.2!
+// With flexing \+newline as nothing all is working fine!
+#define MZK_ENTER(METHOD) \
+{ \
+ CzkMethodLog lMethodLog(METHOD,"Framework");\
+}
+
+#define ZK_ASSERTM(METHOD,ASSERTION,MESSAGE) \
+ { if(!(ASSERTION))\
+ {\
+ std::ostringstream lMesgStream; \
+ lMesgStream << "Assertion failed: " \
+ << MESSAGE; \
+ CzkLogManager::doLog(CzkLogManager::FATAL,"",METHOD, \
+ "Assert",lMesgStream); \
+ assert(ASSERTION);\
+ }\
+ }
+
+// Test if not newline-backslashes are handled correctly
+string s = "My \"quoted\" string";
+
+// parsed fine as macro
+#define FOO (arg) method(arg, "foo");
+
+// With semantic 1.4.2 this parsed as macro BAR *and* function method.
+// With latest c.bnf at least one-liner macros can be parsed correctly.
+#define BAR (arg) CzkMessageLog method(arg, "bar");
+
+// some const and volatile stuff
+char * p1 = "Hello"; // 1. variable Pointer, variable Data
+const char * p2 = "Hello"; // 2. variable pointer, constant data
+char * const p3 = "Hello"; // 3. constant pointer, variable data
+const char * const p4 = "Hello"; // 4. constant pointer, constant data
+
+// Case 2 and 4 can exchange first "const" and "char"
+char const * p21 = "Hello"; // variable pointer, constant data
+char const * const p41 = "Hello"; // constant pointer, constant data
+
+char volatile a = 0; // a volatile char
+void foo(bar const &arg); // a reference to a const bar
+int foobar(bar const * const p); // a const pointer to a const bar
+int foobar(bar const volatile * const p); // a const pointer to a const bar
+int foobar3(char* p); // a const pointer to a const bar
+
+// Should not be parsed because this is invalid code
+int const & const r3 = i;
+
+boolean i = 0;
+boolean & r1 = i;
+boolean const & r2 = i;
+
+// const * sequences can be very long in C++ ;-)
+char const * const * const * const * ppp;
+
+// complex function declarationen with named pointer-arguments
+const char** foobar1(volatile char const * const **p);
+const char** foobar11(volatile Test::Namespace::Char<char*> const * const **p);
+
+// complex function declarationen with unnamed pointer-arguments
+const char* foobar2(const char***);
+const char* foobar21(const Test::Namespace::Char<char>***);
+
+// string literal parsing even with wchar_t
+char const *p = "string1";
+char const *q = "string1" "str\"ing2" "string3";
+wchar_t testc = L'a';
+
+wchar_t const *wp = L"string with a \" in it";
+wchar_t const *wq = L"string \n\t\"test" L"string2";
+wchar_t const *wr = L"string L";
Index: tests/test.el
===================================================================
RCS file: tests/test.el
diff -N tests/test.el
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/test.el 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,141 @@
+;; Test file for Emacs Lisp.
+;; Attempt to include as many aspects of Emacs Lisp as possible.
+;;
+
+;;; Require
+;;
+(require 'semantic)
+(require 'eieio "../eieio")
+
+;; tags encapsulated in eval-when-compile and eval-and-compile
+;; should be expanded out into the outer environment.
+(eval-when-compile
+ (require 'semantic-imenu)
+ )
+
+(eval-and-compile
+ (defconst const-1 nil)
+ (defun function-1 (arg)
+ nil)
+ )
+
+;;; Functions
+;;
+(defun a-defun (arg1 arg2 &optional arg3)
+ "doc a"
+ nil)
+
+(defun a-defun-interactive (arg1 arg2 &optional arg3)
+ "doc a that is a command"
+ (interactive "R")
+ nil)
+
+(defun* a-defun* (arg1 arg2 &optional arg3)
+ "doc a*"
+ nil)
+
+(defsubst a-defsubst (arg1 arg2 &optional arg3)
+ "doc a-subst"
+ nil)
+
+(defmacro a-defmacro (arg1 arg2 &optional arg3)
+ "doc a-macro"
+ nil)
+
+(define-overload a-overload (arg)
+ "doc a-overload"
+ nil)
+
+;;; Methods
+;;
+(defmethod a-method ((obj some-class) &optional arg2)
+ "Doc String for a method."
+ (call-next-method))
+
+(defgeneric a-generic (arg1 arg2)
+ "General description of a-generic.")
+
+;;; Advice
+;;
+(defadvice existing-function-to-advise (around test activate)
+ "Do something special to this fcn."
+ (ad-do-it))
+
+;;; Variables
+;;
+(defvar a-defvar (cons 1 2)
+ "Variable a")
+
+(defvar a-defvar-star (cons 1 2)
+ "*User visible var a")
+
+(defconst a-defconst 'a "var doc const")
+
+(defcustom a-defcustom nil
+ "*doc custom"
+ :group 'a-defgroup
+ :type 'boolean)
+
+(defface a-defface 'bold
+ "A face that is bold.")
+
+(defimage ezimage-page-minus
+ ((:type xpm :file "page-minus.xpm" :ascent center))
+ "Image used for open files with stuff in them.")
+
+;;; Autoloads
+;;
+(autoload (quote a-autoload) "somefile"
+ "Non-interactive autoload." nil nil)
+
+(autoload (quote a-autoload-interactive) "somefile"
+"Interactive autoload." t nil)
+
+
+(defgroup a-defgroup nil
+ "Group for `emacs-lisp' regression-test")
+
+;;; Classes
+;;
+(defclass a-class (a-parent)
+ ((slot-1)
+ (slot-2 :initarg :slot-2)
+ (slot-3 :documentation "Doc about slot3")
+ (slot-4 :type 'boolean)
+ )
+ "Doc String for class.")
+
+(defclass a-class-abstract ()
+ nil
+ "Doc string for abstract class."
+ :abstract t)
+
+;;; Structures
+;;
+(defstruct (test-struct-1 :test 'equal)
+ (slot-1 :equal 'eq)
+ slot-2)
+
+(defstruct test-struct-2
+ slot-1
+ slot-2)
+
+;;; Semantic specific macros
+;;
+(define-lex a-lexer
+ "Doc String"
+ this
+ that)
+
+(define-mode-local-override a-overriden-function
+ emacs-lisp-mode (tag)
+ "A function that is overloaded."
+ nil)
+
+(defvar-mode-local emacs-lisp-mode a-mode-local-def
+ "some value")
+
+
+;;; Provide
+;;
+(provide 'test)
Index: tests/test.make
===================================================================
RCS file: tests/test.make
diff -N tests/test.make
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/test.make 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,60 @@
+# Test makefile -*- makefile -*-
+
+top=
+ede_FILES=Project.ede Makefile
+
+example_MISC=semantic-skel.el skeleton.bnf
+init_LISP=semantic-load.el
+DISTDIR=$(top)semantic-$(VERSION)
+
+# really goofy & variables tabs
+A= B
+A =B
+A=B C
+A=B\
+ C
+
+A= http://${B} \
+ ftp://${B}
+B= test
+
+all: example semantic Languages tools senator semantic.info
+
+test ${B}: foo bar
+ @echo ${A}
+
+example:
+ @
+
+init: $(init_LISP)
+ @echo "(add-to-list 'load-path nil)" > address@hidden
+ @if test ! -z "${LOADPATH}" ; then\
+ for loadpath in ${LOADPATH}; do \
+ echo "(add-to-list 'load-path \"$$loadpath\")" >> address@hidden;
\
+ done;\
+ fi
+ @echo "(setq debug-on-error t)" >> address@hidden
+ $(EMACS) -batch -l address@hidden -f batch-byte-compile $^
+
+include tesset.mk tusset.mk
+include oneset.mk
+
+ifdef SOME_SYMBOL
+ VAR1 = foo
+else
+ VAR1 = bar
+endif
+
+ifndef SOME_OTHER_SYMBOL
+ VAR1 = baz
+endif
+
+ifeq ($(VAR1), foo)
+ VAR2 = gleep
+else
+ ifneq ($(VAR1), foo)
+ VAR2 = glop
+ endif
+endif
+
+# End of Makefile
Index: tests/test.py
===================================================================
RCS file: tests/test.py
diff -N tests/test.py
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/test.py 28 Sep 2009 23:23:31 -0000 1.2
@@ -0,0 +1,579 @@
+# Test file for Python language.
+#
+# $Id: test.py,v 1.2 2009/09/28 23:23:31 cyd Exp $
+
+# Simle class compount statement with blank lines sprinkled.
+class Foo(Bar):
+
+ x = 1
+
+ y = 2
+
+# Simple def statement with no argument
+def sss():
+ i = 1
+
+# Simple def statement with arguments
+def ttt(x,y,z):
+ i = 1
+
+import foo
+
+for x in y:
+ print x
+
+while y > 0:
+ y = y - 1
+
+a=b=c=d=e=f=i=j=k=l=m=n=o=p=q=r=s=t=x=y=1
+
+if x:
+ x = 2
+ y = 3
+
+x = 2
+y = 3
+s and t
+q | r
+o ^ p
+m & n
+k << l
+z = 4
+i >> j
+e / f
+c * d
+a + b
+2 ** 5
+x
+s = "a" "b" "c"
+1
+
+# implicit continuation lines, see
+# http://docs.python.org/ref/implicit-joining.html
+
+a_list = [ 1, 2, 3,
+ 4, 5,
+ 6 ]
+
+a_tuple = (1, 2, 3,
+
+ 4, 5, 6)
+
+a_hash = { 'a':1, "b":2,
+ 'c' : 3,
+ "d" : 4 }
+
+
+def longarglist(a,
+ b,
+ c,
+ d):
+ a=1;
+ b=1;
+ c=1;
+ d=1;
+
+class longclasslist(xx.yyy,
+ zz.aa):
+ foo=1
+
+
+# wisent-python.wy chokes on this! -ryk 6/17/02
+
+class HTTPServer(xxx.yyy):
+ allow_reuse_address = 1 # Seems to make sense in testing environment
+ def server_bind(self):
+ SocketServer.TCPServer.server_bind(self)
+ host, port = self.socket.getsockname()
+ self.server_name = socket.getfqdn(host)
+ self.server_port = port
+
+
+#########################################################################
+### /usr/lib/python2.2/BaseHTTPServer.py
+#########################################################################
+
+"""HTTP server base class.
+
+Note: the class in this module doesn't implement any HTTP request; see
+SimpleHTTPServer for simple implementations of GET, HEAD and POST
+(including CGI scripts).
+
+Contents:
+
+- BaseHTTPRequestHandler: HTTP request handler base class
+- test: test function
+
+XXX To do:
+
+- send server version
+- log requests even later (to capture byte count)
+- log user-agent header and other interesting goodies
+- send error log to separate file
+- are request names really case sensitive?
+
+"""
+
+
+# See also:
+#
+# HTTP Working Group T. Berners-Lee
+# INTERNET-DRAFT R. T. Fielding
+# <draft-ietf-http-v10-spec-00.txt> H. Frystyk Nielsen
+# Expires September 8, 1995 March 8, 1995
+#
+# URL: http://www.ics.uci.edu/pub/ietf/http/draft-ietf-http-v10-spec-00.txt
+
+
+# Log files
+# ---------
+#
+# Here's a quote from the NCSA httpd docs about log file format.
+#
+# | The logfile format is as follows. Each line consists of:
+# |
+# | host rfc931 authuser [DD/Mon/YYYY:hh:mm:ss] "request" ddd bbbb
+# |
+# | host: Either the DNS name or the IP number of the remote client
+# | rfc931: Any information returned by identd for this person,
+# | - otherwise.
+# | authuser: If user sent a userid for authentication, the user name,
+# | - otherwise.
+# | DD: Day
+# | Mon: Month (calendar name)
+# | YYYY: Year
+# | hh: hour (24-hour format, the machine's timezone)
+# | mm: minutes
+# | ss: seconds
+# | request: The first line of the HTTP request as sent by the client.
+# | ddd: the status code returned by the server, - if not available.
+# | bbbb: the total number of bytes sent,
+# | *not including the HTTP/1.0 header*, - if not available
+# |
+# | You can determine the name of the file accessed through request.
+#
+# (Actually, the latter is only true if you know the server configuration
+# at the time the request was made!)
+
+
+__version__ = "0.2"
+
+__all__ = ["HTTPServer", "BaseHTTPRequestHandler"]
+
+import sys
+import time
+import socket # For gethostbyaddr()
+import mimetools
+import SocketServer
+
+# Default error message
+DEFAULT_ERROR_MESSAGE = """\
+<head>
+<title>Error response</title>
+</head>
+<body>
+<h1>Error response</h1>
+<p>Error code %(code)d.
+<p>Message: %(message)s.
+<p>Error code explanation: %(code)s = %(explain)s.
+</body>
+"""
+
+
+class HTTPServer(SocketServer.TCPServer):
+
+ allow_reuse_address = 1 # Seems to make sense in testing environment
+
+ def server_bind(self):
+ """Override server_bind to store the server name."""
+ SocketServer.TCPServer.server_bind(self)
+ host, port = self.socket.getsockname()
+ self.server_name = socket.getfqdn(host)
+ self.server_port = port
+
+
+class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler):
+
+ """HTTP request handler base class.
+
+ The following explanation of HTTP serves to guide you through the
+ code as well as to expose any misunderstandings I may have about
+ HTTP (so you don't need to read the code to figure out I'm wrong
+ :-).
+
+ HTTP (HyperText Transfer Protocol) is an extensible protocol on
+ top of a reliable stream transport (e.g. TCP/IP). The protocol
+ recognizes three parts to a request:
+
+ 1. One line identifying the request type and path
+ 2. An optional set of RFC-822-style headers
+ 3. An optional data part
+
+ The headers and data are separated by a blank line.
+
+ The first line of the request has the form
+
+ <command> <path> <version>
+
+ where <command> is a (case-sensitive) keyword such as GET or POST,
+ <path> is a string containing path information for the request,
+ and <version> should be the string "HTTP/1.0". <path> is encoded
+ using the URL encoding scheme (using %xx to signify the ASCII
+ character with hex code xx).
+
+ The protocol is vague about whether lines are separated by LF
+ characters or by CRLF pairs -- for compatibility with the widest
+ range of clients, both should be accepted. Similarly, whitespace
+ in the request line should be treated sensibly (allowing multiple
+ spaces between components and allowing trailing whitespace).
+
+ Similarly, for output, lines ought to be separated by CRLF pairs
+ but most clients grok LF characters just fine.
+
+ If the first line of the request has the form
+
+ <command> <path>
+
+ (i.e. <version> is left out) then this is assumed to be an HTTP
+ 0.9 request; this form has no optional headers and data part and
+ the reply consists of just the data.
+
+ The reply form of the HTTP 1.0 protocol again has three parts:
+
+ 1. One line giving the response code
+ 2. An optional set of RFC-822-style headers
+ 3. The data
+
+ Again, the headers and data are separated by a blank line.
+
+ The response code line has the form
+
+ <version> <responsecode> <responsestring>
+
+ where <version> is the protocol version (always "HTTP/1.0"),
+ <responsecode> is a 3-digit response code indicating success or
+ failure of the request, and <responsestring> is an optional
+ human-readable string explaining what the response code means.
+
+ This server parses the request and the headers, and then calls a
+ function specific to the request type (<command>). Specifically,
+ a request SPAM will be handled by a method do_SPAM(). If no
+ such method exists the server sends an error response to the
+ client. If it exists, it is called with no arguments:
+
+ do_SPAM()
+
+ Note that the request name is case sensitive (i.e. SPAM and spam
+ are different requests).
+
+ The various request details are stored in instance variables:
+
+ - client_address is the client IP address in the form (host,
+ port);
+
+ - command, path and version are the broken-down request line;
+
+ - headers is an instance of mimetools.Message (or a derived
+ class) containing the header information;
+
+ - rfile is a file object open for reading positioned at the
+ start of the optional input data part;
+
+ - wfile is a file object open for writing.
+
+ IT IS IMPORTANT TO ADHERE TO THE PROTOCOL FOR WRITING!
+
+ The first thing to be written must be the response line. Then
+ follow 0 or more header lines, then a blank line, and then the
+ actual data (if any). The meaning of the header lines depends on
+ the command executed by the server; in most cases, when data is
+ returned, there should be at least one header line of the form
+
+ Content-type: <type>/<subtype>
+
+ where <type> and <subtype> should be registered MIME types,
+ e.g. "text/html" or "text/plain".
+
+ """
+
+ # The Python system version, truncated to its first component.
+ sys_version = "Python/" + sys.version.split()[0]
+
+ # The server software version. You may want to override this.
+ # The format is multiple whitespace-separated strings,
+ # where each string is of the form name[/version].
+ server_version = "BaseHTTP/" + __version__
+
+ def parse_request(self):
+ """Parse a request (internal).
+
+ The request should be stored in self.raw_request; the results
+ are in self.command, self.path, self.request_version and
+ self.headers.
+
+ Return value is 1 for success, 0 for failure; on failure, an
+ error is sent back.
+
+ """
+ self.request_version = version = "HTTP/0.9" # Default
+ requestline = self.raw_requestline
+ if requestline[-2:] == '\r\n':
+ requestline = requestline[:-2]
+ elif requestline[-1:] == '\n':
+ requestline = requestline[:-1]
+ self.requestline = requestline
+ words = requestline.split()
+ if len(words) == 3:
+ [command, path, version] = words
+ if version[:5] != 'HTTP/':
+ self.send_error(400, "Bad request version (%s)" % `version`)
+ return 0
+ elif len(words) == 2:
+ [command, path] = words
+ if command != 'GET':
+ self.send_error(400,
+ "Bad HTTP/0.9 request type (%s)" % `command`)
+ return 0
+ else:
+ self.send_error(400, "Bad request syntax (%s)" % `requestline`)
+ return 0
+ self.command, self.path, self.request_version = command, path, version
+ self.headers = self.MessageClass(self.rfile, 0)
+ return 1
+
+ def handle(self):
+ """Handle a single HTTP request.
+
+ You normally don't need to override this method; see the class
+ __doc__ string for information on how to handle specific HTTP
+ commands such as GET and POST.
+
+ """
+
+ self.raw_requestline = self.rfile.readline()
+ if not self.parse_request(): # An error code has been sent, just exit
+ return
+ mname = 'do_' + self.command
+ if not hasattr(self, mname):
+ self.send_error(501, "Unsupported method (%s)" % `self.command`)
+ return
+ method = getattr(self, mname)
+ method()
+
+ def send_error(self, code, message=None):
+ """Send and log an error reply.
+
+ Arguments are the error code, and a detailed message.
+ The detailed message defaults to the short entry matching the
+ response code.
+
+ This sends an error response (so it must be called before any
+ output has been generated), logs the error, and finally sends
+ a piece of HTML explaining the error to the user.
+
+ """
+
+ try:
+ short, long = self.responses[code]
+ except KeyError:
+ short, long = '???', '???'
+ if not message:
+ message = short
+ explain = long
+ self.log_error("code %d, message %s", code, message)
+ self.send_response(code, message)
+ self.send_header("Content-Type", "text/html")
+ self.end_headers()
+ self.wfile.write(self.error_message_format %
+ {'code': code,
+ 'message': message,
+ 'explain': explain})
+
+ error_message_format = DEFAULT_ERROR_MESSAGE
+
+ def send_response(self, code, message=None):
+ """Send the response header and log the response code.
+
+ Also send two standard headers with the server software
+ version and the current date.
+
+ """
+ self.log_request(code)
+ if message is None:
+ if self.responses.has_key(code):
+ message = self.responses[code][0]
+ else:
+ message = ''
+ if self.request_version != 'HTTP/0.9':
+ self.wfile.write("%s %s %s\r\n" %
+ (self.protocol_version, str(code), message))
+ self.send_header('Server', self.version_string())
+ self.send_header('Date', self.date_time_string())
+
+ def send_header(self, keyword, value):
+ """Send a MIME header."""
+ if self.request_version != 'HTTP/0.9':
+ self.wfile.write("%s: %s\r\n" % (keyword, value))
+
+ def end_headers(self):
+ """Send the blank line ending the MIME headers."""
+ if self.request_version != 'HTTP/0.9':
+ self.wfile.write("\r\n")
+
+ def log_request(self, code='-', size='-'):
+ """Log an accepted request.
+
+ This is called by send_reponse().
+
+ """
+
+ self.log_message('"%s" %s %s',
+ self.requestline, str(code), str(size))
+
+ def log_error(self, *args):
+ """Log an error.
+
+ This is called when a request cannot be fulfilled. By
+ default it passes the message on to log_message().
+
+ Arguments are the same as for log_message().
+
+ XXX This should go to the separate error log.
+
+ """
+
+ apply(self.log_message, args)
+
+ def log_message(self, format, *args):
+ """Log an arbitrary message.
+
+ This is used by all other logging functions. Override
+ it if you have specific logging wishes.
+
+ The first argument, FORMAT, is a format string for the
+ message to be logged. If the format string contains
+ any % escapes requiring parameters, they should be
+ specified as subsequent arguments (it's just like
+ printf!).
+
+ The client host and current date/time are prefixed to
+ every message.
+
+ """
+
+ sys.stderr.write("%s - - [%s] %s\n" %
+ (self.address_string(),
+ self.log_date_time_string(),
+ format%args))
+
+ def version_string(self):
+ """Return the server software version string."""
+ return self.server_version + ' ' + self.sys_version
+
+ def date_time_string(self):
+ """Return the current date and time formatted for a message header."""
+ now = time.time()
+ year, month, day, hh, mm, ss, wd, y, z = time.gmtime(now)
+ s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
+ self.weekdayname[wd],
+ day, self.monthname[month], year,
+ hh, mm, ss)
+ return s
+
+ def log_date_time_string(self):
+ """Return the current time formatted for logging."""
+ now = time.time()
+ year, month, day, hh, mm, ss, x, y, z = time.localtime(now)
+ s = "%02d/%3s/%04d %02d:%02d:%02d" % (
+ day, self.monthname[month], year, hh, mm, ss)
+ return s
+
+ weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+ monthname = [None,
+ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+ 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+
+ def address_string(self):
+ """Return the client address formatted for logging.
+
+ This version looks up the full hostname using gethostbyaddr(),
+ and tries to find a name that contains at least one dot.
+
+ """
+
+ host, port = self.client_address
+ return socket.getfqdn(host)
+
+ # Essentially static class variables
+
+ # The version of the HTTP protocol we support.
+ # Don't override unless you know what you're doing (hint: incoming
+ # requests are required to have exactly this version string).
+ protocol_version = "HTTP/1.0"
+
+ # The Message-like class used to parse headers
+ MessageClass = mimetools.Message
+
+ # Table mapping response codes to messages; entries have the
+ # form {code: (shortmessage, longmessage)}.
+ # See http://www.w3.org/hypertext/WWW/Protocols/HTTP/HTRESP.html
+ responses = {
+ 200: ('OK', 'Request fulfilled, document follows'),
+ 201: ('Created', 'Document created, URL follows'),
+ 202: ('Accepted',
+ 'Request accepted, processing continues off-line'),
+ 203: ('Partial information', 'Request fulfilled from cache'),
+ 204: ('No response', 'Request fulfilled, nothing follows'),
+
+ 301: ('Moved', 'Object moved permanently -- see URI list'),
+ 302: ('Found', 'Object moved temporarily -- see URI list'),
+ 303: ('Method', 'Object moved -- see Method and URL list'),
+ 304: ('Not modified',
+ 'Document has not changed singe given time'),
+
+ 400: ('Bad request',
+ 'Bad request syntax or unsupported method'),
+ 401: ('Unauthorized',
+ 'No permission -- see authorization schemes'),
+ 402: ('Payment required',
+ 'No payment -- see charging schemes'),
+ 403: ('Forbidden',
+ 'Request forbidden -- authorization will not help'),
+ 404: ('Not found', 'Nothing matches the given URI'),
+
+ 500: ('Internal error', 'Server got itself in trouble'),
+ 501: ('Not implemented',
+ 'Server does not support this operation'),
+ 502: ('Service temporarily overloaded',
+ 'The server cannot process the request due to a high load'),
+ 503: ('Gateway timeout',
+ 'The gateway server did not receive a timely response'),
+
+ }
+
+
+def test(HandlerClass = BaseHTTPRequestHandler,
+ ServerClass = HTTPServer):
+ """Test the HTTP request handler class.
+
+ This runs an HTTP server on port 8000 (or the first command line
+ argument).
+
+ """
+
+ if sys.argv[1:]:
+ port = int(sys.argv[1])
+ else:
+ port = 8000
+ server_address = ('', port)
+
+ httpd = ServerClass(server_address, HandlerClass)
+
+ sa = httpd.socket.getsockname()
+ print "Serving HTTP on", sa[0], "port", sa[1], "..."
+ httpd.serve_forever()
+
+
+if __name__ == '__main__':
+ test()
Index: tests/testdoublens.cpp
===================================================================
RCS file: tests/testdoublens.cpp
diff -N tests/testdoublens.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testdoublens.cpp 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,148 @@
+//
+// CPP file for semantic-ia-utest
+// completion engine unit tests.
+//
+#include "testdoublens.hpp"
+
+namespace Name1 {
+ namespace Name2 {
+
+ Foo::Foo()
+ {
+ p// -1-
+ // #1# ( "pMumble" "publishStuff" )
+ ;
+ }
+
+ int Foo::get() // ^1^
+ {
+ p// -2-
+ // #2# ( "pMumble" "publishStuff" )
+ ;
+ return 0;
+ }
+
+ void Foo::publishStuff(int /* a */, int /* b */) // ^2^
+ {
+ }
+
+ void Foo::sendStuff(int /* a */, int /* b */) // ^3^
+ {
+ }
+
+ } // namespace Name2
+} // namespace Name1
+
+// Test multiple levels of metatype expansion
+int test_fcn () {
+ stage3_Foo MyFoo;
+
+ MyFoo.// -3-
+ // #3# ( "Mumble" "get" )
+ ;
+
+ Name1::Name2::F//-4-
+ // #4# ( "Foo" )
+ ;
+
+ // @TODO - get this working...
+ Name1::stage2_Foo::M//-5-
+ /// #5# ( "Mumble" )
+ ;
+}
+
+stage3_Foo foo_fcn() {
+ // Can we go "up" to foo with senator-go-to-up-reference?
+}
+
+
+// Second test from Ravikiran Rajagopal
+
+namespace A {
+ class foo {
+ public:
+ void aa();
+ void bb();
+ };
+}
+namespace A {
+ class bar {
+ public:
+ void xx();
+ public:
+ foo myFoo;
+ };
+
+ void bar::xx()
+ {
+ myFoo.// -6- <--- cursor is here after the dot
+ // #6# ( "aa" "bb" )
+ ;
+ }
+}
+
+// Double namespace example from Hannu Koivisto
+//
+// This is tricky because the parent class "Foo" is found within the
+// scope of B, so the scope calculation needs to put that together
+// before searching for parents in scope.
+namespace a {
+ namespace b {
+
+ class Bar : public Foo
+ {
+ int baz();
+ };
+
+ int Bar::baz()
+ {
+ return dum// -7-
+ // #7# ( "dumdum" )
+ ;
+ }
+
+ } // namespace b
+} // namespace a
+
+// Three namespace example from Hannu Koivisto
+//
+// This one is special in that the name e::Foo, where "e" is in
+// the scope, and not referenced from the global namespace. This
+// wasn't previously handled, so the fullscope needed to be added
+// to the list of things searched when in split-name decent search mode
+// for scopes.
+
+namespace d {
+ namespace e {
+
+ class Foo
+ {
+ public:
+ int write();
+ };
+
+ } // namespace d
+} // namespace e
+
+
+namespace d {
+ namespace f {
+
+ class Bar
+ {
+ public:
+ int baz();
+
+ private:
+ e::Foo &foo;
+ };
+
+ int Bar::baz()
+ {
+ return foo.w// -8-
+ // #8# ( "write" )
+ ;
+ }
+
+ } // namespace f
+} // namespace d
Index: tests/testdoublens.hpp
===================================================================
RCS file: tests/testdoublens.hpp
diff -N tests/testdoublens.hpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testdoublens.hpp 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,51 @@
+//
+// Header file used in one of the ia-utest tests.
+//
+namespace Name1 {
+ namespace Name2 {
+
+ class Foo
+ {
+ typedef unsigned int Mumble;
+ public:
+ Foo();
+ ~Foo();
+ int get();
+
+ private:
+ void publishStuff(int a, int b);
+
+ void sendStuff(int a, int b);
+
+ Mumble* pMumble;
+ };
+
+ typedef Foo stage1_Foo;
+
+ } // namespace Name2
+
+ typedef Name2::stage1_Foo stage2_Foo;
+
+ typedef Name2::Foo decl_stage1_Foo;
+
+} // namespace Name1
+
+typedef Name1::stage2_Foo stage3_Foo;
+
+
+// Double namespace from Hannu Koivisto
+namespace a {
+ namespace b {
+
+ class Foo
+ {
+ struct Dum {
+ int diDum;
+ };
+
+ protected:
+ mutable a::b::Foo::Dum dumdum;
+ };
+
+ } // namespace b
+} // namespace a
Index: tests/testfriends.cpp
===================================================================
RCS file: tests/testfriends.cpp
diff -N tests/testfriends.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testfriends.cpp 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,37 @@
+// Test parsing of friends and how they are used in completion.
+/*
+ >> Thanks Damien Profeta for the nice example.
+ >
+ > I paste a small example.
+ > It would be great if friend can be well parsed and even greater if
+ > class B can access to all the members of A.
+*/
+
+class Af // %2% ( ( "testfriends.cpp" ) ( "Af" "B::testB" ) )
+{
+public:
+ int pubVar;
+private:
+ int privateVar;
+
+ friend class B;
+
+};
+
+class B
+{
+public:
+ int testB();
+ int testAB();
+
+};
+
+
+int B::testB() {
+ Af classA;
+ classA.//-1-
+ ; //#1# ( "privateVar" "pubVar" )
+}
+
+int B::testAB() { // %1% ( ( "testfriends.cpp" ) ( "B" "B::testAB" ) )
+}
Index: tests/testjavacomp.java
===================================================================
RCS file: tests/testjavacomp.java
diff -N tests/testjavacomp.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testjavacomp.java 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,69 @@
+/** testjavacomp.java ---
+ *
+ * Copyright (C) 2009 Eric M. Ludlam
+ *
+ * Author: Eric M. Ludlam <address@hidden>
+ * X-RCS: $Id: testjavacomp.java,v 1.2 2009/09/28 23:23:32 cyd Exp $
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+package tests.testjavacomp;
+
+class secondClass {
+ private void scFuncOne() { }
+ public void scFuncOne() { }
+}
+
+
+public class testjavacomp {
+
+ private int funcOne() { }
+ private int funcTwo() { }
+ private char funcThree() { }
+
+ class nestedClass {
+ private void ncFuncOne() { }
+ public void ncFuncOne() { }
+ }
+
+ public void publicFunc() {
+
+ int i;
+
+ i = fu// -1-
+ // #1# ( "funcOne" "funcTwo" )
+ ;
+
+ fu// -2-
+ // #2# ( "funcOne" "funcThree" "funcTwo" )
+ ;
+
+ secondClass SC;
+
+ SC.//-3-
+ // #3# ( "scFuncOne" )
+ ;
+
+ nestedClass NC;
+
+ // @todo - need to fix this? I don't know if this is legal java.
+ NC.// - 4-
+ // #4# ( "ncFuncOne" )
+ ;
+ }
+
+} // testjavacomp
Index: tests/testnsp.cpp
===================================================================
RCS file: tests/testnsp.cpp
diff -N tests/testnsp.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testnsp.cpp 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,28 @@
+// Test NSP (Name space parent)
+//
+// Test dereferencing parents based on local parent scope.
+//
+// Derived from data David Engster provided.
+
+namespace nsp {
+
+ class rootclass {
+ public:
+ int fromroot() {};
+ };
+
+}
+
+namespace nsp {
+ class childclass : public rootclass {
+ public:
+ int fromchild() {};
+ };
+}
+
+void myfcn_not_in_ns (void) {
+ nsp::childclass test;
+
+ test.// -1-
+ ; // #1# ( "fromchild" "fromroot" )
+}
Index: tests/testpolymorph.cpp
===================================================================
RCS file: tests/testpolymorph.cpp
diff -N tests/testpolymorph.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testpolymorph.cpp 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,131 @@
+/** testpolymorph.cpp --- A sequence of polymorphism examples.
+ *
+ * Copyright (C) 2009 Eric M. Ludlam
+ *
+ * Author: Eric M. Ludlam <address@hidden>
+ * X-RCS: $Id: testpolymorph.cpp,v 1.2 2009/09/28 23:23:32 cyd Exp $
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <cmath>
+
+// Test 1 - Functions w/ prototypes
+namespace proto {
+
+ int pt_func1(int arg1);
+ int pt_func1(int arg1) {
+ return 0;
+ }
+
+}
+
+// Test 2 - Functions w/ different arg lists.
+namespace fcn_poly {
+
+ int pm_func(void) {
+ return 0;
+ }
+ int pm_func(int a) {
+ return a;
+ }
+ int pm_func(char a) {
+ return int(a);
+ }
+ int pm_func(double a) {
+ return int(floor(a));
+ }
+
+}
+
+// Test 3 - Methods w/ differet arg lists.
+class meth_poly {
+public:
+ int pm_meth(void) {
+ return 0;
+ }
+ int pm_meth(int a) {
+ return a;
+ }
+ int pm_meth(char a) {
+ return int(a);
+ }
+ int pm_meth(double a) {
+ return int(floor(a));
+ }
+
+};
+
+// Test 4 - Templates w/ partial specifiers.
+namespace template_partial_spec {
+ template <typename T> class test
+ {
+ public:
+ void doSomething(T t) { };
+ };
+
+ template <typename T> class test<T *>
+ {
+ public:
+ void doSomething(T* t) { };
+ };
+}
+
+// Test 5 - Templates w/ full specicialization which may or may not share
+// common functions.
+namespace template_full_spec {
+ template <typename T> class test
+ {
+ public:
+ void doSomething(T t) { };
+ void doSomethingElse(T t) { };
+ };
+
+ template <> class test<int>
+ {
+ public:
+ void doSomethingElse(int t) { };
+ void doSomethingCompletelyDifferent(int t) { };
+ };
+}
+
+// Test 6 - Dto., but for templates with multiple parameters.
+namespace template_multiple_spec {
+ template <typename T1, typename T2> class test
+ {
+ public:
+ void doSomething(T1 t) { };
+ void doSomethingElse(T2 t) { };
+ };
+
+ template <typename T2> class test<int, T2>
+ {
+ public:
+ void doSomething(int t) { };
+ void doSomethingElse(T2 t) { };
+ };
+
+ template <> class test<float, int>
+ {
+ public:
+ void doSomething(float t) { };
+ void doSomethingElse(int t) { };
+ void doNothing(void) { };
+ };
+}
+
+
+// End of polymorphism test file.
Index: tests/testspp.c
===================================================================
RCS file: tests/testspp.c
diff -N tests/testspp.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testspp.c 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,84 @@
+/* Attempt to test the C preprocessor
+ *
+ */
+
+int some_fcn (){}
+
+
+#ifndef MOOSE
+int pre_show_moose(){}
+#endif
+
+#ifdef MOOSE
+int pre_dont_show_moose(){}
+#endif
+
+#if !defined(MOOSE)
+int pre_show_moose_if(){}
+#endif
+
+#if defined(MOOSE)
+int pre_dont_show_moose_if(){}
+#endif
+
+#define MOOSE
+
+#if 0
+int dont_show_function_if_0(){}
+#endif
+
+#if 1
+int show_function_if_1(){}
+#endif
+
+#ifdef MOOSE
+int moose_function(){}
+#endif
+
+#ifndef MOOSE
+int dont_show_moose(){}
+#endif
+
+#if defined(MOOSE)
+int moose_function_if(){}
+#endif
+
+#if !defined(MOOSE)
+int dont_show_moose_if() {}
+#endif
+
+#undef MOOSE
+
+#ifdef MOOSE
+int no_handy_moose(){}
+#endif
+
+#ifndef MOOSE
+int show_moose_else() {}
+#else
+int no_show_moose_else(){}
+#endif
+
+
+#ifdef MOOSE
+int no_show_moose_else_2() {}
+#else
+int show_moose_else_2() {}
+#endif
+
+#if defined(MOOSE)
+int no_show_moose_elif() {}
+#elif !defined(MOOSE)
+int show_moose_elif() {}
+#else
+int no_show_moose_elif_else() {}
+#endif
+
+#if defined(MOOSE)
+int no_show_moose_if_elif_2() {}
+#elif defined(COW)
+int no_show_moose_elif_2() {}
+#else
+int show_moose_elif_else() {}
+#endif
+
Index: tests/testsppcomplete.c
===================================================================
RCS file: tests/testsppcomplete.c
diff -N tests/testsppcomplete.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testsppcomplete.c 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,29 @@
+/* Example provided by Hannes Janetzek */
+
+struct Test { int test; };
+
+#define BLA(_type) \
+ _type *bla = (_type*) malloc(sizeof(_type));
+
+#define BLUB(_type) \
+ (_type*)malloc(sizeof(_type));
+
+#define FOO(_type) \
+ _type *foo = BLUB(_type);
+
+#define BAR(_type) \
+ _type *bar = (*_type)BLUB(_type);
+
+int main(int argc, char *argv[]) {
+ BLA(Test);
+ bla->// -1-
+ ; // #1# ( "test" )
+
+ FOO(Test);
+ foo->// -2-
+ ; // #2# ( "test" )
+
+ BAR(Test);
+ bar->// -3-
+ ; // #3# ( "test" )
+}
Index: tests/testsppreplace.c
===================================================================
RCS file: tests/testsppreplace.c
diff -N tests/testsppreplace.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testsppreplace.c 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,135 @@
+/* Test CPP/SPP Replacement
+ */
+
+/* TEST: The EMU keyword doesn't screw up the function defn. */
+#define EMU
+#define EMU2 /*comment*/
+char EMU parse_around_emu EMU2 (EMU)
+{
+}
+
+/* TEST: A simple word can be replaced in a definition. */
+#define SUBFLOAT /* Some Float */ float
+SUBFLOAT returnanfloat()
+{
+}
+
+/* TEST: Punctuation an be replaced in a definition. */
+#define COLON :
+int foo COLON COLON bar ()
+{
+}
+
+/* TEST: Multiple lexical characters in a definition */
+#define SUPER mysuper::
+int SUPER baz ()
+{
+}
+
+/* TEST: Macro replacement. */
+#define INT_FCN(name) int name (int in)
+
+INT_FCN(increment) {
+ return in+1;
+}
+
+/* TEST: Macro replacement with complex args */
+#define P_(proto) ()
+
+int myFcn1 P_((a,b));
+
+#define P__(proto) proto
+
+int myFcn2 P__((int a, int b));
+int myFcn3 (int a, int b);
+
+/* TEST: Multiple args to a macro. */
+#define MULTI_ARGS(name, field1, field2, field3) struct name { int field1; int
field2; int field3; }
+
+MULTI_ARGS(ma_struct, moose, penguin, emu);
+
+/* TEST: Macro w/ args, but no body. */
+#define NO_BODY(name)
+
+NO_BODY(Moose);
+
+/* TEST: Not a macro with args, but close. */
+#define NOT_WITH_ARGS (moose)
+
+int not_with_args_fcn NOT_WITH_ARGS
+{
+}
+
+/* TEST: macro w/ continuation. */
+#define WITH_CONT \
+ continuation_symbol
+
+int WITH_CONT () { };
+
+/* TEST: macros in a macro - tail processing */
+#define tail_with_args_and_long_name(a) (int a)
+#define int_arg tail_with_args_and_long_name
+
+int tail int_arg(q) {}
+
+/* TEST: macros used improperly. */
+#define tail_fail tail_with_args_and_long_name(q)
+
+int tail_fcn tail_fail(q);
+
+/* TEST: feature of CPP from LSD <address@hidden> */
+#define __gthrw_(name) __gthrw_ ## name
+
+int __gthrw_(foo) (int arg1) { }
+
+/* TEST: macros using macros */
+#define macro_foo foo
+#define mf_declare int macro_foo
+
+mf_declare;
+
+/* TEST: macros with args using macros */
+#define Amacro(A) (int A)
+#define mf_Amacro(B) int B Amacro(B)
+
+mf_Amacro(noodle);
+
+/* TEST: Double macro using the argument stack. */
+#define MACRO0(name) int that_ ## name(int i);
+#define MACRO1(name) int this_ ## name(int i);
+#define MACRO2(name) MACRO0(name) MACRO1(name)
+
+MACRO2(foo)
+
+/* TEST: The G++ namespace macro hack. Not really part of SPP. */
+_GLIBCXX_BEGIN_NAMESPACE(baz)
+
+ int bazfnc(int b) { }
+
+_GLIBCXX_END_NAMESPACE;
+
+_GLIBCXX_BEGIN_NESTED_NAMESPACE(foo,bar)
+
+ int foo_bar_func(int a) { }
+
+_GLIBCXX_END_NESTED_NAMESPACE;
+
+
+/* TEST: The VC++ macro hack. */
+_STD_BEGIN
+
+ int inside_std_namespace(int a) { }
+
+_STD_END
+
+/* TEST: Recursion prevention. CPP doesn't allow even 1 level of recursion. */
+#define STARTMACRO MACROA
+#define MACROA MACROB
+#define MACROB MACROA
+
+int STARTMACRO () {
+
+}
+
+
+/* END */
Index: tests/testsppreplaced.c
===================================================================
RCS file: tests/testsppreplaced.c
diff -N tests/testsppreplaced.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testsppreplaced.c 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,97 @@
+/* What the SPP replace file would looklike with MACROS replaced.
+ */
+
+/* TEST: The EMU keyword doesn't screw up the function defn. */
+char parse_around_emu ()
+{
+}
+
+/* TEST: A simple word can be replaced in a definition. */
+float returnanfloat()
+{
+}
+
+/* TEST: Punctuation an be replaced in a definition. */
+int foo::bar ()
+{
+}
+
+/* TEST: Multiple lexical characters in a definition */
+int mysuper::baz ()
+{
+}
+
+/* TEST: Macro replacement. */
+int increment (int in) {
+ return in+1;
+}
+
+/* TEST: Macro replacement with complex args */
+int myFcn1 ();
+
+int myFcn2 (int a, int b);
+int myFcn3 (int a, int b);
+
+/* TEST: Multiple args to a macro. */
+struct ma_struct { int moose; int penguin; int emu; };
+
+/* TEST: Macro w/ args, but no body. */
+
+/* TEST: Not a macro with args, but close. */
+int not_with_args_fcn (moose)
+{
+}
+
+/* TEST: macro w/ continuation. */
+int continuation_symbol () { };
+
+/* TEST: macros in a macro - tail processing */
+
+int tail (int q) {}
+
+/* TEST: macros used impropertly. */
+
+int tail_fcn(int q);
+
+/* TEST: feature of CPP from LSD <address@hidden> */
+
+int __gthrw_foo (int arg1) { }
+
+/* TEST: macros using macros */
+int foo;
+
+/* TEST: macros with args using macros */
+int noodle(int noodle);
+
+/* TEST: Double macro using the argument stack. */
+int that_foo(int i);
+int this_foo(int i);
+
+/* TEST: The G++ namespace macro hack. Not really part of SPP. */
+namespace baz {
+
+ int bazfnc(int b) { }
+
+}
+
+namespace foo { namespace bar {
+
+ int foo_bar_func(int a) { }
+
+ }
+}
+
+/* TEST: The VC++ macro hack. */
+namespace std {
+
+ int inside_std_namespace(int a) { }
+
+}
+
+/* TEST: Recursion prevention. CPP doesn't allow even 1 level of recursion. */
+int MACROA () {
+
+}
+
+
+/* End */
Index: tests/teststruct.cpp
===================================================================
RCS file: tests/teststruct.cpp
diff -N tests/teststruct.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/teststruct.cpp 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,66 @@
+// Combinations of templates and structure inheritance.
+//
+// Created by Alex Ott.
+
+template <typename DerivedT>
+struct grammar {
+public:
+ typedef grammar<DerivedT> self_t;
+ typedef DerivedT const& embed_t;
+ grammar() {}
+ ~grammar() { }
+ void use_parser() const { }
+ void test1() { }
+};
+
+struct PDFbool_parser : public grammar<PDFbool_parser> {
+ PDFbool_parser() {}
+ template <typename scannerT> struct definition {
+ typedef typename scannerT::iterator_t iterator_t;
+ int top;
+ definition(const PDFbool_parser& /*self*/) {
+ return ;
+ }
+ const int start() const {
+ return top;
+ }
+ };
+};
+
+int main(void) {
+ PDFbool_parser PDFbool_p = PDFbool_parser();
+ PDFbool_p.//-1-
+ ;
+ // #1# ("definition" "embed_t" "self_t" "test1" "use_parser")
+}
+
+// ----------------------------------------------------------------------
+
+template <class Derived> struct Base {
+public:
+ void interface()
+ {
+ // ...
+ static_cast<Derived*>(this)->implementation();
+ // ...
+ }
+
+ static void static_func()
+ {
+ // ...
+ Derived::static_sub_func();
+ // ...
+ }
+};
+
+struct Derived : Base<Derived> {
+ void implementation() { }
+ static void static_sub_func() { }
+};
+
+int foo () {
+ Derived d;
+ d.//-2-
+ ;
+ // #2# ("implementation" "interface" "static_func" "static_sub_func")
+}
Index: tests/testsubclass.cpp
===================================================================
RCS file: tests/testsubclass.cpp
diff -N tests/testsubclass.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testsubclass.cpp 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,231 @@
+/* Special test file for Semantic Analyzer and complex C++ inheritance.
+ */
+
+//#include <iostream>
+#include "testsubclass.hh"
+
+void animal::moose::setFeet(int numfeet) //^1^
+{
+ if (numfeet > 4) {
+ std::cerr << "Why would a moose have more than 4 feet?" << std::endl;
+ return;
+ }
+
+ fFeet = numfeet;
+}
+
+int animal::moose::getFeet() //^2^
+{
+ return fFeet;
+}
+
+void animal::moose::doNothing() //^3^
+{
+ animal::moose foo();
+
+ fFeet = N// -15-
+ ; // #15# ( "NAME1" "NAME2" "NAME3" )
+}
+
+
+void deer::moose::setAntlers(bool have_antlers) //^4^
+{
+ fAntlers = have_antlers;
+}
+
+bool deer::moose::getAntlers() //^5^
+// %1% ( ( "testsubclass.cpp" "testsubclass.hh" ) ( "deer::moose::doSomething"
"deer::moose::getAntlers" "moose" ) )
+{
+ return fAntlers;
+}
+
+bool i_dont_have_symrefs()
+// %2% ( ("testsubclass.cpp" ) ("i_dont_have_symrefs"))
+{
+}
+
+void deer::moose::doSomething() //^6^
+{
+ // All these functions should be identified by semantic analyzer.
+ getAntlers();
+ setAntlers(true);
+
+ getFeet();
+ setFeet(true);
+
+ doNothing();
+
+ fSomeField = true;
+
+ fIsValid = true;
+}
+
+void deer::alces::setLatin(bool l) {
+ fLatin = l;
+}
+
+bool deer::alces::getLatin() {
+ return fLatin;
+}
+
+void deer::alces::doLatinStuff(moose moosein) {
+ // All these functions should be identified by semantic analyzer.
+ getFeet();
+ setFeet(true);
+
+ getLatin();
+ setLatin(true);
+
+ doNothing();
+
+ deer::moose foo();
+
+
+}
+
+moose deer::alces::createMoose()
+{
+ moose MooseVariableName;
+ bool tmp;
+ int itmp;
+ bool fool;
+ int fast;
+
+ MooseVariableName = createMoose();
+
+ doLatinStuff(MooseVariableName);
+
+ tmp = this.f// -1-
+ // #1# ( "fAlcesBool" "fIsValid" "fLatin" )
+ ;
+
+ itmp = this.f// -2-
+ // #2# ( "fAlcesInt" "fGreek" "fIsProtectedInt" )
+ ;
+
+ tmp = f// -3-
+ // #3# ( "fAlcesBool" "fIsValid" "fLatin" "fool" )
+ ;
+
+ itmp = f// -4-
+ // #4# ( "fAlcesInt" "fGreek" "fIsProtectedInt" "fast" )
+ ;
+
+ MooseVariableName = m// -5-
+ // #5# ( "moose" )
+
+ return MooseVariableName;
+}
+
+/** Test Scope Changes
+ *
+ * This function is rigged to make sure the scope changes to account
+ * for different locations in local variable parsing.
+ */
+int someFunction(int mPickle)
+{
+ moose mMoose = deer::alces::createMoose();
+
+ if (mPickle == 1) {
+
+ int mOption1 = 2;
+
+ m// -5-
+ // #5# ( "mMoose" "mOption1" "mPickle" )
+ ;
+
+ } else {
+
+ int mOption2 = 2;
+
+ m// -6-
+ // #6# ( "mMoose" "mOption2" "mPickle" )
+ ;
+ }
+
+}
+
+// Thanks Ming-Wei Chang for this next example.
+
+namespace pub_priv {
+
+ class A{
+ private:
+ void private_a(){}
+ public:
+ void public_a();
+ };
+
+ void A::public_a() {
+ A other_a;
+
+ other_a.p// -7-
+ // #7# ( "private_a" "public_a" )
+ ;
+ }
+
+ int some_regular_function(){
+ A a;
+ a.p// -8-
+ // #8# ( "public_a" )
+ ;
+ return 0;
+ }
+
+}
+
+
+/** Test Scope w/in a function (non-method) with classes using
+ * different levels of inheritance.
+ */
+int otherFunction()
+{
+ sneaky::antelope Antelope(1);
+ sneaky::jackalope Jackalope(1);
+ sneaky::bugalope Bugalope(1);
+
+ Antelope.// -9-
+ // #9# ( "fAntyPublic" "fQuadPublic" "testAccess")
+ ;
+
+ Jackalope.// -10-
+ // #10# ( "fBunnyPublic" "testAccess")
+ ;
+
+ Jackalope// @1@ 6
+ ;
+ Jackalope;
+ Jackalope;
+ Jackalope;
+
+ Bugalope.// -11-
+ // #11# ( "fBugPublic" "testAccess")
+ ;
+ Bugalope// @2@ 3
+ ;
+}
+
+/** Test methods within each class for types of access to the baseclass.
+ */
+
+bool sneaky::antelope::testAccess() //^7^
+{
+ this.// -12-
+ // #12# ( "fAntyPrivate" "fAntyProtected" "fAntyPublic" "fQuadProtected"
"fQuadPublic" "testAccess" )
+ ;
+}
+
+bool sneaky::jackalope::testAccess() //^8^
+{
+ this.// -13-
+ // #13# ( "fBunnyPrivate" "fBunnyProtected" "fBunnyPublic"
"fQuadProtected" "fQuadPublic" "testAccess" )
+ ;
+}
+
+bool sneaky::bugalope::testAccess() //^9^
+{
+ this.// -14-
+ // #14# ( "fBugPrivate" "fBugProtected" "fBugPublic" "fQuadPublic"
"testAccess" )
+ ;
+}
+
Index: tests/testsubclass.hh
===================================================================
RCS file: tests/testsubclass.hh
diff -N tests/testsubclass.hh
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testsubclass.hh 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,175 @@
+/* Special test file for Semantic Analyzer and complex C++ inheritance.
+ *
+ * Header file for testsubclass.cpp with class defns but no
+ * implementations.
+ */
+
+//#include <cmath>
+// #include <stdio.h>
+
+#ifndef TESTSUBCLASS_HH
+#define TESTSUBCLASS_HH
+
+namespace animal {
+
+ class moose {
+ public:
+ moose() : fFeet(0),
+ fIsValid(false)
+ { }
+
+ virtual void setFeet(int);
+ int getFeet();
+
+ void doNothing();
+
+ enum moose_enum {
+ NAME1, NAME2, NAME3 };
+
+
+ protected:
+
+ bool fIsValid;
+ int fIsProtectedInt;
+
+ private:
+ int fFeet; // Usually 2 or 4.
+ bool fIsPrivateBool;
+
+ }; // moose
+
+ int two_prototypes();
+ int two_prototypes();
+
+ class quadruped {
+ public:
+ quadruped(int a) : fQuadPrivate(a)
+ { }
+
+ int fQuadPublic;
+
+ protected:
+ int fQuadProtected;
+
+ private:
+ int fQuadPrivate;
+
+ };
+
+}
+
+
+namespace deer {
+
+ class moose : public animal::moose {
+ public:
+ moose() : fAntlers(false)
+ { }
+
+ void setAntlers(bool);
+ bool getAntlers();
+
+ void doSomething();
+
+ protected:
+
+ bool fSomeField;
+
+ private:
+ bool fAntlers;
+
+ };
+
+} // deer
+
+// A second namespace of the same name will test the
+// namespace merging needed to resolve deer::alces
+namespace deer {
+
+ class alces : public animal::moose {
+ public:
+ alces(int lat) : fLatin(lat)
+ { }
+
+ void setLatin(bool);
+ bool getLatin();
+
+ void doLatinStuff(moose moosein); // for completion testing
+
+ moose createMoose(); // for completion testing.
+
+ protected:
+ bool fAlcesBool;
+ int fAlcesInt;
+
+ private:
+ bool fLatin;
+ int fGreek;
+ };
+
+};
+
+// A third namespace with classes that does protected and private inheritance.
+namespace sneaky {
+
+ class antelope : public animal::quadruped {
+
+ public:
+ antelope(int a) : animal::quadruped(),
+ fAntyProtected(a)
+ {}
+
+ int fAntyPublic;
+
+ bool testAccess();
+
+ protected:
+ int fAntyProtected;
+
+ private :
+ int fAntyPrivate;
+
+ };
+
+ class jackalope : protected animal::quadruped {
+
+ public:
+ jackalope(int a) : animal::quadruped(),
+ fBunny(a)
+ {}
+
+ int fBunnyPublic;
+
+ bool testAccess();
+
+ protected:
+ bool fBunnyProtected;
+
+ private :
+ bool fBunnyPrivate;
+
+ };
+
+ // Nothing specified means private.
+ class bugalope : /* private*/ animal::quadruped {
+
+ public:
+ bugalope(int a) : animal::quadruped(),
+ fBug(a)
+ {}
+
+ int fBugPublic;
+
+ bool testAccess();
+ protected:
+ bool fBugProtected;
+
+ private :
+ bool fBugPrivate;
+
+ };
+
+
+};
+
+#endif
Index: tests/testtemplates.cpp
===================================================================
RCS file: tests/testtemplates.cpp
diff -N tests/testtemplates.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testtemplates.cpp 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,90 @@
+// Templates Test file:
+// Written by 'Raf'
+
+template <class T, int U, class V>
+class read_ref {
+public:
+ const T* read_ref_member_one( T);
+ const V* read_ref_member_two();
+};
+
+namespace NS {
+ template <class T, int U, class V>
+ class ref {
+ public:
+ read_ref<T,10,V> operator->() {
+ m_// -1-
+ ;
+ // #1# ( "m_datas" )
+ }
+
+ private:
+ T m_datas[U];
+ };
+
+}
+
+class FooOne {
+public:
+ int fooOneMember();
+};
+
+class FooTwo {
+public:
+ int fooTwoMember();
+};
+
+class FooThree {
+public:
+ int fooThreeMember();
+
+ FooOne * operator->();
+};
+
+typedef ref<FooOne, 10,FooTwo> Test;
+
+using NS;
+
+void
+main(void) {
+ ref<FooOne, 10, FooTwo> v;
+
+ v->read_ref_member_one()-> // -2-
+ ;
+ // #2# ( "fooOneMember" )
+
+ v->read_ref_member_two()-> // -3-
+ ;
+ // #3# ( "fooTwoMember" )
+
+ v-> // -4-
+ ;
+ // #4# ( "read_ref_member_one" "read_ref_member_two" )
+
+ Test t;
+
+ t->read_ref_member_two()-> // -5-
+ ;
+ // #5# ( "fooTwoMember" )
+
+ ref<FooOne, 10, FooThree> v2;
+
+ v2->read_ref_member_two()-> // -6-
+ ;
+ // #6# ( "fooOneMember" )
+
+ /* Try all these things by also specifying the namespace in the name. */
+ NS::ref<FooOne, 10, FooTwo> v3;
+
+ v3->read_ref_member_one()-> // -7-
+ ;
+ // #7# ( "fooOneMember" )
+
+ v3->read_ref_member_two()-> // -8-
+ ;
+ // #8# ( "fooTwoMember" )
+
+ v3->read_ref_member_two// @1@ 5
+ ;
+
+}
Index: tests/testtypedefs.cpp
===================================================================
RCS file: tests/testtypedefs.cpp
diff -N tests/testtypedefs.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testtypedefs.cpp 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,74 @@
+// Sample with some fake bits out of std::string
+//
+// Thanks Ming-Wei Chang for these examples.
+
+namespace std {
+
+ template <T>class basic_string {
+
+ public:
+ void resize(int);
+
+ };
+
+}
+
+typedef std::basic_string<char> mstring;
+
+using namespace std;
+typedef basic_string<char> bstring;
+
+
+int main(){
+ mstring a;
+
+ a.// -1-
+ ;
+ // #1# ( "resize" )
+
+ bstring b;
+ // It doesn't work here.
+ b.// -2-
+ ;
+ // #2# ( "resize" )
+
+ return 0;
+}
+
+
+// ------------------
+
+class Bar
+{
+public:
+ void someFunc() {}
+
+};
+
+typedef Bar new_Bar;
+
+template <class mytype>
+class TBar
+{
+public:
+ void otherFunc() {}
+
+};
+
+typedef TBar<char> new_TBar;
+
+int main()
+{
+ new_Bar nb;
+ new_TBar ntb;
+
+ nb.// -3-
+ ;
+ // #3# ("someFunc")
+
+ ntb.// -4-
+ ;
+ // #4# ("otherFunc")
+
+ return 0;
+}
Index: tests/testusing.cpp
===================================================================
RCS file: tests/testusing.cpp
diff -N tests/testusing.cpp
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testusing.cpp 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,132 @@
+// Test using statements in C++
+
+#include <adstdio.h>
+
+#include <testusing.hh>
+
+namespace moose {
+
+ class MyClass;
+ class Point;
+
+ typedef MyClass snerk;
+}
+
+namespace moose {
+
+ class Point;
+ class MyClass;
+
+}
+
+namespace {
+
+ int global_variable = 0;
+
+};
+
+using moose::MyClass;
+
+void someFcn() {
+
+ MyClass f;
+
+ f.//-1-
+ ; //#1# ( "getVal" "setVal" )
+
+}
+
+// Code from Zhiqiu Kong
+
+namespace panda {
+
+ using namespace bread_name;
+
+ int func()
+ {
+ bread test;
+ test.//-2-
+ ;// #2# ( "geta" )
+ return 0;
+ }
+}
+
+// Local using statements and aliased types
+// Code from David Engster
+
+void func2()
+{
+ using namespace somestuff;
+ OneClass f;
+ f.//-3-
+ ; //#3# ( "aFunc" "anInt" )
+}
+
+void func3()
+{
+ using somestuff::OneClass;
+ OneClass f;
+ f.//-4-
+ ; //#4# ( "aFunc" "anInt" )
+}
+
+// Dereferencing alias types created through 'using' statements
+
+// Alias with fully qualified name
+void func4()
+{
+ otherstuff::OneClass f;
+ f. //-5-
+ ; //#5# ( "aFunc" "anInt" )
+}
+
+// Alias through namespace directive
+void func5()
+{
+ using namespace otherstuff;
+ OneClass f;
+ f. //-6-
+ ; //#6# ( "aFunc" "anInt" )
+}
+
+// Check name hiding
+void func6()
+{
+ using namespace morestuff;
+ OneClass f; // Alias for somestuff::OneClass
+ f. //-7-
+ ; //#7# ( "aFunc" "anInt" )
+ aStruct g; // This however is morestuff::aStruct !
+ g. //-8-
+ ; //#8# ( "anotherBar" "anotherFoo" )
+}
+
+// Alias of an alias
+// Currently doesn't work interactively for some reason.
+void func6()
+{
+ using namespace evenmorestuff;
+ OneClass f;
+ f. //-7-
+ ; //#7# ( "aFunc" "anInt" )
+}
+
+// Alias for struct in nested namespace, fully qualified
+void func7()
+{
+ outer::StructNested f;
+ f.//-8-
+ ; //#8# ( "one" "two" )
+}
+
+// Alias for nested namespace
+void func8()
+{
+ using namespace outerinner;
+ StructNested f;
+ AnotherStruct g;
+ f.//-9-
+ ; //#9# ( "one" "two" )
+ g.//-10-
+ ; //#10# ( "four" "three" )
+}
Index: tests/testusing.hh
===================================================================
RCS file: tests/testusing.hh
diff -N tests/testusing.hh
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testusing.hh 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,125 @@
+// test usings header file.
+
+namespace moose {
+
+ class Point;
+
+ class MyClass;
+
+}
+
+
+namespace moose {
+
+ class Point;
+
+ class MyClass {
+ public:
+ MyClass() : fVal(0) {
+ }
+
+ ~MyClass() {};
+
+ /**
+ * fVal Accessors
+ * @{
+ */
+ int getVal() const {
+ return fVal;
+ }
+ void setVal(int Val) const {
+ fVal = Val;
+ }
+ /**
+ * @}
+ */
+ private:
+ int fVal;
+ };
+
+}
+
+namespace deer {
+
+ class Pickle;
+
+};
+
+// Code from Zhiqiu Kong
+
+#ifndef BREAD_H
+#define BREAD_H
+
+namespace bread_name {
+ class bread
+ {
+ public:
+ void geta();
+ private:
+ int m_a;
+ int m_b;
+ };
+}
+
+#endif
+
+// Code from David Engster
+// Creating alias types through 'using' trickery
+
+namespace somestuff {
+ class OneClass {
+ public:
+ void aFunc();
+ int anInt;
+ };
+ struct aStruct {
+ int foo;
+ int bar;
+ };
+}
+
+namespace otherstuff {
+ // make otherstuff::OneClass an alias for somestuff::OneClass
+ using somestuff::OneClass;
+}
+
+namespace morestuff {
+ // make morestuff an alias namespace for somestuff
+ using namespace somestuff;
+ // but hide aStruct with own type
+ struct aStruct {
+ int anotherFoo;
+ int anotherBar;
+ };
+}
+
+// We can also create an alias for an alias
+namespace evenmorestuff {
+ using otherstuff::OneClass;
+}
+
+// Now with nested namespaces
+namespace outer {
+ namespace inner {
+ struct StructNested {
+ int one;
+ int two;
+ };
+ struct AnotherStruct {
+ int three;
+ int four;
+ };
+ }
+}
+
+// Elevate the first struct into 'outer'
+// so that we can access it via 'outer::StructNested'
+namespace outer {
+ using outer::inner::StructNested;
+}
+
+// Create an alias for a nested namespace
+namespace outerinner {
+ // equivalent to 'namespace outerinner = outer::inner;'
+ using namespace outer::inner;
+}
Index: tests/testvarnames.c
===================================================================
RCS file: tests/testvarnames.c
diff -N tests/testvarnames.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ tests/testvarnames.c 28 Sep 2009 23:23:32 -0000 1.2
@@ -0,0 +1,71 @@
+/*
+ * Test variable and function names, lists of variables on one line, etc.
+ */
+
+struct independent {
+ int indep_1;
+ int indep_2;
+};
+
+struct independent var_indep_struct;
+
+struct {
+ int unnamed_1;
+ int unnamed_2;
+} var_unamed_struct;
+
+struct {
+ int unnamed_3;
+ int unnamed_4;
+} var_un_2, var_un_3;
+
+struct inlinestruct {
+ int named_1;
+ int named_2;
+} var_named_struct;
+
+struct inline2struct {
+ int named_3;
+ int named_4;
+} var_n_2, var_n_3;
+
+/* Structures with names that then declare variables
+ * should also be completable.
+ *
+ * Getting this to work is the bugfix in semantic-c.el CVS v 1.122
+ */
+struct inlinestruct in_var1;
+struct inline2struct in_var2;
+
+int test_1(int var_arg1) {
+
+ var_// -1-
+ ; // #1# ("var_arg1" "var_indep_struct" "var_n_2" "var_n_3"
"var_named_struct" "var_un_2" "var_un_3" "var_unamed_struct")
+
+ var_indep_struct.// -2-
+ ; // #2# ( "indep_1" "indep_2" )
+
+ var_unamed_struct.// -3-
+ ; // #3# ( "unnamed_1" "unnamed_2" )
+
+ var_named_struct.// -4-
+ ; // #4# ( "named_1" "named_2" )
+
+ var_un_2.// -5-
+ ; // #5# ( "unnamed_3" "unnamed_4" )
+ var_un_3.// -6-
+ ; // #6# ( "unnamed_3" "unnamed_4" )
+
+ var_n_2.// -7-
+ ; // #7# ( "named_3" "named_4" )
+ var_n_3.// -8-
+ ; // #8# ( "named_3" "named_4" )
+
+ in_// -9-
+ ; // #9# ( "in_var1" "in_var2" )
+
+ in_var1.// -10-
+ ; // #10# ( "named_1" "named_2")
+ in_var2.// -11-
+ ; // #11# ( "named_3" "named_4")
+}
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] emacs/test/cedet cedet-utests.el ede-tests.el s...,
Chong Yidong <=