From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!not-for-mail From: Stefan Merten Newsgroups: gmane.emacs.devel Subject: Re: Running ert tests on buffers in rst.el and elsewhere Date: Mon, 25 Jun 2012 11:20:38 +0200 Message-ID: <7757.1340616038@theowa.merten-home.homelinux.org> References: <6280.1340054412@theowa.merten-home.homelinux.org> NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: multipart/signed; boundary="==-=-="; micalg=pgp-sha1; protocol="application/pgp-signature" X-Trace: dough.gmane.org 1340646969 16687 80.91.229.3 (25 Jun 2012 17:56:09 GMT) X-Complaints-To: usenet@dough.gmane.org NNTP-Posting-Date: Mon, 25 Jun 2012 17:56:09 +0000 (UTC) Cc: Christian Ohler To: emacs-devel@gnu.org Original-X-From: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Mon Jun 25 19:56:07 2012 Return-path: Envelope-to: ged-emacs-devel@m.gmane.org Original-Received: from lists.gnu.org ([208.118.235.17]) by plane.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1SjDWA-0000bA-Fz for ged-emacs-devel@m.gmane.org; Mon, 25 Jun 2012 19:56:06 +0200 Original-Received: from localhost ([::1]:44530 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SjDWA-0002Yg-Ga for ged-emacs-devel@m.gmane.org; Mon, 25 Jun 2012 13:56:06 -0400 Original-Received: from eggs.gnu.org ([208.118.235.92]:49150) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SjDW5-0002Lt-0E for emacs-devel@gnu.org; Mon, 25 Jun 2012 13:56:04 -0400 Original-Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1SjDW1-0001xJ-It for emacs-devel@gnu.org; Mon, 25 Jun 2012 13:56:00 -0400 Original-Received: from moutng.kundenserver.de ([212.227.126.187]:55705) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SjDVw-0001wT-O2; Mon, 25 Jun 2012 13:55:53 -0400 Original-Received: from theowa.merten-home.homelinux.org (ip-109-46-39-75.web.vodafone.de [109.46.39.75]) by mrelayeu.kundenserver.de (node=mreu0) with ESMTP (Nemesis) id 0MJ0Dl-1ShIlw2lp3-002VGa; Mon, 25 Jun 2012 19:55:50 +0200 Original-Received: by theowa.merten-home.homelinux.org (Postfix, from userid 1000) id 7A318401D9; Mon, 25 Jun 2012 11:20:38 +0200 (CEST) Original-Received: from theowa.merten-home.homelinux.org (localhost [127.0.0.1]) by theowa.merten-home.homelinux.org (Postfix) with ESMTP id 49D687A007; Mon, 25 Jun 2012 11:20:38 +0200 (CEST) In-reply-to: Comments: In-reply-to Stefan Monnier message dated "Tue, 19 Jun 2012 14:06:53 -0400." X-Mailer: MH-E 8.2; nmh 1.3; GNU Emacs 23.1.1 X-Provags-ID: V02:K0:wXip2Oiu0J/dofz8sZWSLznJCrR3l2sPcXu1zWaOzxO GwKNVhUf60KBsdKsJM13U/eZL2yAC0fl5/PfNYd7z7l5SYnXx5 0nbX2HC/VetCGB0A9XByZeL8sYhfRKaRWrsqwzkfv/uS/tqxsY CEBTIKweHBIqjVkLrC7AuoS/3Axog5W6yCjXyLy+nB+6dk0F8P eMZRrWbqzuRhEeMqKfcyhQMKns6df7GN1PlcYk1aFvijkyC/j6 FWrSFn92gMUJNdZ98nP6cdB05CFjJNGvLdcO/OrGuax4T4phN6 GbM9bDA/0t21MaBc6z44qn3Spd+khl59sabKmXb+EDMvjJjOU4 V+qhJBsTCcuz/Nzgd4MQO3u7g635waHL0jev8J8tIFqH6guiL+ KuP6CcTvo00PhhLgm1kj+lbfDuiWGQX580= X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 212.227.126.187 X-BeenThere: emacs-devel@gnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: "Emacs development discussions." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Original-Sender: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Xref: news.gmane.org gmane.emacs.devel:151162 Archived-At: --==-=-= Content-Type: multipart/mixed; boundary="=-=-=" --=-=-= Content-Type: text/plain; charset=iso-8859-1 Content-Transfer-Encoding: quoted-printable Hi StefanMo, Christian, all! 6 days ago Stefan Monnier wrote: >> I wanted to test functions which operate on buffers - i.e. use buffer >> content as input and possibly modify the buffer. Buffer includes point >> and mark in this case. Since I found no support for this requirement >> in the ert package I wrote some support code for it. I just polished >> it a bit to better fit into Emacs standards. >=20 > Sounds OK. The code looks mostly OK, except: > - It should either use (require 'cl-lib) or (eval-when-compile (require '= cl)). Done. > - You can use the "--" convention for internal functions/variables > (e.g. use ert--equal-buffer instead of ert-equal-buffer-internal). Done. > - ert-Buf-create-string could probably use car-less-than-car if a speed > boost is needed (probably not worth the trouble, tho). Indeed not worth the trouble. > - the docstrings talk about "run list FOO" which is meaningless to me > (a list can't be run). So describe FUNCALL a bit better (e.g. making > it clear that it's expected to have the shape (FUN . ARGS)). I improved the whole documentation including a commentary section describing how to use it. I also revamped and refactored a few other things and added more tests. Most important changes are that `ert-equal-buffer' / `ert-equal-buffer-return' are now macros so the form given as argument needs not be quoted. Also these macros accept more parameters including an option to say "the expected buffer should be the same as the input buffer". I include the code below. Gr=FC=DFe Stefan --=-=-= Content-Type: text/x-lisp Content-Disposition: attachment; filename=ert-buffer.el Content-Transfer-Encoding: quoted-printable Content-Description: Implementation ;;; ert-buffer.el --- Support functions for running ert tests on buffers ;; Copyright (C) 2010-2012 Free Software Foundation, Inc. ;; Author: Stefan Merten , ;; 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 . ;;; Commentary: ;;=20 ;; Some functions need a buffer to run on. They may use the buffer content= as ;; well as point and mark as input and may modify all of them. In addition ;; they may return some result. Here are some support functions to test su= ch ;; functions using `ert'. ;; ;; Use `ert-equal-buffer' and/or `ert-equal-buffer-return' for your `should' ;; forms. ;; ;; You may use the constants `ert-Buf-point-char' and `ert-Buf-mark-char' in ;; constructing comparison strings to represent point or mark, respectively. ;; ;; Examples: ;; ;; (should (ert-equal-buffer (insert "foo") ;; ; Insertion of "foo"... ;; (concat ert-Buf-point-char ert-Buf-mark-char) ;; ; ...into an empty buffer with point and mar= k... ;; (concat ert-Buf-mark-char "foo" ;; ert-Buf-point-char))) ;; ; ...should result in a buffer containing "f= oo" ;; ; with point and mark moved appropriately. ;; ;; (should (ert-equal-buffer (delete-region) ;; ; Deleting region... ;; `(,ert-Buf-mark-char "foo" ,ert-Buf-point-ch= ar) ;; ; ...in a region spanning the whole buffer... ;; (concat ert-Buf-point-char ert-Buf-mark-char) ;; ; ...should result in an empty buffer... ;; t)) ;; ; ...when called interactively. ;; ;; (should (ert-equal-buffer-return (point) ;; ; Returning the point... ;; ert-Buf-point-char ;; ; ...in an empty buffer... ;; t ;; ; ...without changing the result buff= er... ;; 1)) ;; ; ...should return 1. ;;; Code: (eval-when-compile (require 'cl)) (require 'ert) ;; ************************************************************************= **** ;; `ert-Buf' and related functions (defconst ert-Buf-point-char "\^@" "Special character used to mark the position of point in a `ert-Buf'.") (defconst ert-Buf-mark-char "\^?" "Special character used to mark the position of mark in a `ert-Buf'.") (defstruct (ert-Buf (:constructor nil) ; No default constructor. (:constructor ert-Buf-from-string (string &aux (analysis (ert-Buf--parse-string string)) (content (car analysis)) (point (cadr analysis)) (mark (caddr analysis)))) (:constructor ert-Buf-from-buffer (&aux (content (buffer-substring-no-properties (point-min) (point-max))) (point (point)) (mark (mark t)) (string (ert-Buf--create-string content point mark))))) "Structure to hold comparable information about a buffer. `ert-Buf-from-string' constructs a structure from a given STRING. `ert-Buf-from-buffer' constructs a structure from the current buffer." (content nil :read-only t) ; Pure string content without any special mark= up. (point nil :read-only t) ; Position of point. (mark nil :read-only t) ; Position of mark. (string nil :read-only t) ; String representation. ) (defun ert-Buf--parse-string (string) "Parse STRING and return clean results. Return a list consisting of the cleaned content, the position of point if `ert-Buf-point-char' was found and the the position of mark if `ert-Buf-mark-char' was found." (with-temp-buffer (let ((case-fold-search nil) fnd point-fnd mark-fnd) (insert string) (goto-char (point-min)) (while (re-search-forward (concat "[" ert-Buf-point-char ert-Buf-mark-char "]") nil t) (setq fnd (match-string 0)) (replace-match "") (cond ((equal fnd ert-Buf-point-char) (if point-fnd (error "Duplicate point")) (setq point-fnd (point))) ((equal fnd ert-Buf-mark-char) (if mark-fnd (error "Duplicate mark")) (setq mark-fnd (point))) (t (error "Unexpected marker found")))) (list (buffer-substring-no-properties (point-min) (point-max)) point-fnd mark-fnd)))) (defun ert-Buf--create-string (content point mark) "Create a string representation from CONTENT, POINT and MARK." (with-temp-buffer (insert content) (let (pnt-chs) (if point (setq pnt-chs (nconc pnt-chs (list (cons point ert-Buf-point-char))))) (if mark (setq pnt-chs (nconc pnt-chs (list (cons mark ert-Buf-mark-char))))) ;; Sort pairs so the highest position is last. (setq pnt-chs (sort pnt-chs (lambda (el1 el2) (> (car el1) (car el2))= ))) (while pnt-chs (goto-char (caar pnt-chs)) (insert (cdar pnt-chs)) (setq pnt-chs (cdr pnt-chs))) (buffer-substring-no-properties (point-min) (point-max))))) (defun ert-Buf--to-buffer (buf) "Set current buffer according to BUF." (insert (ert-Buf-content buf)) (if (ert-Buf-point buf) (goto-char (ert-Buf-point buf))) (if (ert-Buf-mark buf) (set-mark (ert-Buf-mark buf)))) (defun ert-Buf--from-argument (arg other) "Interpret ARG as input for an `ert-Buf', convert it and return the `ert-= Buf'. ARG may be one of the types described in `ert-equal-buffer-return' or nil which is also returned." (cond ((not arg) nil) ((eq arg t) (when (or (not other) (eq other t)) (error "First argument to `ert-Buf--from-argument' t requires a non-n= il, non-t second argument")) (ert-Buf--from-argument other nil)) ((characterp arg) (ert-Buf-from-string (char-to-string arg))) ((stringp arg) (ert-Buf-from-string arg)) ((ert-Buf-p arg) arg) ((listp arg) (ert-Buf-from-string (apply 'concat arg))) (t (error "Unknown type for `ert-Buf--from-argument'")))) ;; ************************************************************************= **** ;; Runners (defvar ert--inputs nil "Variable to hold the strings to give successively to `ert-completing-rea= d'.") (defadvice completing-read (around ert-completing-read first (prompt collection &optional predicate require-match initial-input hist def inherit-input-method)) "Advice `completing-read' to accept input from `ert--inputs'." (if (not ert--inputs) (error "No more input strings in `ert--inputs'")) (let* ((input (pop ert--inputs))) (setq ad-return-value (cond ((eq (try-completion input collection predicate) t) ;; Perfect match. input) ((not require-match) ;; Non-matching input allowed. input) ((and (equal input "") (eq require-match t)) ;; Empty input and this is allowed. input) (t (error "Input '%s' is not allowed for `completing-read' expecting %s" input collection)))))) (defadvice read-string (around ert-read-string first (prompt &optional initial-input history default-value inherit-input-method)) "Advice `read-string' to accept input from `ert--inputs'." (if (not ert--inputs) (error "No more input strings in `ert--inputs'")) (let* ((input (pop ert--inputs))) (setq ad-return-value (if (and (equal input "") default-value) default-value input)))) (defadvice read-number (around ert-read-number first (prompt &optional default)) "Advice `read-number' to accept input from `ert--inputs'." (if (not ert--inputs) (error "No more input strings in `ert--inputs'")) (let* ((input (pop ert--inputs))) (setq ad-return-value (if (and (equal input "") default) default input)))) (defun ert--run-test-with-buffer (buf form interactive) "With a buffer filled with `ert-Buf' BUF evaluate function form FORM. Return a cons consisting of the return value and a `ert-Buf'. If INTERACTIVE is non-nil FORM is evaluated in an interactive environment." (with-temp-buffer (ert-Buf--to-buffer buf) (let ((act-return (cond ((not interactive) (apply (car form) (cdr form))) ((eq interactive t) (let ((current-prefix-arg (cadr form))) (call-interactively (car form)))) ((listp interactive) (setq ert--inputs interactive) (ad-activate 'read-string) (ad-activate 'read-number) (ad-activate 'completing-read) (unwind-protect (let ((current-prefix-arg (cadr form))) (call-interactively (car form))) (progn (ad-deactivate 'completing-read) (ad-deactivate 'read-number) (ad-deactivate 'read-string))) (if ert--inputs (error "%d input strings left over" (length ert--inputs)))))) (act-buf (ert-Buf-from-buffer))) (cons act-return act-buf)))) (defun ert--compare-test-with-buffer (result buf ignore-return exp-return) "Compare RESULT of test with expected buffer BUF. RESULT is a return value from `ert--run-test-with-buffer'. Return a list of booleans where t stands for a successful test of this kind: * Content of output buffer * Point in output buffer * Return value IGNORE-RETURN, EXP-RETURN are described in `ert--equal-buffer'." (let ((act-return (car result)) (act-buf (cdr result))) (list (or (not buf) (equal (ert-Buf-content act-buf) (ert-Buf-content buf))) (or (not buf) (not (ert-Buf-point buf)) (equal (ert-Buf-point act-buf) (ert-Buf-point buf))) (or ignore-return (equal act-return exp-return))))) (defun ert--equal-buffer (form input exp-output ignore-return exp-return in= teractive) "Run tests for `ert-equal-buffer-return' and `ert-equal-buffer'. FORM, INPUT and EXP-OUTPUT are as described for `ert-equal-buffer-return'. Ignore return value if IGNORE-RETURN or compare the return value to EXP-RETURN. INTERACTIVE is as described for `ert-equal-buffer-return'. Return t if equal." (catch 'return (dolist (elem (ert--compare-test-with-buffer (ert--run-test-with-buffer (ert-Buf--from-argument input exp-output) form interactive) (ert-Buf--from-argument exp-output input) ignore-return exp-return) t) (unless elem (throw 'return nil))))) (defmacro ert-equal-buffer-return (form input exp-output exp-return &option= al interactive) "Evaluate function form FORM with a buffer and compare results. Since `ert-equal-buffer-return' is a macro FORM is not evaluated immediately. Thus you must give FORM as a normal function form with no additional quoting. The buffer is filled with INPUT. Compare the buffer content to EXP-OUTPUT if this is non-nil. Compare the return value to EXP-RETURN. Return t if buffer and return value are equal to the expected values. INPUT and EXP-OUTPUT represent the input buffer or the expected output buffer, respectively. They can be one of the following: * nil in which case the respective buffer is not used. Makes sense only for EXP-OUTPUT. * t in which case the other buffer is used unchanged. The other buffer must not be nil or t in this case. * A character which is converted to a one character string. * A string. * A list of strings which are concatenated using `concat'. This can be used to shorten the form describing the buffer when used with quote or backquote. * An `ert-Buf' object. All input variants which end up in a string are parsed by `ert-Buf-from-string'. If INTERACTIVE is nil FORM is evaluated with no special context. If INTERACTIVE is non-nil FORM is evaluated interactively and `current-prefix-arg' is set to the cadr of FORM (i.e\. the first argument in FORM) and thus must comply to the format of `current-prefix-arg'. If INTERACTIVE is t `call-interactively' is used normally. If INTERACTIVE is a list of strings the elements of the list are given to (advised forms of) functions reading from the minibuffer as user input strings. This allows simulating interactive user input. Return t if buffer and return value equal the expected values." `(let ((formq ',form)) (ert--equal-buffer formq ,input ,exp-output nil ,exp-return ,interacti= ve))) (defmacro ert-equal-buffer (form input exp-output &optional interactive) "Like `ert-equal-buffer-return' but the return value of FORM is ignored. INPUT, EXP-OUTPUT and INTERACTIVE are described in `ert-equal-buffer-return'." `(let ((formq ',form)) (ert--equal-buffer formq ,input ,exp-output t nil ,interactive))) ;; ************************************************************************= **** ;; Explainers (defun ert--equal-buffer-explain (form input exp-output ignore-return exp-r= eturn interactive) "Explain why `ert--equal-buffer' failed with these parameters. Return the explanation. FORM, INPUT, EXP-OUTPUT, IGNORE-RETURN, EXP-RETURN, INTERACTIVE are described in `ert--equal-buffer'." (let ((test-result (ert--run-test-with-buffer (ert-Buf--from-argument input exp-output) form interactive)) (exp-buf (ert-Buf--from-argument exp-output input))) (destructuring-bind (ok-string ok-point ok-return) (ert--compare-test-with-buffer test-result (ert-Buf--from-argument exp-output input) ignore-return exp-return) (let (result) (if (not ok-return) (push (list 'different-return-values (ert--explain-not-equal (car test-result) exp-return)) result)) (if (not ok-point) (push (list 'different-points (ert-Buf-string (cdr test-result)) (ert-Buf-string exp-buf)) result)) (if (not ok-string) (push (list 'different-buffer-contents (ert--explain-not-equal (ert-Buf-content (cdr test-result)) (ert-Buf-content exp-buf))) result)) result)))) (defun ert-equal-buffer-return-explain (form input exp-output exp-return &o= ptional interactive) "Explain why `ert-equal-buffer-return' failed with these parameters. Return the explanation. FORM, INPUT, EXP-OUTPUT, EXP-RETURN, INTERACTIVE are described in `ert--equal-buffer'." (ert--equal-buffer-explain form input exp-output nil exp-return interactive)) (put 'ert-equal-buffer-return 'ert-explainer 'ert-equal-buffer-return-expla= in) (defun ert-equal-buffer-explain (form input exp-output &optional interactiv= e) "Explain why `ert-equal-buffer' failed with these parameters. Return the explanation. FORM, INPUT, EXP-OUTPUT, EXP-RETURN, INTERACTIVE are described in `ert--equal-buffer'." (ert--equal-buffer-explain form input exp-output t nil interactive)) (put 'ert-equal-buffer 'ert-explainer 'ert-equal-buffer-explain) ; LocalWords: foo minibuffer ;; Local Variables: ;; sentence-end-double-space: t ;; End: (provide 'ert-buffer) ;;; ert-buffer.el ends here --=-=-= Content-Type: text/x-lisp Content-Disposition: attachment; filename=buffer.el Content-Description: Tests ;;; buffer.el --- Test the test support for buffers (add-to-list 'load-path ".") (load "ert-buffer" nil t) ;; **************************************************************************** ;; `ert-Buf' (defun roundtrip-ert-Buf (in) (with-temp-buffer (ert-Buf--to-buffer (ert-Buf-from-string in)) (ert-Buf-string (ert-Buf-from-buffer)))) (ert-deftest ert-Buf () "Tests for functions working with `ert-Buf's." (should (equal (concat ert-Buf-point-char "abc\n") (roundtrip-ert-Buf (concat ert-Buf-point-char "abc\n")))) (should (equal (concat "a" ert-Buf-point-char "bc\n") (roundtrip-ert-Buf (concat "a" ert-Buf-point-char "bc\n")))) (should (equal (concat "ab" ert-Buf-point-char "c\n") (roundtrip-ert-Buf (concat "ab" ert-Buf-point-char "c\n")))) (should (equal (concat "abc" ert-Buf-point-char "\n") (roundtrip-ert-Buf (concat "abc" ert-Buf-point-char "\n")))) (should (equal (concat "abc\n" ert-Buf-point-char) (roundtrip-ert-Buf (concat "abc\n" ert-Buf-point-char)))) (should (equal (concat ert-Buf-point-char "abc\n" ert-Buf-mark-char "") (roundtrip-ert-Buf (concat ert-Buf-point-char "abc\n" ert-Buf-mark-char "")))) (should (equal (concat ert-Buf-mark-char "abc\n" ert-Buf-point-char) (roundtrip-ert-Buf (concat ert-Buf-mark-char "abc\n" ert-Buf-point-char)))) (should (equal (concat "a" ert-Buf-mark-char ert-Buf-point-char "bc\n") (roundtrip-ert-Buf (concat "a" ert-Buf-point-char "" ert-Buf-mark-char "bc\n")))) (should (equal (concat "ab" ert-Buf-mark-char "" ert-Buf-point-char "c\n") (roundtrip-ert-Buf (concat "ab" ert-Buf-mark-char ert-Buf-point-char "c\n")))) (should-error (ert-Buf-from-string (concat "ab" ert-Buf-point-char ert-Buf-point-char "c\n"))) (should-error (ert-Buf-from-string (concat "ab" ert-Buf-mark-char ert-Buf-mark-char "c\n"))) ) (ert-deftest ert-Buf--from-argument () "Test `ert-Buf--from-argument'." (let ((marked-a (ert-Buf-from-string (concat ert-Buf-point-char "a" ert-Buf-mark-char)))) (should (not (ert-Buf--from-argument nil nil))) (should (equal (ert-Buf--from-argument ?a nil) (ert-Buf-from-string "a"))) (should (equal (ert-Buf--from-argument ert-Buf-point-char nil) (ert-Buf-from-string ert-Buf-point-char))) (should (equal (ert-Buf--from-argument '("a" "b") nil) (ert-Buf-from-string "ab"))) (should (equal (ert-Buf--from-argument `("a" ,ert-Buf-point-char "b") nil) (ert-Buf-from-string (concat "a" ert-Buf-point-char "b")))) (should (equal (ert-Buf--from-argument marked-a nil) marked-a)) (should-error (ert-Buf--from-argument -1 nil)) (should-error (ert-Buf--from-argument [0] nil)) (should-error (ert-Buf--from-argument t nil)) (should-error (ert-Buf--from-argument t t)) (should (eq (ert-Buf--from-argument t marked-a) marked-a)) )) ;; **************************************************************************** ;; Advice `ert-completing-read' (defvar read-fun-args nil "Input for for functions reading the minibuffer. Consists of a list of functions and their argument lists to be run successively. Prompt is omitted.") (defun insert-reads () (interactive) (while read-fun-args (let* ((fun-arg (pop read-fun-args)) (result (apply (car fun-arg) "" (cdr fun-arg)))) (insert (if (integerp result) (int-to-string result) result) "\n")))) (defun test-reads (inputs fun-args result) (setq read-fun-args fun-args) (ert-equal-buffer (insert-reads) "" result inputs)) (ert-deftest reads () "Tests for functions using `completing-read's." (should (test-reads '(5) '((read-number)) "5\n")) (should (test-reads nil nil "")) (should-error (test-reads '("") nil "")) ;; Too much input. (should-error (test-reads '(5) '((read-number) (read-number)) "")) ;; Too less input. (should (test-reads '("") '((completing-read nil)) "\n")) (should (test-reads '("" "") '((completing-read nil) (completing-read nil)) "\n\n")) (should (test-reads '("a" "b") '((completing-read nil) (completing-read nil)) "a\nb\n")) (should (test-reads '("a" "b") '((completing-read ("a" "b")) (completing-read ("a" "b"))) "a\nb\n")) (should (test-reads '("a" "b") '((completing-read ("a" "b")) (completing-read ("a"))) "a\nb\n")) (should-error (test-reads '("a" "b") '((completing-read ("a" "b")) (completing-read ("a") nil t)) "a\nb\n")) ;; Invalid input. (should (test-reads '("a" "") '((completing-read ("a" "b")) (completing-read ("a") nil t)) "a\n\n")) (should-error (test-reads '("a" "") '((completing-read ("a" "b")) (completing-read ("a") nil 'non-empty)) "a\n\n")) (should (test-reads '("x") '((read-string)) "x\n")) (should (test-reads '("") '((read-string nil nil "x")) "x\n")) (should (test-reads '("y") '((read-string nil nil "x")) "y\n")) (should (test-reads '("") '((read-number 5)) "5\n")) (should (test-reads '(0) '((read-number 5)) "0\n")) ) ;; **************************************************************************** ;; Test main functions (ert-deftest ert-equal-buffer () "Tests for `ert-equal-buffer'." (should (ert-equal-buffer (insert "foo") (concat ert-Buf-point-char ert-Buf-mark-char) (concat ert-Buf-mark-char "foo" ert-Buf-point-char))) (should (ert-equal-buffer (delete-region) (concat ert-Buf-mark-char "foo" ert-Buf-point-char) (concat ert-Buf-point-char ert-Buf-mark-char) t)) (should (ert-equal-buffer (delete-region 1 4) "foo" "")) (should-error (ert-equal-buffer (delete-region 0 3) (concat "foo") "") :type 'args-out-of-range) (should (ert-equal-buffer (goto-char 4) "foo" (concat "foo" ert-Buf-point-char))) ) (ert-deftest ert-equal-buffer-return () "Tests for `ert-equal-buffer-return'." (should (ert-equal-buffer-return (buffer-substring-no-properties 4 1) "foo" t "foo")) (should (ert-equal-buffer-return (delete-and-extract-region 1 4) "foo" "" "foo")) (should (ert-equal-buffer-return (point) ert-Buf-point-char t 1)) (should (ert-equal-buffer-return (point) (concat " " ert-Buf-point-char) t 2)) (should (ert-equal-buffer-return (region-beginning) (concat ert-Buf-point-char " " ert-Buf-mark-char) t 1)) (should (ert-equal-buffer-return (region-end) (concat ert-Buf-mark-char " " ert-Buf-point-char) t 2)) (should (ert-equal-buffer-return (following-char) (concat ert-Buf-point-char "A") t ?A)) (should (ert-equal-buffer-return (following-char) (concat "A" ert-Buf-point-char) t 0)) ) --=-=-=-- --==-=-= Content-Type: application/pgp-signature -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.10 (GNU/Linux) iQCVAwUBT+gtYwnTZgC3zSk5AQIQHgQAlpThWvP6PsQDq9715kqElSTZYIevmS+P 9RD5nWMbk7vYj8ynwYKsPup4lsH3YAee2voanV3KR1arwK7HrCowwPbp7qpGbsW7 YFBf3E3ZO1sP7pSMGheZEhiBSHnl04nB6F3WHl8obPdQwaMtk4RhTWSbM0rJJ72+ Cs4cQwfO59Y= =RhcY -----END PGP SIGNATURE----- --==-=-=--