LCOV - code coverage report
Current view: top level - test/lisp - abbrev-tests.el (source / functions) Hit Total Coverage
Test: abbrev-tests.info Lines: 4 149 2.7 %
Date: 2017-08-25 07:56:09 Functions: 1 17 5.9 %

          Line data    Source code
       1             : ;;; abbrev-tests.el --- Test suite for abbrevs  -*- lexical-binding: t; -*-
       2             : 
       3             : ;; Copyright (C) 2015-2017 Free Software Foundation, Inc.
       4             : 
       5             : ;; Author: Eli Zaretskii <eliz@gnu.org>
       6             : ;; Keywords: abbrevs
       7             : 
       8             : ;; This file is part of GNU Emacs.
       9             : 
      10             : ;; GNU Emacs is free software: you can redistribute it and/or modify
      11             : ;; it under the terms of the GNU General Public License as published by
      12             : ;; the Free Software Foundation, either version 3 of the License, or
      13             : ;; (at your option) any later version.
      14             : 
      15             : ;; GNU Emacs is distributed in the hope that it will be useful,
      16             : ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
      17             : ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      18             : ;; GNU General Public License for more details.
      19             : 
      20             : ;; You should have received a copy of the GNU General Public License
      21             : ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
      22             : 
      23             : ;;; Commentary:
      24             : 
      25             : ;; `kill-all-abbrevs-test' will remove all user *and* system abbrevs
      26             : ;; if called noninteractively with the init file loaded.
      27             : 
      28             : ;;; Code:
      29             : 
      30             : (require 'ert)
      31             : (require 'abbrev)
      32             : (require 'seq)
      33             : 
      34             : ;; set up test abbrev table and abbrev entry
      35             : (defun setup-test-abbrev-table ()
      36           7 :   (defvar ert-test-abbrevs nil)
      37           7 :   (define-abbrev-table 'ert-test-abbrevs '(("a-e-t" "abbrev-ert-test")))
      38           7 :   (abbrev-table-put ert-test-abbrevs :ert-test "ert-test-value")
      39           7 :   ert-test-abbrevs)
      40             : 
      41             : (ert-deftest abbrev-table-p-test ()
      42           0 :   (should-not (abbrev-table-p 42))
      43           0 :   (should-not (abbrev-table-p "aoeu"))
      44           0 :   (should-not (abbrev-table-p '()))
      45           0 :   (should-not (abbrev-table-p []))
      46             :   ;; Missing :abbrev-table-modiff counter:
      47           0 :   (should-not (abbrev-table-p (obarray-make)))
      48           0 :   (should (abbrev-table-empty-p (make-abbrev-table))))
      49             : 
      50             : (ert-deftest abbrev-make-abbrev-table-test ()
      51             :   ;; Table without properties:
      52           0 :   (let ((table (make-abbrev-table)))
      53           0 :     (should (abbrev-table-p table))
      54           0 :     (should (= (length table) obarray-default-size)))
      55             :   ;; Table with one property 'foo with value 'bar:
      56           0 :   (let ((table (make-abbrev-table '(foo bar))))
      57           0 :     (should (abbrev-table-p table))
      58           0 :     (should (= (length table) obarray-default-size))
      59           0 :     (should (eq (abbrev-table-get table 'foo) 'bar))))
      60             : 
      61             : (ert-deftest abbrev-table-get-put-test ()
      62           0 :   (let ((table (make-abbrev-table)))
      63           0 :     (should-not (abbrev-table-get table 'foo))
      64           0 :     (should (= (abbrev-table-put table 'foo 42) 42))
      65           0 :     (should (= (abbrev-table-get table 'foo) 42))
      66           0 :     (should (eq (abbrev-table-put table 'foo 'bar) 'bar))
      67           0 :     (should (eq (abbrev-table-get table 'foo) 'bar))))
      68             : 
      69             : (ert-deftest copy-abbrev-table-test ()
      70           0 :   (defvar foo-abbrev-table nil)         ; Avoid compiler warning
      71           0 :   (define-abbrev-table 'foo-abbrev-table
      72           0 :     '())
      73           0 :   (should (abbrev-table-p foo-abbrev-table))
      74             :   ;; Bug 21828
      75           0 :   (let ((new-foo-abbrev-table
      76           0 :          (condition-case nil
      77           0 :              (copy-abbrev-table foo-abbrev-table)
      78           0 :            (error nil))))
      79           0 :     (should (abbrev-table-p new-foo-abbrev-table)))
      80           0 :   (should-not (string-equal (buffer-name) "*Backtrace*")))
      81             : 
      82             : (ert-deftest abbrev-table-empty-p-test ()
      83           0 :   (should-error (abbrev-table-empty-p 42))
      84           0 :   (should-error (abbrev-table-empty-p "aoeu"))
      85           0 :   (should-error (abbrev-table-empty-p '()))
      86           0 :   (should-error (abbrev-table-empty-p []))
      87             :   ;; Missing :abbrev-table-modiff counter:
      88           0 :   (should-error (abbrev-table-empty-p (obarray-make)))
      89           0 :   (let* ((table (obarray-make)))
      90           0 :     (abbrev-table-put table :abbrev-table-modiff 42)
      91           0 :     (should (abbrev-table-empty-p table))))
      92             : 
      93             : (ert-deftest kill-all-abbrevs-test ()
      94             :   "Test undefining all defined abbrevs"
      95           0 :   (unless noninteractive
      96           0 :     (ert-skip "Cannot test kill-all-abbrevs in interactive mode"))
      97             : 
      98           0 :   (let ((num-tables 0))
      99             :     ;; ensure at least one abbrev exists
     100           0 :     (should (abbrev-table-p (setup-test-abbrev-table)))
     101           0 :     (setf num-tables (length abbrev-table-name-list))
     102           0 :     (kill-all-abbrevs)
     103             : 
     104             :     ;; no tables should have been removed/added
     105           0 :     (should (= num-tables (length abbrev-table-name-list)))
     106             :     ;; number of empty tables should be the same as number of tables
     107           0 :     (should (= num-tables (length (seq-filter
     108             :                                    (lambda (table)
     109           0 :                                        (abbrev-table-empty-p (symbol-value table)))
     110           0 :                                    abbrev-table-name-list))))))
     111             : 
     112             : (ert-deftest abbrev-table-name-test ()
     113             :   "Test returning name of abbrev-table"
     114           0 :   (let ((ert-test-abbrevs (setup-test-abbrev-table))
     115             :         (no-such-table nil))
     116           0 :     (should (equal 'ert-test-abbrevs (abbrev-table-name ert-test-abbrevs)))
     117           0 :     (should (equal nil (abbrev-table-name no-such-table)))))
     118             : 
     119             : (ert-deftest clear-abbrev-table-test ()
     120             :   "Test clearing single abbrev table"
     121           0 :   (let ((ert-test-abbrevs (setup-test-abbrev-table)))
     122           0 :     (should (equal "abbrev-ert-test" (abbrev-expansion "a-e-t" ert-test-abbrevs)))
     123           0 :     (clear-abbrev-table ert-test-abbrevs)
     124           0 :     (should (equal nil (abbrev-expansion "a-e-t" ert-test-abbrevs)))
     125           0 :     (should (equal t (abbrev-table-empty-p ert-test-abbrevs)))))
     126             : 
     127             : (ert-deftest list-abbrevs-test ()
     128             :   "Test generation of abbrev list buffer"
     129             :   ;; Somewhat redundant as prepare-abbrev-list-buffer is also tested.
     130             :   ;; all abbrevs
     131           0 :   (let ((abbrev-buffer (prepare-abbrev-list-buffer)))
     132           0 :     (should (equal "*Abbrevs*" (buffer-name abbrev-buffer)))
     133           0 :     (kill-buffer abbrev-buffer))
     134             :   ;; mode-specific abbrevs
     135           0 :   (let ((abbrev-buffer (prepare-abbrev-list-buffer t)))
     136           0 :     (should (equal "*Abbrevs*" (buffer-name abbrev-buffer)))
     137           0 :     (kill-buffer abbrev-buffer)))
     138             : 
     139             : (ert-deftest prepare-abbrev-list-buffer-test ()
     140             :   "Test generation of abbrev list buffer"
     141             :   ;; all abbrevs
     142           0 :   (let ((ert-test-abbrevs (setup-test-abbrev-table)))
     143           0 :     (with-current-buffer (prepare-abbrev-list-buffer)
     144             :       ;; Check for a couple of abbrev-table names in buffer.
     145           0 :       (should (and (progn
     146           0 :                      (goto-char (point-min))
     147           0 :                      (search-forward (symbol-name (abbrev-table-name ert-test-abbrevs))))
     148           0 :                    (progn
     149           0 :                      (goto-char (point-min))
     150           0 :                      (search-forward "global-abbrev-table"))))
     151           0 :       (should (equal 'edit-abbrevs-mode major-mode))
     152           0 :       (kill-buffer "*Abbrevs*")))
     153             : 
     154             :   ;; mode-specific abbrevs (temp buffer uses fundamental-mode)
     155           0 :   (with-temp-buffer
     156           0 :     (prepare-abbrev-list-buffer t)
     157           0 :     (with-current-buffer "*Abbrevs*"
     158           0 :       (should (progn
     159           0 :                 (goto-char (point-min))
     160           0 :                 (search-forward "fundamental-mode-abbrev-table")))
     161           0 :       (should-error (progn
     162           0 :                       (goto-char (point-min))
     163           0 :                       (search-forward "global-abbrev-table")))
     164           0 :       (should-not (equal 'edit-abbrevs-mode major-mode))
     165           0 :       (kill-buffer "*Abbrevs*"))))
     166             : 
     167             : (ert-deftest insert-abbrevs-test ()
     168             :   "Test inserting abbrev definitions into buffer"
     169           0 :   (with-temp-buffer
     170           0 :     (insert-abbrevs)
     171           0 :       (should (progn
     172           0 :                 (goto-char (point-min))
     173           0 :                 (search-forward "global-abbrev-table")))))
     174             : 
     175             : (ert-deftest edit-abbrevs-test ()
     176             :   "Test editing abbrevs from buffer"
     177           0 :   (defvar ert-edit-abbrevs-test-table nil)
     178           0 :   (let ((ert-test-abbrevs (setup-test-abbrev-table)))
     179           0 :     (with-temp-buffer
     180             :       ;; insert test table and new abbrev, redefine, check definition
     181           0 :       (goto-char (point-min))
     182           0 :       (insert "(ert-edit-abbrevs-test-table)\n")
     183           0 :       (insert "\n" "\"e-a-t\"\t" "0\t" "\"edit-abbrevs-test\"\n")
     184             :       ;; check test table before redefine
     185           0 :       (should (equal "abbrev-ert-test"
     186           0 :                      (abbrev-expansion "a-e-t" ert-test-abbrevs)))
     187           0 :       (edit-abbrevs-redefine)
     188           0 :       (should-not (abbrev-expansion "a-e-t" ert-test-abbrevs))
     189           0 :       (should (equal "edit-abbrevs-test"
     190           0 :                      (abbrev-expansion "e-a-t" ert-edit-abbrevs-test-table))))))
     191             : 
     192             : (ert-deftest define-abbrevs-test ()
     193             :   "Test defining abbrevs from buffer"
     194           0 :   (defvar ert-bad-abbrev-table nil)
     195           0 :   (defvar ert-good-abbrev-table nil)
     196           0 :   (defvar ert-redefine-abbrev-table nil)
     197           0 :   (with-temp-buffer
     198             :     ;; insert bad abbrev data and attempt define
     199           0 :     (goto-char (point-min))
     200           0 :     (insert "ert-bad-abbrev-table\n")
     201           0 :     (insert "\n" "\"b-a-t\"\t" "0\t" "\n")
     202           0 :     (should-not (define-abbrevs))
     203           0 :     (should (equal nil (abbrev-expansion "b-a-t" ert-bad-abbrev-table)))
     204           0 :     (delete-region (point-min) (point-max))
     205             :     ;; try with valid abbrev data
     206           0 :     (goto-char (point-min))
     207           0 :     (insert "(ert-good-abbrev-table)\n")
     208           0 :     (insert "\n" "\"g-a-t\"\t" "0\t" "\"good-abbrev-table\"\n")
     209           0 :     (define-abbrevs)
     210           0 :     (should (equal "good-abbrev-table"
     211           0 :                    (abbrev-expansion "g-a-t" ert-good-abbrev-table)))
     212             :     ;; redefine from buffer
     213           0 :     (delete-region (point-min) (point-max))
     214           0 :     (insert "(ert-redefine-abbrev-table)\n")
     215           0 :     (insert "\n" "\"r-a-t\"\t" "0\t" "\"redefine-abbrev-table\"\n")
     216             :     ;; arg = kill-all-abbrevs
     217           0 :     (define-abbrevs t)
     218           0 :     (should (equal "redefine-abbrev-table"
     219           0 :                    (abbrev-expansion "r-a-t" ert-redefine-abbrev-table)))
     220           0 :     (should (equal nil (abbrev-expansion "g-a-t" ert-good-abbrev-table)))))
     221             : 
     222             : (ert-deftest read-write-abbrev-file-test ()
     223             :   "Test reading and writing abbrevs from file"
     224           0 :   (let ((temp-test-file (make-temp-file "ert-abbrev-test"))
     225           0 :         (ert-test-abbrevs (setup-test-abbrev-table)))
     226           0 :     (write-abbrev-file temp-test-file)
     227           0 :     (clear-abbrev-table ert-test-abbrevs)
     228           0 :     (should (abbrev-table-empty-p ert-test-abbrevs))
     229           0 :     (read-abbrev-file temp-test-file)
     230           0 :     (should (equal "abbrev-ert-test" (abbrev-expansion "a-e-t" ert-test-abbrevs)))
     231           0 :     (delete-file temp-test-file)))
     232             : 
     233             : (ert-deftest abbrev-edit-save-to-file-test ()
     234             :   "Test saving abbrev definitions in buffer to file"
     235           0 :   (defvar ert-save-test-table nil)
     236           0 :   (let ((temp-test-file (make-temp-file "ert-abbrev-test"))
     237           0 :         (ert-test-abbrevs (setup-test-abbrev-table)))
     238           0 :     (with-temp-buffer
     239           0 :       (goto-char (point-min))
     240           0 :       (insert "(ert-save-test-table)\n")
     241           0 :       (insert "\n" "\"s-a-t\"\t" "0\t" "\"save-abbrevs-test\"\n")
     242           0 :       (should (equal "abbrev-ert-test"
     243           0 :                      (abbrev-expansion "a-e-t" ert-test-abbrevs)))
     244             :       ;; clears abbrev tables
     245           0 :       (abbrev-edit-save-to-file temp-test-file)
     246           0 :       (should-not (abbrev-expansion "a-e-t" ert-test-abbrevs))
     247           0 :       (read-abbrev-file temp-test-file)
     248           0 :       (should (equal "save-abbrevs-test"
     249           0 :                      (abbrev-expansion "s-a-t" ert-save-test-table)))
     250           0 :       (delete-file temp-test-file))))
     251             : 
     252             : (provide 'abbrev-tests)
     253             : 
     254             : ;;; abbrev-tests.el ends here

Generated by: LCOV version 1.12