Function: faceup-test-equal

faceup-test-equal is a byte-compiled function defined in faceup.el.gz.

Signature

(faceup-test-equal LHS RHS)

Documentation

Compares two (multi-line) strings, LHS and RHS, for equality.

This is intended to be used in Ert regression test rules.

When faceup-test-explain is non-nil, instead of returning nil on inequality, a list is returned with a explanation what differs. Currently, this function reports 1) if the number of lines in the strings differ. 2) the lines and the line numbers on which the string differed.

For example:
    (let ((a "ABC\\nDEF\\nGHI")
          (b "ABC\\nXXX\\nGHI\\nZZZ")
          (faceup-test-explain t))
      (message "%s" (faceup-test-equal a b)))

    ==> (4 3 number-of-lines-differ (on-line 2 (DEF) (XXX)))

When used in an ert rule, the output is as below:

    (ert-deftest faceup-test-equal-example ()
      (let ((a "ABC\\nDEF\\nGHI")
            (b "ABC\\nXXX\\nGHI\\nZZZ"))
        (should (faceup-test-equal a b))))

    F faceup-test-equal-example
        (ert-test-failed
         ((should
           (faceup-test-equal a b))
          :form
          (faceup-test-equal "ABC\\nDEF\\nGHI" "ABC\\nXXX\\nGHI\\nZZZ")
          :value nil :explanation
          (4 3 number-of-lines-differ
             (on-line 2
                      ("DEF")
                      ("XXX")))))

Source Code

;; Defined in /usr/src/emacs/lisp/emacs-lisp/faceup.el.gz
;; ------------------------------
;; Multi-line string support.
;;

(defun faceup-test-equal (lhs rhs)
  "Compares two (multi-line) strings, LHS and RHS, for equality.

This is intended to be used in Ert regression test rules.

When `faceup-test-explain' is non-nil, instead of returning nil
on inequality, a list is returned with a explanation what
differs.  Currently, this function reports 1) if the number of
lines in the strings differ.  2) the lines and the line numbers on
which the string differed.

For example:
    (let ((a \"ABC\\nDEF\\nGHI\")
          (b \"ABC\\nXXX\\nGHI\\nZZZ\")
          (faceup-test-explain t))
      (message \"%s\" (faceup-test-equal a b)))

    ==> (4 3 number-of-lines-differ (on-line 2 (DEF) (XXX)))

When used in an `ert' rule, the output is as below:

    (ert-deftest faceup-test-equal-example ()
      (let ((a \"ABC\\nDEF\\nGHI\")
            (b \"ABC\\nXXX\\nGHI\\nZZZ\"))
        (should (faceup-test-equal a b))))

    F faceup-test-equal-example
        (ert-test-failed
         ((should
           (faceup-test-equal a b))
          :form
          (faceup-test-equal \"ABC\\nDEF\\nGHI\" \"ABC\\nXXX\\nGHI\\nZZZ\")
          :value nil :explanation
          (4 3 number-of-lines-differ
             (on-line 2
                      (\"DEF\")
                      (\"XXX\")))))"
  (if (equal lhs rhs)
      t
    (if faceup-test-explain
        (let ((lhs-lines (split-string lhs "\n"))
              (rhs-lines (split-string rhs "\n"))
              (explanation '())
              (line 1))
          (unless (= (length lhs-lines) (length rhs-lines))
            (setq explanation (list 'number-of-lines-differ
                                    (length lhs-lines) (length rhs-lines))))
          (while lhs-lines
            (let ((one (pop lhs-lines))
                  (two (pop rhs-lines)))
              (unless (equal one two)
                (setq explanation
                      (cons (list 'on-line line (list one) (list two))
                            explanation)))
              (setq line (+ line 1))))
          (nreverse explanation))
      nil)))