org-mode/testing/lisp/test-org-footnote.el

762 lines
19 KiB
EmacsLisp
Raw Normal View History

testing: Make all files use `lexical-binding` Mainly, add the corresponding cookie, but also add various `require`s so that the compiler knows which vars should be trated as dynbound. This does not fix all the warnings, but does try to eliminate all those about "unused" variables. For the variables truly unused, the patch usually adds an underscore to their name to silence the warning. Some of the fixes affect files which already used `lexical-binding`. Not sure why the test worked before: maybe because the tests were run without compiling them first (which could cause some of the missing `require`d packages to be autoloaded before we got to the problematic code, thus hiding the problem)? I found some suspicious code, for which I added FIXMEs. There are also a few changes to the main files. * lisp/org-protocol.el (org-protocol-check-filename-for-protocol): Don't call `server-edit` if it's not yet defined. [ Needed to get the tests to pass. ] * lisp/ob-core.el (org-babel-temporary-directory) (org-babel-temporary-stable-directory): Always define (and use nil if we don't want to create a directory for it). Simplify the code based on the fact that (defvar V E) only evaluates E if V is not yet `boundp`. (org-babel-temp-file, org-babel-temp-stable-file) (org-babel-remove-temporary-directory) (org-babel-remove-temporary-stable-directory): Adjust accordingly. * lisp/org.el (org-log-beginning): Add FIXME. * testing/org-test.el: Require `org` and `org-id`. (org-id-locations-file): Don't `defconst` it. (org-test-at-id, org-test-in-example-file, org-test-at-marker) (org-test-with-temp-text, org-test-with-temp-text-in-file): Move edebug specs into `declare` (and simplify them). (org-test-with-tramp-remote-dir--worker): Declare dynbound tramp vars. (org--compile-when): Fix quoting of `exp`. (org-test-load): Tweak regexps. * testing/org-batch-test-init.el: Tweak regexp, remove dead code and add a FIXME about it. * testing/lisp/test-ox.el: Require `ox` instead of erroring out if it's not already loaded. Also require `org-inlinetask`. (org-test-with-parsed-data): Silence warnings when `info` is not used. (test-org-export/bind-keyword): Add FIXME. * testing/lisp/test-ox-publish.el: Require `org-test` and `ox-publish`. (test-org-publish/resolve-external-link): Expose lambdas to the compiler. Remove unused var `ids`. (test-org-publish/get-project-from-filename): Remove unused var `file`. * testing/lisp/test-org.el: Require `org-macs`, `org`, `org-inlinetask`, `org-refile`, and `org-agenda`. (test-org/org-read-date): Declare `org-time-was-given` as dynbound. (test-org/set-regexps-and-options): Add FIXME. * testing/lisp/test-org-timer.el: Require `org-timer`. * testing/lisp/test-org-table.el: Require `ox`. * testing/lisp/test-org-protocol.el: Require `org-protocol` instead of erroring out if it's not already loaded. Also require `capture`, and add missing `provide` statement. * testing/lisp/test-org-pcomplete.el: Require `org`. * testing/lisp/test-org-list.el: Require `org-list` and `org`. * testing/lisp/test-org-lint.el: Require `org-footnote` and `org-lint`. * testing/lisp/test-org-footnote.el: Require `org-footnote`. * testing/lisp/test-org-element.el: Require `org-element` instead of erroring out if it's not already loaded. Also require `org` and `org-inlinetask`. * testing/lisp/test-org-duration.el: Require `org-duration`. * testing/lisp/test-org-datetree.el: Require `org-datetree`. * testing/lisp/test-org-colview.el: Require `org-colview`, `org-duration`, and `org-inlinetask`. * testing/lisp/test-org-clock.el: Require `org-duration` and `org-clock`. * testing/lisp/test-org-archive.el: Require `org-archive`. * testing/lisp/test-org-agenda.el (test-org-agenda/bulk-custom-arg-func): Add FIXME. * testing/lisp/test-ol.el: Require `ol` and `org-id`. (test-org-link/store-link): Declare `org-store-link-props` and add FIXME. * testing/lisp/test-oc.el (test-org-cite/export-capability): Add FIXME. * testing/lisp/test-ob.el: Require `ob-core`, `org-src`, `ob-ref`, and `org-table`. (test-ob/eval-header-argument): Rename `foo` to `test-ob--foo` and declare it as dynbound. (test-ob/blocks-with-spaces, test-ob/specific-colnames): Add FIXME. (test-ob/noweb-expansions-in-cache): Declare `noweb-expansions-in-cache-var` as dynbound. * testing/lisp/test-ob-tangle.el: Require `org` and `ob-tangle`. * testing/lisp/test-ob-shell.el: * testing/lisp/test-ob-python.el: Require `ob-core`. * testing/lisp/test-ob-lob.el: Require `ob-lob`. (temporary-value-for-test): Declare as dynbound. * testing/lisp/test-ob-plantuml.el: Require `ob-plantuml` instead of erroring out if it's not already loaded. * testing/lisp/test-ob-lilypond.el: Require `ob-lilypond` instead of erroring out if it's not already loaded. Use `with-current-buffer`. * testing/lisp/test-ob-julia.el: Require `ob-core`. * testing/lisp/test-ob-java.el (org-babel-temporary-directory): Remove dead code now that `org-babel-temporary-directory` is always bound. * testing/lisp/test-ob-exp.el: Require `ob-exp`, `org-src`, and `org-test`. (ob-exp/evaluate-all-executables-in-order): Declare `*evaluation-collector*` as dynbound. * testing/lisp/test-ob-emacs-lisp.el (ob-emacs-lisp/dynamic-lexical-edit) (ob-emacs-lisp/dynamic-lexical-execute): Rename dynbound var to `ob-emacs--x` and declare it as such. * testing/lisp/test-ob-R.el: Require `ob-core`. (ess-ask-for-ess-directory, ess-history-file): Declare vars.
2022-09-14 21:21:37 +00:00
;;; test-org-footnote.el --- Tests for org-footnote.el -*- lexical-binding: t; -*-
2019-01-01 10:50:56 +00:00
;; Copyright (C) 2012-2015, 2019 Nicolas Goaziou
2015-12-16 17:38:53 +00:00
;; Author: Nicolas Goaziou <mail at nicolasgoaziou dot fr>
;; This program 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.
;; This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
;;; Code:
testing: Make all files use `lexical-binding` Mainly, add the corresponding cookie, but also add various `require`s so that the compiler knows which vars should be trated as dynbound. This does not fix all the warnings, but does try to eliminate all those about "unused" variables. For the variables truly unused, the patch usually adds an underscore to their name to silence the warning. Some of the fixes affect files which already used `lexical-binding`. Not sure why the test worked before: maybe because the tests were run without compiling them first (which could cause some of the missing `require`d packages to be autoloaded before we got to the problematic code, thus hiding the problem)? I found some suspicious code, for which I added FIXMEs. There are also a few changes to the main files. * lisp/org-protocol.el (org-protocol-check-filename-for-protocol): Don't call `server-edit` if it's not yet defined. [ Needed to get the tests to pass. ] * lisp/ob-core.el (org-babel-temporary-directory) (org-babel-temporary-stable-directory): Always define (and use nil if we don't want to create a directory for it). Simplify the code based on the fact that (defvar V E) only evaluates E if V is not yet `boundp`. (org-babel-temp-file, org-babel-temp-stable-file) (org-babel-remove-temporary-directory) (org-babel-remove-temporary-stable-directory): Adjust accordingly. * lisp/org.el (org-log-beginning): Add FIXME. * testing/org-test.el: Require `org` and `org-id`. (org-id-locations-file): Don't `defconst` it. (org-test-at-id, org-test-in-example-file, org-test-at-marker) (org-test-with-temp-text, org-test-with-temp-text-in-file): Move edebug specs into `declare` (and simplify them). (org-test-with-tramp-remote-dir--worker): Declare dynbound tramp vars. (org--compile-when): Fix quoting of `exp`. (org-test-load): Tweak regexps. * testing/org-batch-test-init.el: Tweak regexp, remove dead code and add a FIXME about it. * testing/lisp/test-ox.el: Require `ox` instead of erroring out if it's not already loaded. Also require `org-inlinetask`. (org-test-with-parsed-data): Silence warnings when `info` is not used. (test-org-export/bind-keyword): Add FIXME. * testing/lisp/test-ox-publish.el: Require `org-test` and `ox-publish`. (test-org-publish/resolve-external-link): Expose lambdas to the compiler. Remove unused var `ids`. (test-org-publish/get-project-from-filename): Remove unused var `file`. * testing/lisp/test-org.el: Require `org-macs`, `org`, `org-inlinetask`, `org-refile`, and `org-agenda`. (test-org/org-read-date): Declare `org-time-was-given` as dynbound. (test-org/set-regexps-and-options): Add FIXME. * testing/lisp/test-org-timer.el: Require `org-timer`. * testing/lisp/test-org-table.el: Require `ox`. * testing/lisp/test-org-protocol.el: Require `org-protocol` instead of erroring out if it's not already loaded. Also require `capture`, and add missing `provide` statement. * testing/lisp/test-org-pcomplete.el: Require `org`. * testing/lisp/test-org-list.el: Require `org-list` and `org`. * testing/lisp/test-org-lint.el: Require `org-footnote` and `org-lint`. * testing/lisp/test-org-footnote.el: Require `org-footnote`. * testing/lisp/test-org-element.el: Require `org-element` instead of erroring out if it's not already loaded. Also require `org` and `org-inlinetask`. * testing/lisp/test-org-duration.el: Require `org-duration`. * testing/lisp/test-org-datetree.el: Require `org-datetree`. * testing/lisp/test-org-colview.el: Require `org-colview`, `org-duration`, and `org-inlinetask`. * testing/lisp/test-org-clock.el: Require `org-duration` and `org-clock`. * testing/lisp/test-org-archive.el: Require `org-archive`. * testing/lisp/test-org-agenda.el (test-org-agenda/bulk-custom-arg-func): Add FIXME. * testing/lisp/test-ol.el: Require `ol` and `org-id`. (test-org-link/store-link): Declare `org-store-link-props` and add FIXME. * testing/lisp/test-oc.el (test-org-cite/export-capability): Add FIXME. * testing/lisp/test-ob.el: Require `ob-core`, `org-src`, `ob-ref`, and `org-table`. (test-ob/eval-header-argument): Rename `foo` to `test-ob--foo` and declare it as dynbound. (test-ob/blocks-with-spaces, test-ob/specific-colnames): Add FIXME. (test-ob/noweb-expansions-in-cache): Declare `noweb-expansions-in-cache-var` as dynbound. * testing/lisp/test-ob-tangle.el: Require `org` and `ob-tangle`. * testing/lisp/test-ob-shell.el: * testing/lisp/test-ob-python.el: Require `ob-core`. * testing/lisp/test-ob-lob.el: Require `ob-lob`. (temporary-value-for-test): Declare as dynbound. * testing/lisp/test-ob-plantuml.el: Require `ob-plantuml` instead of erroring out if it's not already loaded. * testing/lisp/test-ob-lilypond.el: Require `ob-lilypond` instead of erroring out if it's not already loaded. Use `with-current-buffer`. * testing/lisp/test-ob-julia.el: Require `ob-core`. * testing/lisp/test-ob-java.el (org-babel-temporary-directory): Remove dead code now that `org-babel-temporary-directory` is always bound. * testing/lisp/test-ob-exp.el: Require `ob-exp`, `org-src`, and `org-test`. (ob-exp/evaluate-all-executables-in-order): Declare `*evaluation-collector*` as dynbound. * testing/lisp/test-ob-emacs-lisp.el (ob-emacs-lisp/dynamic-lexical-edit) (ob-emacs-lisp/dynamic-lexical-execute): Rename dynbound var to `ob-emacs--x` and declare it as such. * testing/lisp/test-ob-R.el: Require `ob-core`. (ess-ask-for-ess-directory, ess-history-file): Declare vars.
2022-09-14 21:21:37 +00:00
(require 'org-footnote)
(ert-deftest test-org-footnote/new-anon ()
"Test `org-footnote-new' specifications."
;; `org-footnote-auto-label' is `anonymous'.
(should
(string-match-p
"Test\\[fn::\\]"
(org-test-with-temp-text "Test<point>"
(let ((org-footnote-auto-label 'anonymous)
(org-footnote-section nil))
(org-footnote-new))
(buffer-string)))))
(ert-deftest test-org-footnote/new ()
"Test `org-footnote-new' specifications."
;; `org-footnote-auto-label' is t.
(should
(string-match-p
"Test\\[fn:1\\]\n+\\[fn:1\\]"
(org-test-with-temp-text "Test<point>"
(let ((org-footnote-auto-label t)
(org-footnote-section nil))
(org-footnote-new))
(buffer-string))))
;; `org-footnote-auto-label' is `random'.
(should
(string-match-p
"Test\\[fn:\\(.+?\\)\\]\n+\\[fn:\\1\\]"
(org-test-with-temp-text "Test<point>"
(let ((org-footnote-auto-label 'random)
(org-footnote-section nil))
(org-footnote-new))
(buffer-string))))
;; Error at beginning of line.
(should-error
(org-test-with-temp-text "<point>Test"
(org-footnote-new)))
;; Error at keywords.
(should-error
(org-test-with-temp-text "#+TIT<point>LE: value"
(org-footnote-new)))
(should-error
(org-test-with-temp-text "#+CAPTION: <point>\nParagraph"
(org-footnote-new)))
;; Allow new footnotes in blank lines at the beginning of the
;; document.
(should
(string-match-p
" \\[fn:1\\]"
(org-test-with-temp-text " <point>"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
;; In an headline or inlinetask, point must be either on the
;; heading itself or on the blank lines below.
(should (org-test-with-temp-text "* H<point>" (org-footnote-new) t))
(should
(org-test-with-temp-text "* H\n <point>\nParagraph" (org-footnote-new) t))
(should-error (org-test-with-temp-text "*<point> H" (org-footnote-new) t))
(should-error
(org-test-with-temp-text "* H <point>:tag:" (org-footnote-new) t))
;; Allow new footnotes within recursive objects, but not in links.
(should
(string-match-p
" \\*bold\\[fn:1\\]\\*"
(org-test-with-temp-text " *bold<point>*"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
(should-error
(org-test-with-temp-text " [[https://orgmode.org][Org mode<point>]]"
(org-footnote-new)))
;; Allow new footnotes in blank lines after an element or white
;; spaces after an object.
(should
(string-match-p
" \\[fn:1\\]"
(org-test-with-temp-text "#+BEGIN_EXAMPLE\nA\n#+END_EXAMPLE\n <point>"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
(should
(string-match-p
" \\*bold\\*\\[fn:1\\]"
(org-test-with-temp-text " *bold*<point>"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
;; Allow new footnotes at the start of a footnote definition.
(should
(string-match-p
"\\[fn:1\\]\\[fn:2\\]"
(org-test-with-temp-text "[fn:1]<point>"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
(should
(string-match-p
"\\[fn:1\\] \\[fn:2\\]"
(org-test-with-temp-text "[fn:1] <point>"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
(should
(string-match-p
"\\[fn:1\\]\\[fn:2\\]"
(org-test-with-temp-text "[fn:1]<point> \nParagraph"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
(should-error
(org-test-with-temp-text "[fn:<point>1]"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string)))
(should-error
(org-test-with-temp-text "<point>[fn:1]"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string)))
;; Allow new footnotes in table cells.
(should
(string-match-p
" \\[fn:1\\]"
(org-test-with-temp-text "| <point> |"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
(should
(string-match-p
"|\\[fn:1\\]"
(org-test-with-temp-text "|<point> |"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
(should
(string-match-p
" \\[fn:1\\]"
(org-test-with-temp-text "| <point>|"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
(should
(string-match-p
" \\[fn:1\\]"
(org-test-with-temp-text "| contents <point>|"
(let ((org-footnote-auto-label t)) (org-footnote-new))
(buffer-string))))
;; When creating a new footnote, move to its definition.
(should
(string=
"[fn:1]"
(org-test-with-temp-text "Text<point>"
(let ((org-footnote-auto-label t)
(org-footnote-auto-adjust nil))
(org-footnote-new))
(buffer-substring-no-properties (line-beginning-position) (point)))))
;; Re-order and re-label footnotes properly when
;; `org-footnote-auto-adjust' is non-nil.
(should
(string=
"[fn:1] 1\n\n[fn:2] \n\n[fn:3] 2\n"
(org-test-with-temp-text
"Text[fn:1]Text<point>Text[fn:2]\n\n[fn:1] 1\n\n[fn:2] 2"
(let ((org-footnote-auto-label t)
(org-footnote-auto-adjust t)
(org-footnote-section nil))
(org-footnote-new))
(buffer-substring-no-properties
(line-beginning-position -1)
(line-beginning-position 4)))))
;; Do not alter file local variables when inserting new definition
;; label.
(should
(equal "Paragraph[fn:1]
\[fn:1]
# Local Variables:
# foo: t
# End:"
(org-test-with-temp-text
"Paragraph<point>\n# Local Variables:\n# foo: t\n# End:"
(let ((org-footnote-section nil)) (org-footnote-new))
(buffer-string))))
(should
(equal "Paragraph[fn:1]
* Footnotes
\[fn:1]
# Local Variables:
# foo: t
# End:"
(org-test-with-temp-text
"Paragraph<point>\n# Local Variables:\n# foo: t\n# End:"
(let ((org-footnote-section "Footnotes")) (org-footnote-new))
(buffer-string))))
(should
(equal "Para[fn:1]
* Footnotes
:properties:
:custom_id: id
:end:
\[fn:1]"
(org-test-with-temp-text
"Para<point>\n* Footnotes\n:properties:\n:custom_id: id\n:end:"
(let ((org-footnote-section "Footnotes"))
(org-footnote-new))
(org-trim (buffer-string))))))
(ert-deftest test-org-footnote/delete ()
"Test `org-footnote-delete' specifications."
;; Regular test.
(should
(equal "Paragraph"
2015-12-16 17:38:53 +00:00
(org-test-with-temp-text "Paragraph<point>[fn:1]\n\n[fn:1] Definition"
(org-footnote-delete)
(org-trim (buffer-string)))))
;; Remove multiple definitions and references.
(should
(equal "Paragraph and another"
(org-test-with-temp-text
2015-12-16 17:38:53 +00:00
"Paragraph<point>[fn:1] and another[fn:1]
\[fn:1] def
\[fn:1] def"
(org-footnote-delete)
(org-trim (buffer-string)))))
;; Delete inline footnotes and all references.
(should
(equal "Para and"
2015-12-16 17:38:53 +00:00
(org-test-with-temp-text "Para<point>[fn:label:def] and[fn:label]"
(org-footnote-delete)
(org-trim (buffer-string)))))
;; Delete anonymous footnotes.
(should
(equal "Para"
2015-12-16 17:38:53 +00:00
(let ((org-footnote-section nil))
(org-test-with-temp-text "Para<point>[fn::def]"
(org-footnote-delete)
(org-trim (buffer-string))))))
;; With an argument, delete footnote with specified label.
(should
2015-12-16 17:38:53 +00:00
(equal "Paragraph[fn:1] and another\n\n[fn:1] def"
(let ((org-footnote-section nil))
(org-test-with-temp-text
2015-12-16 17:38:53 +00:00
"Paragraph[fn:1] and another[fn:2]\n\n[fn:1] def\n\n[fn:2] def2"
(org-footnote-delete "2")
(org-trim (buffer-string))))))
;; Error when no argument is specified at point is not at a footnote
;; reference.
(should-error
2015-12-16 17:38:53 +00:00
(org-test-with-temp-text "Para[fn:1]\n\n[fn:1] Def"
(org-footnote-delete)))
;; Correctly delete footnotes with multiple paragraphs.
(should
(equal "Para\n\n\nOutside footnote."
2015-12-16 17:38:53 +00:00
(let ((org-footnote-section nil))
(org-test-with-temp-text
"Para[fn:1]\n\n[fn:1] para1\n\npara2\n\n\nOutside footnote."
(org-footnote-delete "1")
(org-trim (buffer-string))))))
;; Remove blank lines above the footnote but preserve those after
;; it.
(should
(equal "Text\n\n\nOther text."
(let ((org-footnote-section nil))
(org-test-with-temp-text
"Text[fn:1]\n\n[fn:1] Definition.\n\n\nOther text."
(org-footnote-delete "1")
(buffer-string)))))
;; Preserve file local variables when deleting a footnote.
(should
(equal
"Paragraph\n# Local Variables:\n# foo: t\n# End:"
(org-test-with-temp-text
"Paragraph[fn:1]\n[fn:1] Def 1\n# Local Variables:\n# foo: t\n# End:"
(let ((org-footnote-section nil)) (org-footnote-delete "1"))
(buffer-string)))))
(ert-deftest test-org-footnote/goto-definition ()
"Test `org-footnote-goto-definition' specifications."
;; Error on unknown definitions.
(should-error
(org-test-with-temp-text "No footnote definition"
2015-12-16 17:38:53 +00:00
(org-footnote-goto-definition "1")))
;; Error when trying to reach a definition outside narrowed part of
;; buffer.
(should-error
(org-test-with-temp-text "Some text<point>\n[fn:1] Definition."
(narrow-to-region (point-min) (point))
2015-12-16 17:38:53 +00:00
(org-footnote-goto-definition "1")))
(should-error
(org-test-with-temp-text "[fn:1] Definition.\n<point>Some text"
(narrow-to-region (point) (point-max))
2015-12-16 17:38:53 +00:00
(org-footnote-goto-definition "1")))
;; Otherwise, move at the beginning of the definition, including
;; anonymous footnotes.
(should
(equal
" Definition."
(org-test-with-temp-text "Some text\n[fn:1] Definition."
2015-12-16 17:38:53 +00:00
(org-footnote-goto-definition "1")
(buffer-substring (point) (point-max)))))
(should
(equal
"definition]"
(org-test-with-temp-text "Some text[fn:label:definition]"
2015-12-16 17:38:53 +00:00
(org-footnote-goto-definition "label")
(buffer-substring (point) (point-max))))))
(ert-deftest test-org-footnote/goto-previous-reference ()
"Test `org-footnote-goto-previous-reference' specifications."
;; Error on unknown reference.
(should-error
(org-test-with-temp-text "No footnote reference"
(org-footnote-goto-previous-reference "1")))
;; Error when trying to reach a reference outside narrowed part of
;; buffer.
(should-error
(org-test-with-temp-text "Some text<point>\nReference[fn:1]."
(narrow-to-region (point-min) (point))
(org-footnote-goto-previous-reference "1")))
;; Otherwise, move to closest reference from point.
(should
(org-test-with-temp-text "First reference[fn:1]\nReference[fn:1].<point>"
(org-footnote-goto-previous-reference "1")
(= (line-end-position) (point-max))))
(should
(org-test-with-temp-text "First reference[fn:1]\nReference[fn:1]."
(org-footnote-goto-previous-reference "1")
(= (line-beginning-position) (point-min)))))
2015-12-16 17:38:53 +00:00
(ert-deftest test-org-footnote/sort ()
"Test `org-footnote-sort' specifications."
;; Reorder definitions with a nil `org-footnote-section'. In this
;; case each definition is written at the end of the section
;; containing its first reference.
(should
2015-12-16 17:38:53 +00:00
(equal
"
Text[fn:1][fn:2]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2
"
(org-test-with-temp-text "
Text[fn:1][fn:2]
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1"
(let ((org-footnote-section nil)) (org-footnote-sort))
(buffer-string))))
(should
(equal
"
* H1
Text[fn:1]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1
* H2
Text[fn:2]
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2
"
(org-test-with-temp-text "
* H1
Text[fn:1]
* H2
Text[fn:2]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2
"
2015-12-16 17:38:53 +00:00
(let ((org-footnote-section nil)) (org-footnote-sort))
(buffer-string))))
;; Reorder definitions with a non-nil `org-footnote-section'.
(should
(equal
"
Text[fn:1][fn:2]
* Footnotes
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1
\[fn:2] Def 2
"
(org-test-with-temp-text "
Text[fn:1][fn:2]
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1"
(let ((org-footnote-section "Footnotes")) (org-footnote-sort))
(buffer-string))))
;; When `org-footnote-section' is non-nil, clear previous footnote
;; sections.
(should
(equal
2015-12-16 17:38:53 +00:00
"
Text[fn:1]
* Headline
* Other headline
* Footnotes
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1
"
(org-test-with-temp-text "
Text[fn:1]
* Footnotes
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1
2015-12-16 17:38:53 +00:00
* Headline
2015-12-16 17:38:53 +00:00
** Footnotes
2015-12-16 17:38:53 +00:00
* Other headline"
(let ((org-footnote-section "Footnotes")) (org-footnote-sort))
(buffer-string))))
;; Ignore anonymous footnotes.
(should
(equal
"
Text[fn:1][fn::inline][fn:2]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2
"
(org-test-with-temp-text
"
Text[fn:1][fn::inline][fn:2]
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1"
(let ((org-footnote-section nil)) (org-footnote-sort))
(buffer-string))))
;; Ignore inline footnotes.
(should
2015-12-16 17:38:53 +00:00
(equal
"
Text[fn:1][fn:label:inline][fn:2]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2
"
2015-12-16 17:38:53 +00:00
(org-test-with-temp-text
"
Text[fn:1][fn:label:inline][fn:2]
\[fn:2] Def 2
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1"
(let ((org-footnote-section nil)) (org-footnote-sort))
(buffer-string))))
;; Handle (deeply) nested footnotes.
(should
(equal
2015-12-16 17:38:53 +00:00
"
Text[fn:1][fn:3]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1[fn:2]
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2
2015-12-16 17:38:53 +00:00
\[fn:3] Def 3
"
(org-test-with-temp-text "
Text[fn:1][fn:3]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1[fn:2]
2015-12-16 17:38:53 +00:00
\[fn:3] Def 3
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2
"
(let ((org-footnote-section nil)) (org-footnote-sort))
(buffer-string))))
(should
(equal
"
Text[fn:1][fn:4]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1[fn:2]
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2[fn:3]
2015-12-16 17:38:53 +00:00
\[fn:3] Def 3
2015-12-16 17:38:53 +00:00
\[fn:4] Def 4
"
(org-test-with-temp-text "
Text[fn:1][fn:4]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1[fn:2]
2015-12-16 17:38:53 +00:00
\[fn:3] Def 3
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2[fn:3]
2015-12-16 17:38:53 +00:00
\[fn:4] Def 4
"
(let ((org-footnote-section nil)) (org-footnote-sort))
(buffer-string))))
;; When multiple (nested) references are used, make sure to insert
;; definition only once.
(should
(equal
"
* Section 1
2015-12-16 17:38:53 +00:00
Text[fn:1]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1
2015-12-16 17:38:53 +00:00
* Section 2
2015-12-16 17:38:53 +00:00
Text[fn:1]"
(org-test-with-temp-text
"
* Section 1
2015-12-16 17:38:53 +00:00
Text[fn:1]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1
2015-12-16 17:38:53 +00:00
* Section 2
2015-12-16 17:38:53 +00:00
Text[fn:1]"
(let ((org-footnote-section nil)) (org-footnote-sort))
(buffer-string))))
(should
(equal
"
Text[fn:1][fn:4]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1[fn:2][fn:3]
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2[fn:3]
2015-12-16 17:38:53 +00:00
\[fn:3] Def 3
2015-12-16 17:38:53 +00:00
\[fn:4] Def 4
"
(org-test-with-temp-text "
Text[fn:1][fn:4]
2015-12-16 17:38:53 +00:00
\[fn:1] Def 1[fn:2][fn:3]
2015-12-16 17:38:53 +00:00
\[fn:3] Def 3
2015-12-16 17:38:53 +00:00
\[fn:2] Def 2[fn:3]
2015-12-16 17:38:53 +00:00
\[fn:4] Def 4
"
(let ((org-footnote-section nil)) (org-footnote-sort))
(buffer-string))))
;; Insert un-referenced definitions at the end.
(should
(equal
"Text[fn:9]
\[fn:9] B
\[fn:1] A
"
(org-test-with-temp-text "Text[fn:9]\n\n[fn:1] A\n[fn:9] B"
2015-12-16 17:38:53 +00:00
(let ((org-footnote-section nil)) (org-footnote-sort))
(buffer-string))))
;; When sorting, preserve file local variables.
(should
(equal "
Paragraph[fn:1][fn:2]
\[fn:1] Def 1
\[fn:2] Def 2
# Local Variables:
# foo: t
# End:"
(org-test-with-temp-text
"
Paragraph[fn:1][fn:2]
\[fn:2] Def 2
\[fn:1] Def 1
# Local Variables:
# foo: t
# End:"
(let ((org-footnote-section nil)) (org-footnote-sort))
(buffer-string)))))
2015-12-16 17:38:53 +00:00
(ert-deftest test-org-footnote/renumber-fn:N ()
"Test `org-footnote-renumber-fn:N' specifications."
;; Renumber (inline) references and definitions.
(should
(equal
"Test[fn:1]"
(org-test-with-temp-text "Test[fn:99]"
(org-footnote-renumber-fn:N)
(buffer-string))))
(should
(equal
"Test[fn:1]\n\n[fn:1] 99"
(org-test-with-temp-text "Test[fn:99]\n\n[fn:99] 99"
(org-footnote-renumber-fn:N)
(buffer-string))))
(should
(equal
"Test[fn:1:99]"
(org-test-with-temp-text "Test[fn:99:99]"
(org-footnote-renumber-fn:N)
(buffer-string))))
;; No-op if there's no numbered footnote.
(should
(equal
"Test[fn:label]\n\n[fn:label] Def"
(org-test-with-temp-text "Test[fn:label]\n\n[fn:label] Def"
(org-footnote-renumber-fn:N)
(buffer-string))))
;; Definitions without a reference get the highest numbers.
(should
(equal
"Test[fn:1]\n[fn:1] 1\n[fn:2] 99"
(org-test-with-temp-text "Test[fn:1]\n[fn:1] 1\n[fn:99] 99"
(org-footnote-renumber-fn:N)
(buffer-string))))
;; Sort labels in sequence. Anonymous footnotes are ignored.
(should
(equal
"Test[fn:1][fn:2:def][fn:3]"
(org-test-with-temp-text "Test[fn:4][fn:3:def][fn:2]"
(org-footnote-renumber-fn:N)
(buffer-string))))
(should
(equal
"Test[fn:1][fn::def][fn:2]"
(org-test-with-temp-text "Test[fn:4][fn::def][fn:2]"
(org-footnote-renumber-fn:N)
(buffer-string)))))
(ert-deftest test-org-footnote/normalize ()
"Test `org-footnote-normalize' specifications."
;; Normalize regular, inline and anonymous references.
(should
(equal
"Test[fn:1]\n\n[fn:1] def\n"
(org-test-with-temp-text "Test[fn:label]\n[fn:label] def"
(let ((org-footnote-section nil)) (org-footnote-normalize))
(buffer-string))))
(should
(equal
"Test[fn:1]\n\n[fn:1] def\n"
(org-test-with-temp-text "Test[fn:label:def]"
(let ((org-footnote-section nil)) (org-footnote-normalize))
(buffer-string))))
(should
(equal
"Test[fn:1]\n\n[fn:1] def\n"
(org-test-with-temp-text "Test[fn::def]"
(let ((org-footnote-section nil)) (org-footnote-normalize))
(buffer-string))))
;; Normalization includes sorting.
(should
(equal
"Test[fn:1][fn:2]\n\n[fn:1] def2\n\n[fn:2] def\n"
(org-test-with-temp-text "Test[fn:2][fn:1]\n\n[fn:2] def2\n[fn:1] def"
(let ((org-footnote-section nil)) (org-footnote-normalize))
(buffer-string))))
(should
(equal
"Test[fn:1][fn:2]\n\n[fn:1] def\n\n[fn:2] inline\n"
(org-test-with-temp-text "Test[fn:2][fn::inline]\n[fn:2] def\n"
(let ((org-footnote-section nil)) (org-footnote-normalize))
(buffer-string))))
(should
(equal
"Test[fn:1][fn:3]
2015-12-16 17:38:53 +00:00
\[fn:1] def[fn:2]
2015-12-16 17:38:53 +00:00
\[fn:2] inline
2015-12-16 17:38:53 +00:00
\[fn:3] last
"
(org-test-with-temp-text
"Test[fn:lab1][fn:lab2]\n[fn:lab1] def[fn::inline]\n[fn:lab2] last"
(let ((org-footnote-section nil)) (org-footnote-normalize))
(buffer-string))))
;; When normalizing an inline reference, fill paragraph whenever the
;; `org-footnote-fill-after-inline-note-extraction' is non-nil.
(should
(equal
"Test[fn:1] Next\n\n[fn:1] def\n"
(org-test-with-temp-text "Test[fn::def]\nNext"
(let ((org-footnote-section nil)
(org-footnote-fill-after-inline-note-extraction t))
(org-footnote-normalize))
(buffer-string))))
;; Insert un-referenced definitions at the end.
(should
(equal
"Test[fn:1]\nNext\n\n[fn:1] def\n\n[fn:2] A\n"
(org-test-with-temp-text "Test[fn::def]\nNext\n[fn:unref] A"
(let ((org-footnote-section nil)) (org-footnote-normalize))
(buffer-string))))
;; Preserve file local variables when normalizing.
(should
(equal "
Paragraph[fn:1][fn:2]
\[fn:1] Def 1
\[fn:2] Def 2
# Local Variables:
# foo: t
# End:"
(org-test-with-temp-text
"
Paragraph[fn:foo][fn:bar]
\[fn:bar] Def 2
\[fn:foo] Def 1
# Local Variables:
# foo: t
# End:"
(let ((org-footnote-section nil)) (org-footnote-normalize))
(buffer-string)))))
(provide 'test-org-footnote)
;;; test-org-footnote.el ends here