;;; files.el --- tests for file handling.

;; Copyright (C) 2012-2015 Free Software Foundation, Inc.

;; 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/>.

;;; Code:

(require 'ert)

;; Set to t if the local variable was set, `query' if the query was
;; triggered.
(defvar files-test-result nil)

(defvar files-test-safe-result nil)
(put 'files-test-safe-result 'safe-local-variable 'booleanp)

(defun files-test-fun1 ()
  (setq files-test-result t))

;; Test combinations:
;; `enable-local-variables' t, nil, :safe, :all, or something else.
;; `enable-local-eval' t, nil, or something else.

(defvar files-test-local-variable-data
  ;; Unsafe eval form
  '((("eval: (files-test-fun1)")
     (t t         (eq files-test-result t))
     (t nil       (eq files-test-result nil))
     (t maybe     (eq files-test-result 'query))
     (nil t       (eq files-test-result nil))
     (nil nil     (eq files-test-result nil))
     (nil maybe   (eq files-test-result nil))
     (:safe t     (eq files-test-result nil))
     (:safe nil   (eq files-test-result nil))
     (:safe maybe (eq files-test-result nil))
     (:all t      (eq files-test-result t))
     (:all nil    (eq files-test-result nil))
     (:all maybe  (eq files-test-result t)) ; This combination is ambiguous.
     (maybe t     (eq files-test-result 'query))
     (maybe nil   (eq files-test-result nil))
     (maybe maybe (eq files-test-result 'query)))
    ;; Unsafe local variable value
    (("files-test-result: t")
     (t t         (eq files-test-result 'query))
     (t nil       (eq files-test-result 'query))
     (t maybe     (eq files-test-result 'query))
     (nil t       (eq files-test-result nil))
     (nil nil     (eq files-test-result nil))
     (nil maybe   (eq files-test-result nil))
     (:safe t     (eq files-test-result nil))
     (:safe nil   (eq files-test-result nil))
     (:safe maybe (eq files-test-result nil))
     (:all t      (eq files-test-result t))
     (:all nil    (eq files-test-result t))
     (:all maybe  (eq files-test-result t))
     (maybe t     (eq files-test-result 'query))
     (maybe nil   (eq files-test-result 'query))
     (maybe maybe (eq files-test-result 'query)))
    ;; Safe local variable
    (("files-test-safe-result: t")
     (t t         (eq files-test-safe-result t))
     (t nil       (eq files-test-safe-result t))
     (t maybe     (eq files-test-safe-result t))
     (nil t       (eq files-test-safe-result nil))
     (nil nil     (eq files-test-safe-result nil))
     (nil maybe   (eq files-test-safe-result nil))
     (:safe t     (eq files-test-safe-result t))
     (:safe nil   (eq files-test-safe-result t))
     (:safe maybe (eq files-test-safe-result t))
     (:all t      (eq files-test-safe-result t))
     (:all nil    (eq files-test-safe-result t))
     (:all maybe  (eq files-test-safe-result t))
     (maybe t     (eq files-test-result 'query))
     (maybe nil   (eq files-test-result 'query))
     (maybe maybe (eq files-test-result 'query)))
    ;; Safe local variable with unsafe value
    (("files-test-safe-result: 1")
     (t t         (eq files-test-result 'query))
     (t nil       (eq files-test-result 'query))
     (t maybe     (eq files-test-result 'query))
     (nil t       (eq files-test-safe-result nil))
     (nil nil     (eq files-test-safe-result nil))
     (nil maybe   (eq files-test-safe-result nil))
     (:safe t     (eq files-test-safe-result nil))
     (:safe nil   (eq files-test-safe-result nil))
     (:safe maybe (eq files-test-safe-result nil))
     (:all t      (eq files-test-safe-result 1))
     (:all nil    (eq files-test-safe-result 1))
     (:all maybe  (eq files-test-safe-result 1))
     (maybe t     (eq files-test-result 'query))
     (maybe nil   (eq files-test-result 'query))
     (maybe maybe (eq files-test-result 'query))))
  "List of file-local variable tests.
Each list element should have the form

  (LOCAL-VARS-LIST . TEST-LIST)

where LOCAL-VARS-LISTS should be a list of local variable
definitions (strings) and TEST-LIST is a list of tests to
perform.  Each entry of TEST-LIST should have the form

 (ENABLE-LOCAL-VARIABLES ENABLE-LOCAL-EVAL FORM)

where ENABLE-LOCAL-VARIABLES is the value to assign to
`enable-local-variables', ENABLE-LOCAL-EVAL is the value to
assign to `enable-local-eval', and FORM is a desired `should'
form.")

(defun file-test--do-local-variables-test (str test-settings)
  (with-temp-buffer
    (insert str)
    (setq files-test-result nil
	  files-test-safe-result nil)
    (let ((enable-local-variables (nth 0 test-settings))
	  (enable-local-eval      (nth 1 test-settings))
	  ;; Prevent any dir-locals file interfering with the tests.
	  (enable-dir-local-variables nil)
	  (files-test-queried nil))
      (hack-local-variables)
      (eval (nth 2 test-settings)))))

(ert-deftest files-test-local-variables ()
  "Test the file-local variables implementation."
  (unwind-protect
      (progn
	(defadvice hack-local-variables-confirm (around files-test activate)
	  (setq files-test-result 'query)
	  nil)
	(dolist (test files-test-local-variable-data)
	  (let ((str (concat "text\n\n;; Local Variables:\n;; "
			     (mapconcat 'identity (car test) "\n;; ")
			     "\n;; End:\n")))
	    (dolist (subtest (cdr test))
	      (should (file-test--do-local-variables-test str subtest))))))
    (ad-disable-advice 'hack-local-variables-confirm 'around 'files-test)))

(defvar files-test-bug-18141-file
  (expand-file-name "data/files-bug18141.el.gz" (getenv "EMACS_TEST_DIRECTORY"))
  "Test file for bug#18141.")

(ert-deftest files-test-bug-18141 ()
  "Test for http://debbugs.gnu.org/18141 ."
  (skip-unless (executable-find "gzip"))
  (let ((tempfile (make-temp-file "files-test-bug-18141" nil ".gz")))
    (unwind-protect
	(progn
	  (copy-file files-test-bug-18141-file tempfile t)
	  (with-current-buffer (find-file-noselect tempfile)
	    (set-buffer-modified-p t)
	    (save-buffer)
	    (should (eq buffer-file-coding-system 'iso-2022-7bit-unix))))
      (delete-file tempfile))))


(ert-deftest find-file-path-completion-table-duplicates ()
  "Test completion when there are two files with the same name in
different directories on path."
  (let* ((root (make-temp-file "find-file-path-test" t))
	 (dir1 (concat root "/dir1"))
	 (dir2 (concat root "/dir2")))

    (mkdir dir1)
    (mkdir dir2)

    (with-temp-file (concat dir1 "/file1.el")
      (insert "dir1/file1.el"))
    (with-temp-file (concat dir1 "/file2.el")
      (insert "dir1/file2.el"))

    (with-temp-file (concat dir2 "/file1.el")
      (insert "dir2/file1.el"))
    (with-temp-file (concat dir2 "/file3.el")
      (insert "dir2/file3.el"))

    ;; multiple completions, some with same name
    (should (equal (find-file-path-completion-table (list dir1 dir2) nil "fi")
		   '("file1.el<dir1>" "file1.el<dir2>" "file2.el" "file3.el")))

    ;; only one completion (after user selects first of the above)
    (should (equal (find-file-path-completion-table (list dir1 dir2) nil "file1.el<dir1>")
		   '("file1.el<dir1>")))
    ))

(ert-deftest find-file-path-completion-table-predicate ()
  "Test completion when there are two files with the same name in
different directories on path, and a predicate."
  (let* ((root (make-temp-file "find-file-path-test" t))
	 (dir1 (concat root "/dir1"))
	 (dir2 (concat root "/dir2"))
         (regexp (dired-glob-regexp "*.elc"))
	 (pred (lambda (name) (not (string-match regexp name)))))

    (mkdir dir1)
    (mkdir dir2)

    (with-temp-file (concat dir1 "/file1.el")
      (insert "dir1/file1.el"))
    (with-temp-file (concat dir1 "/file1.elc")
      (insert "dir1/file1.elc"))
    (with-temp-file (concat dir1 "/file2.el")
      (insert "dir1/file2.el"))
    (with-temp-file (concat dir1 "/file2.elc")
      (insert "dir1/file2.elc"))

    (with-temp-file (concat dir2 "/file1.el")
      (insert "dir2/file1.el"))
    (with-temp-file (concat dir2 "/file1.elc")
      (insert "dir2/file1.elc"))
    (with-temp-file (concat dir2 "/file3.el")
      (insert "dir2/file3.el"))
    (with-temp-file (concat dir2 "/file3.elc")
      (insert "dir2/file3.elc"))

    ;; multiple completions, some with same name, predicate eliminates some
    (should (equal (find-file-path-completion-table (list dir1 dir2) pred "fi")
		   '("file1.el<dir1>" "file1.el<dir2>" "file2.el" "file3.el")))

    ;; only one completion (after user selects first of the above)
    (should (equal (find-file-path-completion-table (list dir1 dir2) pred "file1.el<dir1>")
		   '("file1.el<dir1>")))
    ))
;; Stop the above "Local Var..." confusing Emacs.


;;; files.el ends here