;;; casefiddle-tests.el --- tests for casefiddle.c functions -*- lexical-binding: t -*-

;; Copyright (C) 2015-2016 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 'case-table)
(require 'ert)

(defvar casefiddle-tests--resources-dir
  (concat (concat (file-name-directory (or load-file-name buffer-file-name))
                  "/casefiddle-resources/"))
  "Path to casefiddle-resources directory next to the \"casefiddle-tests.el\" file.")

(ert-deftest casefiddle-tests-char-properties ()
  "Sanity check of character Unicode properties."
  (should-not
   (let (errors)
     ;;            character  uppercase  lowercase  titlecase
     (dolist (test '((?A nil ?a nil)
                     (?a ?A nil ?A)
                     (?Ł nil ?ł nil)
                     (?ł ?Ł nil ?Ł)

                     (?DŽ nil ?dž ?Dž)
                     (?Dž ?DŽ ?dž ?Dž)
                     (?dž ?DŽ nil ?Dž)

                     (?Σ nil ?σ nil)
                     (?σ ?Σ nil ?Σ)
                     (?ς ?Σ nil ?Σ)

                     (?ⅷ ?Ⅷ nil ?Ⅷ)
                     (?Ⅷ nil ?ⅷ nil)))
       (let ((ch (car test))
             (expected (cdr test))
             (props '(uppercase lowercase titlecase)))
         (while props
           (let ((got (get-char-code-property ch (car props))))
             (unless (equal (car expected) got)
               (push (format "\n%c %s; expected: %s but got: %s"
                             ch (car props) (car expected) got)
                     errors)))
           (setq props (cdr props) expected (cdr expected)))))
     (when errors
       (mapconcat (lambda (line) line) (nreverse errors) "")))))


(defconst casefiddle-tests--characters
  ;; character  uppercase  lowercase  titlecase
  '((?A ?A ?a ?A)
    (?a ?A ?a ?A)
    (?Ł ?Ł ?ł ?Ł)
    (?ł ?Ł ?ł ?Ł)

    (?DŽ ?DŽ ?dž ?Dž)
    (?Dž ?DŽ ?dž ?Dž)
    (?dž ?DŽ ?dž ?Dž)

    (?Σ ?Σ ?σ ?Σ)
    (?σ ?Σ ?σ ?Σ)
    (?ς ?Σ ?ς ?Σ)

    (?Ⅷ ?Ⅷ ?ⅷ ?Ⅷ)
    (?ⅷ ?Ⅷ ?ⅷ ?Ⅷ)))


(ert-deftest casefiddle-tests-case-table ()
  "Sanity check of down and up case tables."
  (should-not
   (let (errors
         (up (case-table-get-table (current-case-table) 'up))
         (down (case-table-get-table (current-case-table) 'down)))
     (dolist (test casefiddle-tests--characters)
       (let ((ch (car test))
             (expected (cdr test))
             (props '(uppercase lowercase))
             (tabs (list up down)))
         (while props
           (let ((got (aref (car tabs) ch)))
             (unless (equal (car expected) got)
               (push (format "\n%c %s; expected: %s but got: %s"
                             ch (car props) (car expected) got)
                     errors)))
           (setq props (cdr props) tabs (cdr tabs) expected (cdr expected)))))
     (when errors
       (mapconcat (lambda (line) line) (nreverse errors) "")))))


(ert-deftest casefiddle-tests-casing-character ()
  (should-not
   (let (errors)
     (dolist (test casefiddle-tests--characters)
       (let ((ch (car test))
             (expected (cdr test))
             (funcs '(upcase downcase capitalize)))
         (while funcs
           (let ((got (funcall (car funcs) ch)))
             (unless (equal (car expected) got)
               (push (format "\n%c %s; expected: %s but got: %s"
                             ch (car funcs) (car expected) got)
                     errors)))
           (setq funcs (cdr funcs) expected (cdr expected)))))
     (when errors
       (mapconcat (lambda (line) line) (nreverse errors) "")))))


(ert-deftest casefiddle-tests-casing-word ()
  (with-temp-buffer
    (dolist (test '((upcase-word     . "FOO Bar")
                    (downcase-word   . "foo Bar")
                    (capitalize-word . "Foo Bar")))
      (dolist (back '(nil t))
        (delete-region (point-min) (point-max))
        (insert "foO Bar")
        (goto-char (+ (if back 4 0) (point-min)))
        (funcall (car test) (if back -1 1))
        (should (string-equal (cdr test) (buffer-string)))
        (should (equal (+ (if back 4 3) (point-min)) (point)))))))


(defun casefiddle-tests--test-casing (tests)
  (nreverse
   (cl-reduce
    (lambda (errors test)
      (let* ((input (car test))
             (expected (cdr test))
             (buffer-language (or (nth 5 test) "en_GB"))
             (func-pairs '((upcase upcase-region)
                           (downcase downcase-region)
                           (capitalize capitalize-region)
                           (upcase-initials upcase-initials-region)))
             (get-string (lambda (func) (funcall func input)))
             (get-region (lambda (func)
                           (delete-region (point-min) (point-max))
                           (unwind-protect
                               (progn
                                 (unless (multibyte-string-p input)
                                   (toggle-enable-multibyte-characters))
                                 (insert input)
                                 (funcall func (point-min) (point-max))
                                 (buffer-string))
                             (unless (multibyte-string-p input)
                               (toggle-enable-multibyte-characters)))))
             (fmt-str (lambda (str)
                        (format "%s  (%sbyte; %d chars; %d bytes)"
                                str
                                (if (multibyte-string-p str) "multi" "uni")
                                (length str) (string-bytes str))))
             funcs getters)
        (while (and func-pairs expected)
          (setq funcs (car func-pairs)
                getters (list get-string get-region))
          (when (car expected)
            (while (and funcs getters)
              (let ((got (funcall (car getters) (car funcs))))
                (unless (string-equal got (car expected))
                  (let ((fmt (length (symbol-name (car funcs)))))
                    (setq fmt (format "\n%%%ds: %%s" (max fmt 8)))
                    (push (format (concat fmt fmt fmt)
                                  (car funcs) (funcall fmt-str input)
                                  "expected" (funcall fmt-str (car expected))
                                  "but got" (funcall fmt-str got))
                          errors))))
              (setq funcs (cdr funcs) getters (cdr getters))))
          (setq func-pairs (cdr func-pairs) expected (cdr expected))))
      errors)
    (cons () tests))))

(ert-deftest casefiddle-tests-casing ()
  (should-not
   (with-temp-buffer
     (casefiddle-tests--test-casing
      ;; input     upper     lower    capitalize up-initials  [locale]
      `(("Foo baR" "FOO BAR" "foo bar" "Foo Bar" "Foo BaR")
        ("Ⅷ ⅷ" "Ⅷ Ⅷ" "ⅷ ⅷ" "Ⅷ Ⅷ" "Ⅷ Ⅷ")
        ;; "DžUNGLA" is an unfortunate result but it’s really best we can
        ;; do while still being consistent.  Hopefully, users only ever
        ;; use upcase-initials on camelCase identifiers not real words.
        ("DŽUNGLA" "DŽUNGLA" "džungla" "Džungla" "DžUNGLA")
        ("Džungla" "DŽUNGLA" "džungla" "Džungla" "Džungla")
        ("džungla" "DŽUNGLA" "džungla" "Džungla" "Džungla")
        ("define" "DEFINE" "define" "Define" "Define")
        ("fish" "FISH" "fish" "Fish" "Fish")
        ("Straße" "STRASSE" "straße" "Straße" "Straße")

        ;; The word repeated twice to test behaviour at the end of a word
        ;; inside of an input string as well as at the end of the string.
        ("ΌΣΟΣ ΌΣΟΣ" "ΌΣΟΣ ΌΣΟΣ" "όσος όσος" "Όσος Όσος" "ΌΣΟΣ ΌΣΟΣ")
        ;; What should be done with sole sigma?  It is ‘final’ but on the
        ;; other hand it does not form a word.  We’re using regular sigma.
        ("Σ Σ" "Σ Σ" "σ σ" "Σ Σ" "Σ Σ")
        ("όσος" "ΌΣΟΣ" "όσος" "Όσος" "Όσος")
        ;; If sigma is already lower case, we don’t want to change it.
        ("όσοσ" "ΌΣΟΣ" "όσοσ" "Όσοσ" "Όσοσ")

        ;; Dutch 'ij' is capitalised as single digraph.
        ("ijsland" "IJSLAND" "ijsland" "Ijsland" "Ijsland")
        ("ijsland" "IJSLAND" "ijsland" "IJsland" "IJsland" "nl")

        ;; There is a language-independent special casing rule which
        ;; converts İ into i followed by combining dot above that’s why we
        ;; get the weird \u0307.  Conceptually, it converts i with
        ;; a soft-dot into an i with a hard-dot so it makes some doze of
        ;; sense.
        ("İstanbul" "İSTANBUL" "i\u0307stanbul" "İstanbul" "İstanbul")
        ("İstanbul" "İSTANBUL" "istanbul" "İstanbul" "İstanbul" "tr")
        ("İstanbul" "İSTANBUL" "istanbul" "İstanbul" "İstanbul" "az")
        (,(decode-coding-string "istanbul" 'no-conversion-multibyte) ; make it multibyte
         "ISTANBUL" "istanbul" "Istanbul" "Istanbul")
        (,(decode-coding-string "istanbul" 'no-conversion-multibyte)
         "İSTANBUL" "istanbul" "İstanbul" "İstanbul" "tr")
        (,(decode-coding-string "istanbul" 'no-conversion-multibyte)
         "İSTANBUL" "istanbul" "İstanbul" "İstanbul" "az")
        (,(decode-coding-string "Irmak" 'no-conversion-multibyte)
         "IRMAK" "irmak" "Irmak" "Irmak")
        (,(decode-coding-string "Irmak" 'no-conversion-multibyte)
         "IRMAK" "ırmak" "Irmak" "Irmak" "tr")
        (,(decode-coding-string "Irmak" 'no-conversion-multibyte)
         "IRMAK" "ırmak" "Irmak" "Irmak" "az")
        ;; FIXME: We explicitly exclude ı→I mapping from the case tables
        ;; in characters.el which is why instead of:
        ;;("ırmak" "IRMAK" "ırmak" "Irmak" "Irmak")
        ;; we actually get:
        ("ırmak" "ıRMAK" "ırmak" "Irmak" "Irmak")
        ;; ‘But wait,’ you ask, ‘why capitalisation works’?  This is
        ;; because those bypass case-table and use character’s Unicode
        ;; titlecase property.
        ("ırmak" "IRMAK" "ırmak" "Irmak" "Irmak" "tr")
        ("ırmak" "IRMAK" "ırmak" "Irmak" "Irmak" "az")
        ;; And for some combining dot above removal.
        ("I\u0307si\u0307s" "I\u0307Sİ\u0307S" "isi\u0307s"
         "I\u0307si\u0307s" "I\u0307si\u0307s" "tr")
        ("I\u0307sI\u0307s" "I\u0307SI\u0307S" "isis"
         "I\u0307sis" "I\u0307sI\u0307s" "tr")

        ;; Test combining dot above in inserted when needed when lower
        ;; casing I or J.
        ("I\u0328\u0300"          ; I + ogonek + grave
         "I\u0328\u0300" "i\u0328\u0307\u0300"
         "I\u0328\u0300" "I\u0328\u0300" "lt")

        ("J\u0328\u0300"          ; J + ogonek + grave
         "J\u0328\u0300" "j\u0328\u0307\u0300"
         "J\u0328\u0300" "J\u0328\u0300" "lt")

        ("Į\u0300"          ; I-ogonek + grave
         "Į\u0300" "į\u0307\u0300" "Į\u0300" "Į\u0300" "lt")

        ("Ì Í Ĩ"
         "Ì Í Ĩ" "i\u0307\u0300 i\u0307\u0301 i\u0307\u0303"
         "Ì Í Ĩ" "Ì Í Ĩ" "lt")

        ;; Test combining dot above in removed when upper casing i or j.
        ("i\u0328\u0307"          ; i + ogonek + dot above
         "I\u0328" "i\u0328\u0307" "I\u0328" "I\u0328" "lt")
        ("j\u0328\u0307"          ; j + ogonek + dot above
         "J\u0328" "j\u0328\u0307" "J\u0328" "J\u0328" "lt")
        ("į\u0307"                ; i-ogonek + dot above
         "Į" "į\u0307" "Į" "Į" "lt"))))))


(defun casefiddle--read-lines (test-file)
  (with-temp-buffer
    (insert-file-contents (concat casefiddle-tests--resources-dir test-file))
    (split-string (buffer-string) "\n" nil " +")))

(ert-deftest casefiddle-test-irish ()
  (let (tests)
    ;; Read upcase test cases
    (let ((input    (casefiddle--read-lines "irish-uppercase-1.txt"))
          (expected (casefiddle--read-lines "irish-uppercase-1-ref.txt")))
      (while (and input expected)
        (push (list (car input) (car expected) nil nil nil "ga") tests)
        (setq input (cdr input) expected (cdr expected)))
      (should-not (or input expected)))

    ;; Read downcase test cases
    (let ((input    (casefiddle--read-lines "irish-lowercase-1.txt"))
          (expected (casefiddle--read-lines "irish-lowercase-1-ref.txt")))
      (while (and input expected)
        (let ((test (assoc (car input) tests)))
          (if test
              (setcar (cddr test) (car expected))
            (push (list (car input) nil (car expected) nil nil "ga") tests)))
        (setq input (cdr input) expected (cdr expected)))
      (should-not (or input expected)))

    (should-not (with-temp-buffer (casefiddle-tests--test-casing tests)))))


(ert-deftest casefiddle-tests-casing-byte8 ()
  (should-not
   (with-temp-buffer
     (casefiddle-tests--test-casing
      '(("\xff Foo baR \xff"
         "\xff FOO BAR \xff"
         "\xff foo bar \xff"
         "\xff Foo Bar \xff"
         "\xff Foo BaR \xff")
        ("\xff Zażółć gĘŚlą \xff"
         "\xff ZAŻÓŁĆ GĘŚLĄ \xff"
         "\xff zażółć gęślą \xff"
         "\xff Zażółć Gęślą \xff"
         "\xff Zażółć GĘŚlą \xff"))))))

(ert-deftest casefiddle-tests-casing-byte8-with-changes ()
  (let ((tab (copy-case-table (standard-case-table)))
        (test '("\xff\xff\xef Foo baR \xcf\xcf"
                "\xef\xef\xef FOO BAR \xcf\xcf"
                "\xff\xff\xff foo bar \xcf\xcf"
                "\xef\xff\xff Foo Bar \xcf\xcf"
                "\xef\xff\xef Foo BaR \xcf\xcf"))
        (byte8 #x3FFF00))
    (should-not
     (with-temp-buffer
       (set-case-table tab)
       (set-case-syntax-pair (+ byte8 #xef) (+ byte8 #xff) tab)
       (casefiddle-tests--test-casing
        (list test
              (mapcar (lambda (str) (decode-coding-string str 'binary)) test)
              '("\xff\xff\xef Zażółć gĘŚlą \xcf\xcf"
                "\xef\xef\xef ZAŻÓŁĆ GĘŚLĄ \xcf\xcf"
                "\xff\xff\xff zażółć gęślą \xcf\xcf"
                "\xef\xff\xff Zażółć Gęślą \xcf\xcf"
                "\xef\xff\xef Zażółć GĘŚlą \xcf\xcf")))))))


(ert-deftest casefiddle-tests-char-casing ()
  ;;             input upcase downcase [titlecase]
  (dolist (test '((?a ?A ?a) (?A ?A ?a)
                  (?ł ?Ł ?ł) (?Ł ?Ł ?ł)
                  (?ß ?ß ?ß) (?ẞ ?ẞ ?ß)
                  (?ⅷ ?Ⅷ ?ⅷ) (?Ⅷ ?Ⅷ ?ⅷ)
                  (?DŽ ?DŽ ?dž ?Dž) (?Dž ?DŽ ?dž ?Dž) (?dž ?DŽ ?dž ?Dž)))
    (let ((ch (car test))
          (up (nth 1 test))
          (lo (nth 2 test))
          (tc (or (nth 3 test) (nth 1 test))))
      (should (eq up (upcase ch)))
      (should (eq lo (downcase ch)))
      (should (eq tc (capitalize ch)))
      (should (eq tc (upcase-initials ch))))))


;;; casefiddle-tests.el ends here