testing/lisp/test-org-table.el

   1 ;;; test-org-table.el --- tests for org-table.el
   2
   3 ;; Copyright (c)  David Maus
   4 ;; Authors: David Maus, Michael Brand
   5
   6 ;; This file is not part of GNU Emacs.
   7
   8 ;; This program is free software; you can redistribute it and/or modify
   9 ;; it under the terms of the GNU General Public License as published by
  10 ;; the Free Software Foundation, either version 3 of the License, or
  11 ;; (at your option) any later version.
  12
  13 ;; This program is distributed in the hope that it will be useful,
  14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ;; GNU General Public License for more details.
  17
  18 ;; You should have received a copy of the GNU General Public License
  19 ;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 ;;;; Comments:
  22
  23 ;; Template test file for Org-mode tests.  Many tests are also a howto
  24 ;; example collection as a user documentation, more or less all those
  25 ;; using `org-test-table-target-expect'.  See also the doc string of
  26 ;; `org-test-table-target-expect'.
  27
  28 ;;; Code:
  29
  30 (require 'org-table)  ; `org-table-make-reference'
  31
  32 (ert-deftest test-org-table/simple-formula/no-grouping/no-title-row ()
  33   "Simple sum without grouping rows, without title row."
  34   (org-test-table-target-expect
  35    "
  36 |       2 |
  37 |       4 |
  38 |       8 |
  39 | replace |
  40 "
  41    "
  42 |  2 |
  43 |  4 |
  44 |  8 |
  45 | 14 |
  46 "
  47    1
  48    ;; Calc formula
  49    "#+TBLFM: @>$1 = vsum(@<..@>>)"
  50    ;; Lisp formula
  51    "#+TBLFM: @>$1 = '(+ @<..@>>); N"))
  52
  53 (ert-deftest test-org-table/simple-formula/no-grouping/with-title-row ()
  54   "Simple sum without grouping rows, with title row."
  55   (org-test-table-target-expect
  56    "
  57 |     foo |
  58 |---------|
  59 |       2 |
  60 |       4 |
  61 |       8 |
  62 | replace |
  63 "
  64    "
  65 | foo |
  66 |-----|
  67 |   2 |
  68 |   4 |
  69 |   8 |
  70 |  14 |
  71 "
  72    1
  73    ;; Calc formula
  74    "#+TBLFM: @>$1 = vsum(@I..@>>)"
  75    ;; Lisp formula
  76    "#+TBLFM: @>$1 = '(+ @I..@>>); N"))
  77
  78 (ert-deftest test-org-table/simple-formula/with-grouping/no-title-row ()
  79   "Simple sum with grouping rows, how not to do."
  80   ;; The first example has a problem, see the second example in this
  81   ;; ert-deftest.
  82   (org-test-table-target-expect
  83    "
  84 |       2 |
  85 |       4 |
  86 |       8 |
  87 |---------|
  88 | replace |
  89 "
  90    "
  91 |  2 |
  92 |  4 |
  93 |  8 |
  94 |----|
  95 | 14 |
  96 "
  97    1
  98    ;; Calc formula
  99    "#+TBLFM: $1 = vsum(@<..@>>)"
 100    ;; Lisp formula
 101    "#+TBLFM: $1 = '(+ @<..@>>); N")
 102
 103   ;; The problem is that the first three rows with the summands are
 104   ;; considered the header and therefore column formulas are not
 105   ;; applied on them as shown below.  Also export behaves unexpected.
 106   ;; See next ert-deftest how to group rows right.
 107   (org-test-table-target-expect
 108    "
 109 |       2 | replace |
 110 |       4 | replace |
 111 |       8 | replace |
 112 |---------+---------|
 113 | replace | replace |
 114 "
 115    "
 116 |  2 | replace |
 117 |  4 | replace |
 118 |  8 | replace |
 119 |----+---------|
 120 | 14 | 28      |
 121 "
 122    2
 123    ;; Calc formula
 124    "#+TBLFM: @>$1 = vsum(@<..@>>) :: $2 = 2 * $1"
 125    ;; Lisp formula
 126    "#+TBLFM: @>$1 = '(+ @<..@>>); N :: $2 = '(* 2 $1); N"))
 127
 128 (ert-deftest test-org-table/simple-formula/with-grouping/with-title-row ()
 129   "Simple sum with grouping rows, how to do it right."
 130   ;; Always add a top row with the column names separated by hline to
 131   ;; get the desired header when you want to group rows.
 132   (org-test-table-target-expect
 133    "
 134 |     foo | bar     |
 135 |---------+---------|
 136 |       2 | replace |
 137 |       4 | replace |
 138 |       8 | replace |
 139 |---------+---------|
 140 | replace | replace |
 141 "
 142    "
 143 | foo | bar |
 144 |-----+-----|
 145 |   2 |   4 |
 146 |   4 |   8 |
 147 |   8 |  16 |
 148 |-----+-----|
 149 |  14 |  28 |
 150 "
 151    2
 152    ;; Calc formula
 153    "#+TBLFM: @>$1 = vsum(@I..@>>) :: $2 = 2 * $1"
 154    ;; Lisp formula
 155    "#+TBLFM: @>$1 = '(+ @I..@>>); N :: $2 = '(* 2 $1); N"))
 156
 157 (ert-deftest test-org-table/align ()
 158   "Align columns within Org buffer, depends on `org-table-number-regexp'."
 159   (org-test-table-target-expect "
 160 | 0  |  0 |    0 |       0 |       0 |           0 |       0 |    0 |
 161 | ab | 12 | 12.2 | 2.4e-08 | 2x10^12 | 4.034+-0.02 | 2.7(10) | >3.5 |
 162 | ab | ab |   ab |      ab |      ab |          ab |      ab |   ab |
 163 ")
 164   (org-test-table-target-expect "
 165 |          0 |           0 |   0 |    0 |    0 |   0 |
 166 | <-0x0ab.cf | >-36#0vw.yz | nan | uinf | -inf | inf |
 167 |         ab |          ab |  ab |   ab |   ab |  ab |
 168 "))
 169
 170 (defconst references/target-normal "
 171 | 0 | 1 | replace | replace | replace | replace | replace | replace |
 172 | z | 1 | replace | replace | replace | replace | replace | replace |
 173 |   | 1 | replace | replace | replace | replace | replace | replace |
 174 |   |   | replace | replace | replace | replace | replace | replace |
 175 "
 176   "Normal numbers and non-numbers for Lisp and Calc formula.")
 177
 178 (defconst references/target-special "
 179 |  nan | 1 | replace | replace | replace | replace | replace | replace |
 180 | uinf | 1 | replace | replace | replace | replace | replace | replace |
 181 | -inf | 1 | replace | replace | replace | replace | replace | replace |
 182 |  inf | 1 | replace | replace | replace | replace | replace | replace |
 183 "
 184   "Special numbers for Calc formula.")
 185
 186 (ert-deftest test-org-table/references/mode-string-EL ()
 187   "Basic: Assign field reference, sum of field references, sum
 188 and len of simple range reference (no row) and complex range
 189 reference (with row).  Mode string EL."
 190   ;; Empty fields are kept during parsing field but lost as list
 191   ;; elements within Lisp formula syntactically when used literally
 192   ;; and not enclosed with " within fields, see last columns with len.
 193   (org-test-table-target-expect
 194    references/target-normal
 195    ;; All the #ERROR show that for Lisp calculations N has to be used.
 196    "
 197 | 0 | 1 | 0 |      1 |      1 |      1 | 2 | 2 |
 198 | z | 1 | z | #ERROR | #ERROR | #ERROR | 2 | 2 |
 199 |   | 1 |   |      1 |      1 |      1 | 1 | 1 |
 200 |   |   |   |      0 |      0 |      0 | 0 | 0 |
 201 "
 202    1 (concat
 203       "#+TBLFM: $3 = '(identity \"$1\"); EL :: $4 = '(+ $1 $2); EL :: "
 204       "$5 = '(+ $1..$2); EL :: $6 = '(+ @0$1..@0$2); EL :: "
 205       "$7 = '(length '($1..$2)); EL :: $8 = '(length '(@0$1..@0$2)); EL"))
 206
 207   ;; Empty fields are kept during parsing field _and_ as list elements
 208   ;; within Lisp formula syntactically even when used literally when
 209   ;; enclosed with " within fields, see last columns with len.
 210   (org-test-table-target-expect
 211    "
 212 | \"0\" | \"1\" | repl | repl | repl | repl | repl | repl |
 213 | \"z\" | \"1\" | repl | repl | repl | repl | repl | repl |
 214 | \"\"  | \"1\" | repl | repl | repl | repl | repl | repl |
 215 | \"\"  | \"\"  | repl | repl | repl | repl | repl | repl |
 216 "
 217    "
 218 | \"0\" | \"1\" | \"0\" | 1 | #ERROR | #ERROR | 2 | 2 |
 219 | \"z\" | \"1\" | \"z\" | 1 | #ERROR | #ERROR | 2 | 2 |
 220 | \"\"  | \"1\" | \"\"  | 1 | #ERROR | #ERROR | 2 | 2 |
 221 | \"\"  | \"\"  | \"\"  | 0 | #ERROR | #ERROR | 2 | 2 |
 222 "
 223    1 (concat
 224       "#+TBLFM: $3 = '(concat \"\\\"\" $1 \"\\\"\"); EL :: "
 225       "$4 = '(+ (string-to-number $1) (string-to-number $2)); EL :: "
 226       "$5 = '(+ $1..$2); EL :: $6 = '(+ @0$1..@0$2); EL :: "
 227       "$7 = '(length '($1..$2)); EL :: $8 = '(length '(@0$1..@0$2)); EL")))
 228
 229 (ert-deftest test-org-table/references/mode-string-E ()
 230   "Basic: Assign field reference, sum of field references, sum
 231 and len of simple range reference (no row) and complex range
 232 reference (with row).  Mode string E."
 233   (let ((lisp
 234          (concat
 235           "#+TBLFM: $3 = '(identity $1); E :: $4 = '(+ $1 $2); E :: "
 236           "$5 = '(+ $1..$2); E :: $6 = '(+ @0$1..@0$2); E :: "
 237           "$7 = '(length '($1..$2)); E :: $8 = '(length '(@0$1..@0$2)); E"))
 238         (calc
 239          (concat
 240           "#+TBLFM: $3 = $1; E :: $4 = $1 + $2; E :: "
 241           "$5 = vsum($1..$2); E :: $6 = vsum(@0$1..@0$2); E :: "
 242           "$7 = vlen($1..$2); E :: $8 = vlen(@0$1..@0$2); E")))
 243     (org-test-table-target-expect
 244      references/target-normal
 245      ;; All the #ERROR show that for Lisp calculations N has to be used.
 246      "
 247 | 0 | 1 | 0 | #ERROR | #ERROR | #ERROR | 2 | 2 |
 248 | z | 1 | z | #ERROR | #ERROR | #ERROR | 2 | 2 |
 249 |   | 1 |   | #ERROR | #ERROR | #ERROR | 2 | 2 |
 250 |   |   |   | #ERROR | #ERROR | #ERROR | 2 | 2 |
 251 "
 252      1 lisp)
 253     (org-test-table-target-expect
 254      references/target-normal
 255      "
 256 | 0 | 1 |   0 |     1 |     1 |     1 | 2 | 2 |
 257 | z | 1 |   z | z + 1 | z + 1 | z + 1 | 2 | 2 |
 258 |   | 1 | nan |   nan |   nan |   nan | 2 | 2 |
 259 |   |   | nan |   nan |   nan |   nan | 2 | 2 |
 260 "
 261      1 calc)
 262     (org-test-table-target-expect
 263      references/target-special
 264      "
 265 |  nan | 1 |  nan |  nan |  nan |  nan | 2 | 2 |
 266 | uinf | 1 | uinf | uinf | uinf | uinf | 2 | 2 |
 267 | -inf | 1 | -inf | -inf | -inf | -inf | 2 | 2 |
 268 |  inf | 1 |  inf |  inf |  inf |  inf | 2 | 2 |
 269 "
 270      1 calc)))
 271
 272 (ert-deftest test-org-table/references/mode-string-EN ()
 273   "Basic: Assign field reference, sum of field references, sum
 274 and len of simple range reference (no row) and complex range
 275 reference (with row).  Mode string EN."
 276   (let ((lisp (concat
 277                "#+TBLFM: $3 = '(identity $1); EN :: $4 = '(+ $1 $2); EN :: "
 278                "$5 = '(+ $1..$2); EN :: $6 = '(+ @0$1..@0$2); EN :: "
 279                "$7 = '(length '($1..$2)); EN :: "
 280                "$8 = '(length '(@0$1..@0$2)); EN"))
 281         (calc (concat
 282                "#+TBLFM: $3 = $1; EN :: $4 = $1 + $2; EN :: "
 283                "$5 = vsum($1..$2); EN :: $6 = vsum(@0$1..@0$2); EN :: "
 284                "$7 = vlen($1..$2); EN :: $8 = vlen(@0$1..@0$2); EN")))
 285     (org-test-table-target-expect
 286      references/target-normal
 287      "
 288 | 0 | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 289 | z | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 290 |   | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 291 |   |   | 0 | 0 | 0 | 0 | 2 | 2 |
 292 "
 293      1 lisp calc)
 294     (org-test-table-target-expect
 295      references/target-special
 296      "
 297 |  nan | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 298 | uinf | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 299 | -inf | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 300 |  inf | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 301 "
 302      1 calc)))
 303
 304 (ert-deftest test-org-table/references/mode-string-L ()
 305   "Basic: Assign field reference, sum of field references, sum
 306 and len of simple range reference (no row) and complex range
 307 reference (with row).  Mode string L."
 308   (org-test-table-target-expect
 309    references/target-normal
 310    ;; All the #ERROR show that for Lisp calculations N has to be used.
 311    "
 312 | 0 | 1 | 0 |      1 |      1 |      1 | 2 | 2 |
 313 | z | 1 | z | #ERROR | #ERROR | #ERROR | 2 | 2 |
 314 |   | 1 |   |      1 |      1 |      1 | 1 | 1 |
 315 |   |   |   |      0 |      0 |      0 | 0 | 0 |
 316 "
 317    1 (concat
 318       "#+TBLFM: $3 = '(identity \"$1\"); L :: $4 = '(+ $1 $2); L :: "
 319       "$5 = '(+ $1..$2); L :: $6 = '(+ @0$1..@0$2); L :: "
 320       "$7 = '(length '($1..$2)); L :: $8 = '(length '(@0$1..@0$2)); L")))
 321
 322 (ert-deftest test-org-table/references/mode-string-none ()
 323   "Basic: Assign field reference, sum of field references, sum
 324 and len of simple range reference (no row) and complex range
 325 reference (with row).  No mode string."
 326   (let ((lisp (concat
 327                "#+TBLFM: $3 = '(identity $1) :: $4 = '(+ $1 $2) :: "
 328                "$5 = '(+ $1..$2) :: $6 = '(+ @0$1..@0$2) :: "
 329                "$7 = '(length '($1..$2)) :: $8 = '(length '(@0$1..@0$2))"))
 330         (calc (concat
 331                "#+TBLFM: $3 = $1 :: $4 = $1 + $2 :: "
 332                "$5 = vsum($1..$2) :: $6 = vsum(@0$1..@0$2) :: "
 333                "$7 = vlen($1..$2) :: $8 = vlen(@0$1..@0$2)")))
 334     (org-test-table-target-expect
 335      references/target-normal
 336      ;; All the #ERROR show that for Lisp calculations N has to be used.
 337      "
 338 | 0 | 1 | 0 | #ERROR | #ERROR | #ERROR | 2 | 2 |
 339 | z | 1 | z | #ERROR | #ERROR | #ERROR | 2 | 2 |
 340 |   | 1 |   | #ERROR | #ERROR | #ERROR | 1 | 1 |
 341 |   |   |   | #ERROR | 0      | 0      | 0 | 0 |
 342 "
 343      1 lisp)
 344     (org-test-table-target-expect
 345      references/target-normal
 346      "
 347 | 0 | 1 | 0 |     1 |     1 |     1 | 2 | 2 |
 348 | z | 1 | z | z + 1 | z + 1 | z + 1 | 2 | 2 |
 349 |   | 1 | 0 |     1 |     1 |     1 | 1 | 1 |
 350 |   |   | 0 |     0 |     0 |     0 | 0 | 0 |
 351 "
 352      1 calc)
 353     (org-test-table-target-expect
 354      references/target-special
 355      "
 356 |  nan | 1 |  nan |  nan |  nan |  nan | 2 | 2 |
 357 | uinf | 1 | uinf | uinf | uinf | uinf | 2 | 2 |
 358 | -inf | 1 | -inf | -inf | -inf | -inf | 2 | 2 |
 359 |  inf | 1 |  inf |  inf |  inf |  inf | 2 | 2 |
 360 "
 361      1 calc)))
 362
 363 (ert-deftest test-org-table/references/mode-string-N ()
 364   "Basic: Assign field reference, sum of field references, sum
 365 and len of simple range reference (no row) and complex range
 366 reference (with row).  Mode string N."
 367   (let ((lisp
 368          (concat
 369           "#+TBLFM: $3 = '(identity $1); N :: $4 = '(+ $1 $2); N :: "
 370           "$5 = '(+ $1..$2); N :: $6 = '(+ @0$1..@0$2); N :: "
 371           "$7 = '(length '($1..$2)); N :: $8 = '(length '(@0$1..@0$2)); N"))
 372         (calc
 373          (concat
 374           "#+TBLFM: $3 = $1; N :: $4 = $1 + $2; N :: "
 375           "$5 = vsum($1..$2); N :: $6 = vsum(@0$1..@0$2); N :: "
 376           "$7 = vlen($1..$2); N :: $8 = vlen(@0$1..@0$2); N")))
 377     (org-test-table-target-expect
 378      references/target-normal
 379      "
 380 | 0 | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 381 | z | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 382 |   | 1 | 0 | 1 | 1 | 1 | 1 | 1 |
 383 |   |   | 0 | 0 | 0 | 0 | 0 | 0 |
 384 "
 385      1 lisp calc)
 386     (org-test-table-target-expect
 387      references/target-special
 388      "
 389 |  nan | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 390 | uinf | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 391 | -inf | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 392 |  inf | 1 | 0 | 1 | 1 | 1 | 2 | 2 |
 393 "
 394      1 calc)))
 395
 396 (ert-deftest test-org-table/compare ()
 397   "Basic: Compare field references in Calc."
 398   (org-test-table-target-expect
 399    "
 400 |      | 0    | z    |      | nan  | uinf | -inf | inf  |
 401 |------+------+------+------+------+------+------+------|
 402 |    0 | repl | repl | repl | repl | repl | repl | repl |
 403 |    z | repl | repl | repl | repl | repl | repl | repl |
 404 |      | repl | repl | repl | repl | repl | repl | repl |
 405 |  nan | repl | repl | repl | repl | repl | repl | repl |
 406 | uinf | repl | repl | repl | repl | repl | repl | repl |
 407 | -inf | repl | repl | repl | repl | repl | repl | repl |
 408 |  inf | repl | repl | repl | repl | repl | repl | repl |
 409 "
 410    "
 411 |      | 0 | z |   | nan | uinf | -inf | inf |
 412 |------+---+---+---+-----+------+------+-----|
 413 |    0 | x |   |   |     |      |      |     |
 414 |    z |   | x |   |     |      |      |     |
 415 |      |   |   | x |     |      |      |     |
 416 |  nan |   |   |   |   x |      |      |     |
 417 | uinf |   |   |   |     |    x |      |     |
 418 | -inf |   |   |   |     |      |    x |     |
 419 |  inf |   |   |   |     |      |      |   x |
 420 "
 421    1
 422    ;; Compare field reference ($1) with field reference (@1)
 423    "#+TBLFM: @<<$<<..@>$> = if(\"$1\" == \"@1\", x, string(\"\")); E"
 424    ;; Compare field reference ($1) with absolute term
 425    (concat "#+TBLFM: "
 426            "$2 = if(\"$1\" == \"(0)\"   , x, string(\"\")); E :: "
 427            "$3 = if(\"$1\" == \"(z)\"   , x, string(\"\")); E :: "
 428            "$4 = if(\"$1\" == \"nan\"   , x, string(\"\")); E :: "
 429            "$5 = if(\"$1\" == \"(nan)\" , x, string(\"\")); E :: "
 430            "$6 = if(\"$1\" == \"(uinf)\", x, string(\"\")); E :: "
 431            "$7 = if(\"$1\" == \"(-inf)\", x, string(\"\")); E :: "
 432            "$8 = if(\"$1\" == \"(inf)\" , x, string(\"\")); E"))
 433
 434   ;; Check field reference converted from an empty field: Despite this
 435   ;; field reference will not end up in a result, Calc evaluates it.
 436   ;; Make sure that also then there is no Calc error.
 437   (org-test-table-target-expect
 438    "
 439 |   0 | replace |
 440 |   z | replace |
 441 |     | replace |
 442 | nan | replace |
 443 "
 444    "
 445 |   0 |     1 |
 446 |   z | z + 1 |
 447 |     |       |
 448 | nan |   nan |
 449 "
 450    1 "#+TBLFM: $2 = if(\"$1\" == \"nan\", string(\"\"), $1 + 1); E"))
 451
 452 (ert-deftest test-org-table/empty-field ()
 453   "Examples how to deal with empty fields."
 454   ;; Test if one field is empty, else do a calculation
 455   (org-test-table-target-expect
 456    "
 457 | -1 | replace |
 458 |  0 | replace |
 459 |    | replace |
 460 "
 461    "
 462 | -1 | 0 |
 463 |  0 | 1 |
 464 |    |   |
 465 "
 466    1
 467    ;; Calc formula
 468    "#+TBLFM: $2 = if(\"$1\" == \"nan\", string(\"\"), $1 + 1); E"
 469    ;; Lisp formula
 470    "#+TBLFM: $2 = '(if (eq \"$1\" \"\") \"\" (1+ $1)); L")
 471
 472   ;; Test if several fields are empty, else do a calculation
 473   (org-test-table-target-expect
 474    "
 475 | 1 | 2 | replace |
 476 | 4 |   | replace |
 477 |   | 8 | replace |
 478 |   |   | replace |
 479 "
 480    "
 481 | 1 | 2 | 3 |
 482 | 4 |   |   |
 483 |   | 8 |   |
 484 |   |   |   |
 485 "
 486    1
 487    ;; Calc formula
 488    (concat "#+TBLFM: $3 = if(\"$1\" == \"nan\" || \"$2\" == \"nan\", "
 489            "string(\"\"), $1 + $2); E")
 490    ;; Lisp formula
 491    (concat "#+TBLFM: $3 = '(if (or (eq \"$1\" \"\") (eq \"$2\" \"\")) "
 492            "\"\" (+ $1 $2)); L"))
 493
 494   ;; $2: Use $1 + 0.5 if $1 available, else only reformat $2 if $2 available
 495   (org-test-table-target-expect
 496    "
 497 | 1.5 | 0 |
 498 | 3.5 |   |
 499 |     | 5 |
 500 |     |   |
 501 "
 502    "
 503 | 1.5 | 2.0 |
 504 | 3.5 | 4.0 |
 505 |     | 5.0 |
 506 |     |     |
 507 "
 508    1
 509    ;; Calc formula
 510    (concat "#+TBLFM: $2 = if(\"$1\" == \"nan\", "
 511            "if(\"$2\" == \"nan\", string(\"\"), $2 +.0), $1 + 0.5); E f-1")
 512    ;; Lisp formula not implemented yet
 513    )
 514
 515   ;; Empty fields in simple and complex range reference
 516   (org-test-table-target-expect
 517    "
 518 |   |   |   |   | repl | repl | repl | repl | repl | repl |
 519 |   |   | 5 | 7 | repl | repl | repl | repl | repl | repl |
 520 | 1 | 3 | 5 | 7 | repl | repl | repl | repl | repl | repl |
 521 "
 522    "
 523 |   |   |   |   |   |   |   |   | 0 | 0 |
 524 |   |   | 5 | 7 |   |   | 6 | 6 | 3 | 3 |
 525 | 1 | 3 | 5 | 7 | 4 | 4 | 4 | 4 | 4 | 4 |
 526 "
 527    1
 528    ;; Calc formula
 529    (concat
 530     "#+TBLFM: "
 531     "$5 = if(typeof(vmean($1..$4)) == 12, "
 532     "string(\"\"), vmean($1..$4)); E :: "
 533     "$6 = if(typeof(vmean(@0$1..@0$4)) == 12, "
 534     "string(\"\"), vmean(@0$1..@0$4)); E :: "
 535     "$7 = if(\"$1..$4\" == \"[]\", string(\"\"), vmean($1..$4)) :: "
 536     "$8 = if(\"@0$1..@0$4\" == \"[]\", string(\"\"), vmean(@0$1..@0$4)) :: "
 537     "$9 = vmean($1..$4); EN :: "
 538     "$10 = vmean(@0$1..@0$4); EN")
 539    ;; Lisp formula
 540    (concat
 541     "#+TBLFM: "
 542     "$5 = '(let ((l '($1..$4))) (if (member \"\" l) \"\" "
 543     "(/ (apply '+ (mapcar 'string-to-number l)) (length l)))); E :: "
 544     "$6 = '(let ((l '(@0$1..@0$4))) (if (member \"\" l) \"\" "
 545     "(/ (apply '+ (mapcar 'string-to-number l)) (length l)))); E :: "
 546     "$7 = '(let ((l '($1..$4))) "
 547     "(if l (/ (apply '+ l) (length l)) \"\")); N :: "
 548     "$8 = '(let ((l '(@0$1..@0$4))) "
 549     "(if l (/ (apply '+ l) (length l)) \"\")); N :: "
 550     "$9 = '(/ (+ $1..$4) (length '($1..$4))); EN :: "
 551     "$10 = '(/ (+ @0$1..@0$4) (length '(@0$1..@0$4))); EN")
 552 ))
 553
 554 (ert-deftest test-org-table/copy-field ()
 555   "Experiments on how to copy one field into another field.
 556 See also `test-org-table/remote-reference-access'."
 557   (let ((target "
 558 | 0                | replace |
 559 | a b              | replace |
 560 | c   d            | replace |
 561 |                  | replace |
 562 | 2012-12          | replace |
 563 | [2012-12-31 Mon] | replace |
 564 "))
 565     ;; Lisp formula to copy literally
 566     (org-test-table-target-expect
 567      target
 568      "
 569 | 0                | 0                |
 570 | a b              | a b              |
 571 | c   d            | c   d            |
 572 |                  |                  |
 573 | 2012-12          | 2012-12          |
 574 | [2012-12-31 Mon] | [2012-12-31 Mon] |
 575 "
 576      1 "#+TBLFM: $2 = '(identity $1)")
 577
 578     ;; Calc formula to copy quite literally
 579     (org-test-table-target-expect
 580      target
 581      "
 582 | 0                | 0                |
 583 | a b              | a b              |
 584 | c   d            | c   d            |
 585 |                  |                  |
 586 | 2012-12          | 2012-12          |
 587 | [2012-12-31 Mon] | <2012-12-31 Mon> |
 588 "
 589      1 (concat "#+TBLFM: $2 = if(\"$1\" == \"nan\", "
 590                "string(\"\"), string(subvec(\"$1\", 2, vlen(\"$1\")))); E"))
 591
 592     ;; Calc formula simple
 593     (org-test-table-target-expect
 594      target
 595      "
 596 | 0                | 0                |
 597 | a b              | a b              |
 598 | c   d            | c d              |
 599 |                  |                  |
 600 | 2012-12          | 2000             |
 601 | [2012-12-31 Mon] | <2012-12-31 Mon> |
 602 "
 603      1 "#+TBLFM: $2 = if(\"$1\" == \"nan\", string(\"\"), $1); E")))
 604
 605 (ert-deftest test-org-table/sub-total ()
 606   "Grouped rows with sub-total.
 607 Begin range with \"@II\" to handle multiline header.  Convert
 608 integer to float with \"+.0\" for sub-total of items c1 and c2.
 609 Sum empty fields as value zero but without ignoring them for
 610 \"vlen\" with format specifier \"EN\".  Format possibly empty
 611 results with the Calc formatter \"f-1\" instead of the printf
 612 formatter \"%.1f\"."
 613   (org-test-table-target-expect
 614    "
 615 |-------+---------+---------|
 616 | Item  |    Item | Sub-    |
 617 | name  |   value | total   |
 618 |-------+---------+---------|
 619 | a1    |     4.1 | replace |
 620 | a2    |     8.2 | replace |
 621 | a3    |         | replace |
 622 |-------+---------+---------|
 623 | b1    |    16.0 | replace |
 624 |-------+---------+---------|
 625 | c1    |      32 | replace |
 626 | c2    |      64 | replace |
 627 |-------+---------+---------|
 628 | Total | replace | replace |
 629 |-------+---------+---------|
 630 "
 631    "
 632 |-------+-------+-------|
 633 | Item  |  Item |  Sub- |
 634 | name  | value | total |
 635 |-------+-------+-------|
 636 | a1    |   4.1 |       |
 637 | a2    |   8.2 |       |
 638 | a3    |       |  12.3 |
 639 |-------+-------+-------|
 640 | b1    |  16.0 |  16.0 |
 641 |-------+-------+-------|
 642 | c1    |    32 |       |
 643 | c2    |    64 |  96.0 |
 644 |-------+-------+-------|
 645 | Total | 124.3 |       |
 646 |-------+-------+-------|
 647 "
 648    1 (concat "#+TBLFM: @>$2 = vsum(@II..@>>) ::"
 649              "$3 = if(vlen(@0..@+I) == 1, "
 650              "vsum(@-I$2..@+I$2) +.0, string(\"\")); EN f-1 :: "
 651              "@>$3 = string(\"\")")))
 652
 653 (ert-deftest test-org-table/org-lookup-all ()
 654   "Use `org-lookup-all' for several GROUP BY as in SQL and for ranking.
 655 See also http://orgmode.org/worg/org-tutorials/org-lookups.html ."
 656   (let ((data "
 657 #+NAME: data
 658 | Purchase | Product | Shop | Rating |
 659 |----------+---------+------+--------|
 660 | a        | p1      | s1   |      1 |
 661 | b        | p1      | s2   |      4 |
 662 | c        | p2      | s1   |      2 |
 663 | d        | p3      | s2   |      8 |
 664 "))
 665
 666     ;; Product rating and ranking by average purchase from "#+NAME: data"
 667     (org-test-table-target-expect
 668      (concat data "
 669 | Product | Rating  | Ranking |
 670 |---------+---------+---------|
 671 | p1      | replace | replace |
 672 | p2      | replace | replace |
 673 | p3      | replace | replace |
 674 ")
 675      (concat data "
 676 | Product | Rating | Ranking |
 677 |---------+--------+---------|
 678 | p1      |    2.5 |       2 |
 679 | p2      |    2.0 |       3 |
 680 | p3      |    8.0 |       1 |
 681 ")
 682     2 (concat
 683        "#+TBLFM: $2 = '(let ((all (org-lookup-all '$1 "
 684        "'(remote(data, @I$2..@>$2)) '(remote(data, @I$4..@>$4))))) "
 685        "(/ (apply '+ all) (length all) 1.0)); L :: "
 686        "$3 = '(+ 1 (length (org-lookup-all $2 '(@I$2..@>$2) nil '<))); N"))
 687
 688     ;; Shop rating and ranking by average purchase from "#+NAME: data"
 689     (org-test-table-target-expect
 690      (concat data "
 691 | Shop | Rating  | Ranking |
 692 |------+---------+---------|
 693 | s1   | replace | replace |
 694 | s2   | replace | replace |
 695 ")
 696      (concat data "
 697 | Shop | Rating | Ranking |
 698 |------+--------+---------|
 699 | s1   |    1.5 |       2 |
 700 | s2   |    6.0 |       1 |
 701 ")
 702      2 (concat
 703        "#+TBLFM: $2 = '(let ((all (org-lookup-all '$1 "
 704        "'(remote(data, @I$3..@>$3)) '(remote(data, @I$4..@>$4))))) "
 705        "(/ (apply '+ all) (length all) 1.0)); L :: "
 706        "$3 = '(+ 1 (length (org-lookup-all $2 '(@I$2..@>$2) nil '<))); N"))))
 707
 708 (ert-deftest test-org-table/org-table-make-reference/mode-string-EL ()
 709   (fset 'f 'org-table-make-reference)
 710   ;; For Lisp formula only
 711   (should (equal "0"   (f   "0"      t nil 'literal)))
 712   (should (equal "z"   (f   "z"      t nil 'literal)))
 713   (should (equal  ""   (f   ""       t nil 'literal)))
 714   (should (equal "0 1" (f '("0" "1") t nil 'literal)))
 715   (should (equal "z 1" (f '("z" "1") t nil 'literal)))
 716   (should (equal  " 1" (f '(""  "1") t nil 'literal)))
 717   (should (equal  " "  (f '(""  "" ) t nil 'literal))))
 718
 719 (ert-deftest test-org-table/org-table-make-reference/mode-string-E ()
 720   (fset 'f 'org-table-make-reference)
 721   ;; For Lisp formula
 722   (should (equal "\"0\""       (f   "0"         t nil t)))
 723   (should (equal "\"z\""       (f   "z"         t nil t)))
 724   (should (equal  "\"\""       (f   ""          t nil t)))
 725   (should (equal "\"0\" \"1\"" (f '("0"    "1") t nil t)))
 726   (should (equal "\"z\" \"1\"" (f '("z"    "1") t nil t)))
 727   (should (equal  "\"\" \"1\"" (f '(""     "1") t nil t)))
 728   (should (equal  "\"\" \"\""  (f '(""     "" ) t nil t)))
 729   ;; For Calc formula
 730   (should (equal  "(0)"        (f   "0"         t nil nil)))
 731   (should (equal  "(z)"        (f   "z"         t nil nil)))
 732   (should (equal  "nan"        (f   ""          t nil nil)))
 733   (should (equal  "[0,1]"      (f '("0"    "1") t nil nil)))
 734   (should (equal  "[z,1]"      (f '("z"    "1") t nil nil)))
 735   (should (equal  "[nan,1]"    (f '(""     "1") t nil nil)))
 736   (should (equal  "[nan,nan]"  (f '(""     "" ) t nil nil)))
 737   ;; For Calc formula, special numbers
 738   (should (equal  "(nan)"      (f    "nan"      t nil nil)))
 739   (should (equal "(uinf)"      (f   "uinf"      t nil nil)))
 740   (should (equal "(-inf)"      (f   "-inf"      t nil nil)))
 741   (should (equal  "(inf)"      (f    "inf"      t nil nil)))
 742   (should (equal  "[nan,1]"    (f '( "nan" "1") t nil nil)))
 743   (should (equal "[uinf,1]"    (f '("uinf" "1") t nil nil)))
 744   (should (equal "[-inf,1]"    (f '("-inf" "1") t nil nil)))
 745   (should (equal  "[inf,1]"    (f '( "inf" "1") t nil nil))))
 746
 747 (ert-deftest test-org-table/org-table-make-reference/mode-string-EN ()
 748   (fset 'f 'org-table-make-reference)
 749   ;; For Lisp formula
 750   (should (equal  "0"    (f   "0"         t t t)))
 751   (should (equal  "0"    (f   "z"         t t t)))
 752   (should (equal  "0"    (f   ""          t t t)))
 753   (should (equal  "0 1"  (f '("0"    "1") t t t)))
 754   (should (equal  "0 1"  (f '("z"    "1") t t t)))
 755   (should (equal  "0 1"  (f '(""     "1") t t t)))
 756   (should (equal  "0 0"  (f '(""     "" ) t t t)))
 757   ;; For Calc formula
 758   (should (equal "(0)"   (f   "0"         t t nil)))
 759   (should (equal "(0)"   (f   "z"         t t nil)))
 760   (should (equal "(0)"   (f   ""          t t nil)))
 761   (should (equal "[0,1]" (f '("0"    "1") t t nil)))
 762   (should (equal "[0,1]" (f '("z"    "1") t t nil)))
 763   (should (equal "[0,1]" (f '(""     "1") t t nil)))
 764   (should (equal "[0,0]" (f '(""     "" ) t t nil)))
 765   ;; For Calc formula, special numbers
 766   (should (equal "(0)"   (f    "nan"      t t nil)))
 767   (should (equal "(0)"   (f   "uinf"      t t nil)))
 768   (should (equal "(0)"   (f   "-inf"      t t nil)))
 769   (should (equal "(0)"   (f    "inf"      t t nil)))
 770   (should (equal "[0,1]" (f '( "nan" "1") t t nil)))
 771   (should (equal "[0,1]" (f '("uinf" "1") t t nil)))
 772   (should (equal "[0,1]" (f '("-inf" "1") t t nil)))
 773   (should (equal "[0,1]" (f '( "inf" "1") t t nil))))
 774
 775 (ert-deftest test-org-table/org-table-make-reference/mode-string-L ()
 776   (fset 'f 'org-table-make-reference)
 777   ;; For Lisp formula only
 778   (should (equal "0"   (f   "0"      nil nil 'literal)))
 779   (should (equal "z"   (f   "z"      nil nil 'literal)))
 780   (should (equal  ""   (f   ""       nil nil 'literal)))
 781   (should (equal "0 1" (f '("0" "1") nil nil 'literal)))
 782   (should (equal "z 1" (f '("z" "1") nil nil 'literal)))
 783   (should (equal   "1" (f '(""  "1") nil nil 'literal)))
 784   (should (equal  ""   (f '(""  "" ) nil nil 'literal))))
 785
 786 (ert-deftest test-org-table/org-table-make-reference/mode-string-none ()
 787   (fset 'f 'org-table-make-reference)
 788   ;; For Lisp formula
 789   (should (equal "\"0\""       (f   "0"         nil nil t)))
 790   (should (equal "\"z\""       (f   "z"         nil nil t)))
 791   (should (equal   ""          (f   ""          nil nil t)))
 792   (should (equal "\"0\" \"1\"" (f '("0"    "1") nil nil t)))
 793   (should (equal "\"z\" \"1\"" (f '("z"    "1") nil nil t)))
 794   (should (equal       "\"1\"" (f '(""     "1") nil nil t)))
 795   (should (equal      ""       (f '(""     "" ) nil nil t)))
 796   ;; For Calc formula
 797   (should (equal  "(0)"        (f   "0"         nil nil nil)))
 798   (should (equal  "(z)"        (f   "z"         nil nil nil)))
 799   (should (equal  "(0)"        (f   ""          nil nil nil)))
 800   (should (equal  "[0,1]"      (f '("0"    "1") nil nil nil)))
 801   (should (equal  "[z,1]"      (f '("z"    "1") nil nil nil)))
 802   (should (equal    "[1]"      (f '(""     "1") nil nil nil)))
 803   (should (equal   "[]"        (f '(""     "" ) nil nil nil)))
 804   ;; For Calc formula, special numbers
 805   (should (equal  "(nan)"      (f    "nan"      nil nil nil)))
 806   (should (equal "(uinf)"      (f   "uinf"      nil nil nil)))
 807   (should (equal "(-inf)"      (f   "-inf"      nil nil nil)))
 808   (should (equal  "(inf)"      (f    "inf"      nil nil nil)))
 809   (should (equal  "[nan,1]"    (f '( "nan" "1") nil nil nil)))
 810   (should (equal "[uinf,1]"    (f '("uinf" "1") nil nil nil)))
 811   (should (equal "[-inf,1]"    (f '("-inf" "1") nil nil nil)))
 812   (should (equal  "[inf,1]"    (f '( "inf" "1") nil nil nil))))
 813
 814 (ert-deftest test-org-table/org-table-make-reference/mode-string-N ()
 815   (fset 'f 'org-table-make-reference)
 816   ;; For Lisp formula
 817   (should (equal  "0"    (f   "0"         nil t t)))
 818   (should (equal  "0"    (f   "z"         nil t t)))
 819   (should (equal  ""     (f   ""          nil t t)))
 820   (should (equal  "0 1"  (f '("0"    "1") nil t t)))
 821   (should (equal  "0 1"  (f '("z"    "1") nil t t)))
 822   (should (equal    "1"  (f '(""     "1") nil t t)))
 823   (should (equal   ""    (f '(""     "" ) nil t t)))
 824   ;; For Calc formula
 825   (should (equal "(0)"   (f   "0"         nil t nil)))
 826   (should (equal "(0)"   (f   "z"         nil t nil)))
 827   (should (equal "(0)"   (f   ""          nil t nil)))
 828   (should (equal "[0,1]" (f '("0"    "1") nil t nil)))
 829   (should (equal "[0,1]" (f '("z"    "1") nil t nil)))
 830   (should (equal   "[1]" (f '(""     "1") nil t nil)))
 831   (should (equal  "[]"   (f '(""     "" ) nil t nil)))
 832   ;; For Calc formula, special numbers
 833   (should (equal "(0)"   (f    "nan"      nil t nil)))
 834   (should (equal "(0)"   (f   "uinf"      nil t nil)))
 835   (should (equal "(0)"   (f   "-inf"      nil t nil)))
 836   (should (equal "(0)"   (f    "inf"      nil t nil)))
 837   (should (equal "[0,1]" (f '( "nan" "1") nil t nil)))
 838   (should (equal "[0,1]" (f '("uinf" "1") nil t nil)))
 839   (should (equal "[0,1]" (f '("-inf" "1") nil t nil)))
 840   (should (equal "[0,1]" (f '( "inf" "1") nil t nil))))
 841
 842 (ert-deftest test-org-table/org-table-convert-refs-to-an/1 ()
 843   "Simple reference @1$1."
 844   (should
 845    (string= "A1" (org-table-convert-refs-to-an "@1$1"))))
 846
 847 ;; TODO: Test broken
 848 ;; (ert-deftest test-org-table/org-table-convert-refs-to-an/2 ()
 849 ;;   "Self reference @1$1."
 850 ;;   (should
 851 ;;    (string= "A1 = $0" (org-table-convert-refs-to-an "@1$1 = $0"))))
 852
 853 (ert-deftest test-org-table/org-table-convert-refs-to-an/3 ()
 854   "Remote reference."
 855   (should
 856    (string= "C& = remote(FOO, @@#B&)" (org-table-convert-refs-to-an "$3 = remote(FOO, @@#$2)"))))
 857
 858 (ert-deftest test-org-table/org-table-convert-refs-to-rc/1 ()
 859   "Simple reference @1$1."
 860   (should
 861    (string= "@1$1" (org-table-convert-refs-to-rc "A1"))))
 862
 863 (ert-deftest test-org-table/org-table-convert-refs-to-rc/2 ()
 864   "Self reference $0."
 865   (should
 866    (string= "@1$1 = $0" (org-table-convert-refs-to-rc "A1 = $0"))))
 867
 868 ;; TODO: Test Broken
 869 ;; (ert-deftest test-org-table/org-table-convert-refs-to-rc/3 ()
 870 ;;   "Remote reference."
 871 ;;   (should
 872 ;;    (string= "$3 = remote(FOO, @@#$2)" (org-table-convert-refs-to-rc "C& = remote(FOO, @@#B&)"))))
 873
 874 (ert-deftest test-org-table/remote-reference-access ()
 875   "Access to remote reference.
 876 See also `test-org-table/copy-field'."
 877   (org-test-table-target-expect
 878    "
 879 #+NAME: table
 880 |   | x   42 |   |
 881
 882 | replace | replace |
 883 "
 884    "
 885 #+NAME: table
 886 |   | x   42 |   |
 887
 888 | x   42 | 84 x |
 889 "
 890    1 (concat "#+TBLFM: "
 891              ;; Copy text without calculation: Use Lisp formula
 892              "$1 = '(identity remote(table, @1$2)) :: "
 893              ;; Do a calculation: Use Calc (or Lisp ) formula
 894              "$2 = 2 * remote(table, @1$2)")))
 895
 896 (ert-deftest test-org-table/remote-reference-indirect ()
 897   "Access to remote reference with indirection of name or ID."
 898   (let ((source-tables "
 899 #+NAME: 2012
 900 | amount |
 901 |--------|
 902 |      1 |
 903 |      2 |
 904 |--------|
 905 |      3 |
 906 #+TBLFM: @>$1 = vsum(@I..@II)
 907
 908 #+NAME: 2013
 909 | amount |
 910 |--------|
 911 |      4 |
 912 |      8 |
 913 |--------|
 914 |     12 |
 915 #+TBLFM: @>$1 = vsum(@I..@II)
 916 "))
 917
 918     ;; Read several remote references from same column
 919     (org-test-table-target-expect
 920      (concat source-tables "
 921 #+NAME: summary
 922 |  year | amount  |
 923 |-------+---------|
 924 |  2012 | replace |
 925 |  2013 | replace |
 926 |-------+---------|
 927 | total | replace |
 928 ")
 929      (concat source-tables "
 930 #+NAME: summary
 931 |  year | amount |
 932 |-------+--------|
 933 |  2012 |      3 |
 934 |  2013 |     12 |
 935 |-------+--------|
 936 | total |     15 |
 937 ")
 938      1
 939      ;; Calc formula
 940      "#+TBLFM: @<<$2..@>>$2 = remote($<, @>$1) :: @>$2 = vsum(@I..@II)"
 941      ;; Lisp formula
 942      (concat "#+TBLFM: @<<$2..@>>$2 = '(identity remote($<, @>$1)); N :: "
 943              "@>$2 = '(+ @I..@II); N"))
 944
 945     ;; Read several remote references from same row
 946     (org-test-table-target-expect
 947      (concat source-tables "
 948 #+NAME: summary
 949 | year   |    2012 |    2013 | total   |
 950 |--------+---------+---------+---------|
 951 | amount | replace | replace | replace |
 952 ")
 953      (concat source-tables "
 954 #+NAME: summary
 955 | year   | 2012 | 2013 | total |
 956 |--------+------+------+-------|
 957 | amount |    3 |   12 |    15 |
 958 ")
 959      1
 960      ;; Calc formula
 961      "#+TBLFM: @2$<<..@2$>> = remote(@<, @>$1) :: @2$> = vsum($<<..$>>)"
 962      ;; Lisp formula
 963      (concat "#+TBLFM: @2$<<..@2$>> = '(identity remote(@<, @>$1)); N :: "
 964              "@2$> = '(+ $<<..$>>); N"))))
 965
 966 (ert-deftest test-org-table/org-at-TBLFM-p ()
 967   (org-test-with-temp-text-in-file
 968       "
 969 | 1 |
 970 | 2 |
 971 #+TBLFM: $2=$1*2
 972
 973 "
 974     (goto-char (point-min))
 975     (forward-line 2)
 976     (should (equal (org-at-TBLFM-p) nil))
 977
 978     (goto-char (point-min))
 979     (forward-line 3)
 980     (should (equal (org-at-TBLFM-p) t))
 981
 982     (goto-char (point-min))
 983     (forward-line 4)
 984     (should (equal (org-at-TBLFM-p) nil))))
 985
 986 (ert-deftest test-org-table/org-table-TBLFM-begin ()
 987   (org-test-with-temp-text-in-file
 988       "
 989 | 1 |
 990 | 2 |
 991 #+TBLFM: $2=$1*2
 992
 993 "
 994     (goto-char (point-min))
 995     (should (equal (org-table-TBLFM-begin)
 996                    nil))
 997
 998     (goto-char (point-min))
 999     (forward-line 1)
1000     (should (equal (org-table-TBLFM-begin)
1001                    nil))
1002
1003     (goto-char (point-min))
1004     (forward-line 3)
1005     (should (= (org-table-TBLFM-begin)
1006                    14))
1007
1008     (goto-char (point-min))
1009     (forward-line 4)
1010     (should (= (org-table-TBLFM-begin)
1011                    14))
1012
1013     ))
1014
1015 (ert-deftest test-org-table/org-table-TBLFM-begin-for-multiple-TBLFM-lines ()
1016   "For multiple #+TBLFM lines."
1017   (org-test-with-temp-text-in-file
1018       "
1019 | 1 |
1020 | 2 |
1021 #+TBLFM: $2=$1*1
1022 #+TBLFM: $2=$1*2
1023
1024 "
1025     (goto-char (point-min))
1026     (should (equal (org-table-TBLFM-begin)
1027                    nil))
1028
1029     (goto-char (point-min))
1030     (forward-line 1)
1031     (should (equal (org-table-TBLFM-begin)
1032                    nil))
1033
1034     (goto-char (point-min))
1035     (forward-line 3)
1036     (should (= (org-table-TBLFM-begin)
1037                    14))
1038
1039     (goto-char (point-min))
1040     (forward-line 4)
1041     (should (= (org-table-TBLFM-begin)
1042                    14))
1043
1044     (goto-char (point-min))
1045     (forward-line 5)
1046     (should (= (org-table-TBLFM-begin)
1047                    14))
1048
1049     ))
1050
1051 (ert-deftest test-org-table/org-table-TBLFM-begin-for-pultiple-TBLFM-lines-blocks ()
1052   (org-test-with-temp-text-in-file
1053       "
1054 | 1 |
1055 | 2 |
1056 #+TBLFM: $2=$1*1
1057 #+TBLFM: $2=$1*2
1058
1059 | 6 |
1060 | 7 |
1061 #+TBLFM: $2=$1*1
1062 #+TBLFM: $2=$1*2
1063
1064 "
1065     (goto-char (point-min))
1066     (should (equal (org-table-TBLFM-begin)
1067                    nil))
1068
1069     (goto-char (point-min))
1070     (forward-line 1)
1071     (should (equal (org-table-TBLFM-begin)
1072                    nil))
1073
1074     (goto-char (point-min))
1075     (forward-line 3)
1076     (should (= (org-table-TBLFM-begin)
1077                    14))
1078
1079     (goto-char (point-min))
1080     (forward-line 4)
1081     (should (= (org-table-TBLFM-begin)
1082                    14))
1083
1084     (goto-char (point-min))
1085     (forward-line 5)
1086     (should (= (org-table-TBLFM-begin)
1087                    14))
1088
1089     (goto-char (point-min))
1090     (forward-line 6)
1091     (should (= (org-table-TBLFM-begin)
1092                    14))
1093
1094     (goto-char (point-min))
1095     (forward-line 8)
1096     (should (= (org-table-TBLFM-begin)
1097                    61))
1098
1099     (goto-char (point-min))
1100     (forward-line 9)
1101     (should (= (org-table-TBLFM-begin)
1102                    61))
1103
1104     (goto-char (point-min))
1105     (forward-line 10)
1106     (should (= (org-table-TBLFM-begin)
1107                    61))))
1108
1109 (ert-deftest test-org-table/org-table-calc-current-TBLFM ()
1110     (org-test-with-temp-text-in-file
1111       "
1112 | 1 |   |
1113 | 2 |   |
1114 #+TBLFM: $2=$1*1
1115 #+TBLFM: $2=$1*2
1116 #+TBLFM: $2=$1*3
1117 "
1118     (let ((got (progn (goto-char (point-min))
1119                       (forward-line 3)
1120                       (org-table-calc-current-TBLFM)
1121                       (buffer-string)))
1122           (expect "
1123 | 1 | 1 |
1124 | 2 | 2 |
1125 #+TBLFM: $2=$1*1
1126 #+TBLFM: $2=$1*2
1127 #+TBLFM: $2=$1*3
1128 "))
1129       (should (string= got
1130                        expect)))
1131
1132     (let ((got (progn (goto-char (point-min))
1133                       (forward-line 4)
1134                       (org-table-calc-current-TBLFM)
1135                       (buffer-string)))
1136           (expect "
1137 | 1 | 2 |
1138 | 2 | 4 |
1139 #+TBLFM: $2=$1*1
1140 #+TBLFM: $2=$1*2
1141 #+TBLFM: $2=$1*3
1142 "))
1143       (should (string= got
1144                        expect)))))
1145
1146 (ert-deftest test-org-table/org-table-calc-current-TBLFM-when-stop-because-of-error ()
1147   "org-table-calc-current-TBLFM should preserve the input as it was."
1148   (org-test-with-temp-text-in-file
1149       "
1150 | 1 | 1 |
1151 | 2 | 2 |
1152 #+TBLFM: $2=$1*1
1153 #+TBLFM: $2=$1*2::$2=$1*2
1154 #+TBLFM: $2=$1*3
1155 "
1156     (let ((expect "
1157 | 1 | 1 |
1158 | 2 | 2 |
1159 #+TBLFM: $2=$1*1
1160 #+TBLFM: $2=$1*2::$2=$1*2
1161 #+TBLFM: $2=$1*3
1162 "))
1163       (goto-char (point-min))
1164       (forward-line 4)
1165       (should-error (org-table-calc-current-TBLFM))
1166       (setq got (buffer-string))
1167       (message "%s" got)
1168       (should (string= got
1169                        expect)))))
1170
1171 (provide 'test-org-table)
1172
1173 ;;; test-org-table.el ends here