code.delx.au - gnu-emacs-elpa/blob - packages/hydra/hydra-test.el

   1 ;;; hydra-test.el --- Tests for Hydra
   2
   3 ;; Copyright (C) 2015  Free Software Foundation, Inc.
   4
   5 ;; Author: Oleh Krehel
   6
   7 ;; This file is part of GNU Emacs.
   8
   9 ;; GNU Emacs is free software: you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation, either version 3 of the License, or
  12 ;; (at your option) any later version.
  13
  14 ;; GNU Emacs is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  21
  22 ;;; Commentary:
  23 ;;
  24
  25 ;;; Code:
  26
  27 (require 'ert)
  28 (require 'hydra)
  29 (setq text-quoting-style 'grave)
  30 (message "Emacs version: %s" emacs-version)
  31
  32 (ert-deftest hydra-red-error ()
  33   (should
  34    (equal
  35     (macroexpand
  36      '(defhydra hydra-error (global-map "M-g")
  37        "error"
  38        ("h" first-error "first")
  39        ("j" next-error "next")
  40        ("k" previous-error "prev")
  41        ("SPC" hydra-repeat "rep" :bind nil)))
  42     '(progn
  43       (set
  44        (defvar hydra-error/keymap nil
  45          "Keymap for hydra-error.")
  46        (quote
  47         (keymap
  48          (32 . hydra-repeat)
  49          (107 . hydra-error/previous-error)
  50          (106 . hydra-error/next-error)
  51          (104 . hydra-error/first-error)
  52          (kp-subtract . hydra--negative-argument)
  53          (kp-9 . hydra--digit-argument)
  54          (kp-8 . hydra--digit-argument)
  55          (kp-7 . hydra--digit-argument)
  56          (kp-6 . hydra--digit-argument)
  57          (kp-5 . hydra--digit-argument)
  58          (kp-4 . hydra--digit-argument)
  59          (kp-3 . hydra--digit-argument)
  60          (kp-2 . hydra--digit-argument)
  61          (kp-1 . hydra--digit-argument)
  62          (kp-0 . hydra--digit-argument)
  63          (57 . hydra--digit-argument)
  64          (56 . hydra--digit-argument)
  65          (55 . hydra--digit-argument)
  66          (54 . hydra--digit-argument)
  67          (53 . hydra--digit-argument)
  68          (52 . hydra--digit-argument)
  69          (51 . hydra--digit-argument)
  70          (50 . hydra--digit-argument)
  71          (49 . hydra--digit-argument)
  72          (48 . hydra--digit-argument)
  73          (45 . hydra--negative-argument)
  74          (21 . hydra--universal-argument))))
  75       (set
  76        (defvar hydra-error/heads nil
  77          "Heads for hydra-error.")
  78        (quote
  79         (("h"
  80           first-error
  81           "first"
  82           :exit nil)
  83          ("j"
  84           next-error
  85           "next"
  86           :exit nil)
  87          ("k"
  88           previous-error
  89           "prev"
  90           :exit nil)
  91          ("SPC"
  92           hydra-repeat
  93           "rep"
  94           :bind nil
  95           :exit nil))))
  96       (set
  97        (defvar hydra-error/hint nil
  98          "Dynamic hint for hydra-error.")
  99        (quote
 100         (format
 101          #("error: [h]: first, [j]: next, [k]: prev, [SPC]: rep."
 102            8 9 (face hydra-face-red)
 103            20 21 (face hydra-face-red)
 104            31 32 (face hydra-face-red)
 105            42 45 (face hydra-face-red)))))
 106       (defun hydra-error/first-error nil
 107         "Create a hydra with a \"M-g\" body and the heads:
 108
 109 \"h\":    `first-error',
 110 \"j\":    `next-error',
 111 \"k\":    `previous-error',
 112 \"SPC\":    `hydra-repeat'
 113
 114 The body can be accessed via `hydra-error/body'.
 115
 116 Call the head: `first-error'."
 117         (interactive)
 118         (hydra-default-pre)
 119         (let ((hydra--ignore t))
 120           (hydra-keyboard-quit)
 121           (setq hydra-curr-body-fn
 122                 (quote hydra-error/body)))
 123         (condition-case err
 124                         (progn
 125                           (setq this-command
 126                                 (quote first-error))
 127                           (call-interactively
 128                            (function first-error)))
 129                         ((quit error)
 130                          (message "%S" err)
 131                          (unless hydra-lv (sit-for 0.8))))
 132         (when hydra-is-helpful
 133           (if hydra-lv
 134               (lv-message
 135                (eval hydra-error/hint))
 136             (message
 137              (eval hydra-error/hint))))
 138         (hydra-set-transient-map
 139          hydra-error/keymap
 140          (lambda nil
 141            (hydra-keyboard-quit)
 142            nil)
 143          nil))
 144       (defun hydra-error/next-error nil
 145         "Create a hydra with a \"M-g\" body and the heads:
 146
 147 \"h\":    `first-error',
 148 \"j\":    `next-error',
 149 \"k\":    `previous-error',
 150 \"SPC\":    `hydra-repeat'
 151
 152 The body can be accessed via `hydra-error/body'.
 153
 154 Call the head: `next-error'."
 155         (interactive)
 156         (hydra-default-pre)
 157         (let ((hydra--ignore t))
 158           (hydra-keyboard-quit)
 159           (setq hydra-curr-body-fn
 160                 (quote hydra-error/body)))
 161         (condition-case err
 162                         (progn
 163                           (setq this-command
 164                                 (quote next-error))
 165                           (call-interactively
 166                            (function next-error)))
 167                         ((quit error)
 168                          (message "%S" err)
 169                          (unless hydra-lv (sit-for 0.8))))
 170         (when hydra-is-helpful
 171           (if hydra-lv
 172               (lv-message
 173                (eval hydra-error/hint))
 174             (message
 175              (eval hydra-error/hint))))
 176         (hydra-set-transient-map
 177          hydra-error/keymap
 178          (lambda nil
 179            (hydra-keyboard-quit)
 180            nil)
 181          nil))
 182       (defun hydra-error/previous-error nil
 183         "Create a hydra with a \"M-g\" body and the heads:
 184
 185 \"h\":    `first-error',
 186 \"j\":    `next-error',
 187 \"k\":    `previous-error',
 188 \"SPC\":    `hydra-repeat'
 189
 190 The body can be accessed via `hydra-error/body'.
 191
 192 Call the head: `previous-error'."
 193         (interactive)
 194         (hydra-default-pre)
 195         (let ((hydra--ignore t))
 196           (hydra-keyboard-quit)
 197           (setq hydra-curr-body-fn
 198                 (quote hydra-error/body)))
 199         (condition-case err
 200                         (progn
 201                           (setq this-command
 202                                 (quote previous-error))
 203                           (call-interactively
 204                            (function previous-error)))
 205                         ((quit error)
 206                          (message "%S" err)
 207                          (unless hydra-lv (sit-for 0.8))))
 208         (when hydra-is-helpful
 209           (if hydra-lv
 210               (lv-message
 211                (eval hydra-error/hint))
 212             (message
 213              (eval hydra-error/hint))))
 214         (hydra-set-transient-map
 215          hydra-error/keymap
 216          (lambda nil
 217            (hydra-keyboard-quit)
 218            nil)
 219          nil))
 220       (unless (keymapp
 221                (lookup-key
 222                 global-map
 223                 (kbd "M-g")))
 224         (define-key global-map (kbd "M-g")
 225           nil))
 226       (define-key global-map [134217831 104]
 227         (quote hydra-error/first-error))
 228       (define-key global-map [134217831 106]
 229         (quote hydra-error/next-error))
 230       (define-key global-map [134217831 107]
 231         (quote
 232          hydra-error/previous-error))
 233       (defun hydra-error/body nil
 234         "Create a hydra with a \"M-g\" body and the heads:
 235
 236 \"h\":    `first-error',
 237 \"j\":    `next-error',
 238 \"k\":    `previous-error',
 239 \"SPC\":    `hydra-repeat'
 240
 241 The body can be accessed via `hydra-error/body'."
 242         (interactive)
 243         (hydra-default-pre)
 244         (let ((hydra--ignore nil))
 245           (hydra-keyboard-quit)
 246           (setq hydra-curr-body-fn
 247                 (quote hydra-error/body)))
 248         (when hydra-is-helpful
 249           (if hydra-lv
 250               (lv-message
 251                (eval hydra-error/hint))
 252             (message
 253              (eval hydra-error/hint))))
 254         (hydra-set-transient-map
 255          hydra-error/keymap
 256          (lambda nil
 257            (hydra-keyboard-quit)
 258            nil)
 259          nil)
 260         (setq prefix-arg
 261               current-prefix-arg))))))
 262
 263 (ert-deftest hydra-blue-toggle ()
 264   (should
 265    (equal
 266     (macroexpand
 267      '(defhydra hydra-toggle (:color blue)
 268        "toggle"
 269        ("t" toggle-truncate-lines "truncate")
 270        ("f" auto-fill-mode "fill")
 271        ("a" abbrev-mode "abbrev")
 272        ("q" nil "cancel")))
 273     '(progn
 274       (set
 275        (defvar hydra-toggle/keymap nil
 276          "Keymap for hydra-toggle.")
 277        (quote
 278         (keymap
 279          (113 . hydra-toggle/nil)
 280          (97 . hydra-toggle/abbrev-mode-and-exit)
 281          (102 . hydra-toggle/auto-fill-mode-and-exit)
 282          (116 . hydra-toggle/toggle-truncate-lines-and-exit)
 283          (kp-subtract . hydra--negative-argument)
 284          (kp-9 . hydra--digit-argument)
 285          (kp-8 . hydra--digit-argument)
 286          (kp-7 . hydra--digit-argument)
 287          (kp-6 . hydra--digit-argument)
 288          (kp-5 . hydra--digit-argument)
 289          (kp-4 . hydra--digit-argument)
 290          (kp-3 . hydra--digit-argument)
 291          (kp-2 . hydra--digit-argument)
 292          (kp-1 . hydra--digit-argument)
 293          (kp-0 . hydra--digit-argument)
 294          (57 . hydra--digit-argument)
 295          (56 . hydra--digit-argument)
 296          (55 . hydra--digit-argument)
 297          (54 . hydra--digit-argument)
 298          (53 . hydra--digit-argument)
 299          (52 . hydra--digit-argument)
 300          (51 . hydra--digit-argument)
 301          (50 . hydra--digit-argument)
 302          (49 . hydra--digit-argument)
 303          (48 . hydra--digit-argument)
 304          (45 . hydra--negative-argument)
 305          (21 . hydra--universal-argument))))
 306       (set
 307        (defvar hydra-toggle/heads nil
 308          "Heads for hydra-toggle.")
 309        (quote
 310         (("t"
 311           toggle-truncate-lines
 312           "truncate"
 313           :exit t)
 314          ("f"
 315           auto-fill-mode
 316           "fill"
 317           :exit t)
 318          ("a"
 319           abbrev-mode
 320           "abbrev"
 321           :exit t)
 322          ("q" nil "cancel" :exit t))))
 323       (set
 324        (defvar hydra-toggle/hint nil
 325          "Dynamic hint for hydra-toggle.")
 326        (quote
 327         (format
 328          #("toggle: [t]: truncate, [f]: fill, [a]: abbrev, [q]: cancel."
 329            9 10 (face hydra-face-blue)
 330            24 25 (face hydra-face-blue)
 331            35 36 (face hydra-face-blue)
 332            48 49 (face hydra-face-blue)))))
 333       (defun hydra-toggle/toggle-truncate-lines-and-exit nil
 334         "Create a hydra with no body and the heads:
 335
 336 \"t\":    `toggle-truncate-lines',
 337 \"f\":    `auto-fill-mode',
 338 \"a\":    `abbrev-mode',
 339 \"q\":    nil
 340
 341 The body can be accessed via `hydra-toggle/body'.
 342
 343 Call the head: `toggle-truncate-lines'."
 344         (interactive)
 345         (hydra-default-pre)
 346         (hydra-keyboard-quit)
 347         (setq hydra-curr-body-fn
 348               (quote hydra-toggle/body))
 349         (progn
 350           (setq this-command
 351                 (quote toggle-truncate-lines))
 352           (call-interactively
 353            (function
 354             toggle-truncate-lines))))
 355       (defun hydra-toggle/auto-fill-mode-and-exit nil
 356         "Create a hydra with no body and the heads:
 357
 358 \"t\":    `toggle-truncate-lines',
 359 \"f\":    `auto-fill-mode',
 360 \"a\":    `abbrev-mode',
 361 \"q\":    nil
 362
 363 The body can be accessed via `hydra-toggle/body'.
 364
 365 Call the head: `auto-fill-mode'."
 366         (interactive)
 367         (hydra-default-pre)
 368         (hydra-keyboard-quit)
 369         (setq hydra-curr-body-fn
 370               (quote hydra-toggle/body))
 371         (progn
 372           (setq this-command
 373                 (quote auto-fill-mode))
 374           (call-interactively
 375            (function auto-fill-mode))))
 376       (defun hydra-toggle/abbrev-mode-and-exit nil
 377         "Create a hydra with no body and the heads:
 378
 379 \"t\":    `toggle-truncate-lines',
 380 \"f\":    `auto-fill-mode',
 381 \"a\":    `abbrev-mode',
 382 \"q\":    nil
 383
 384 The body can be accessed via `hydra-toggle/body'.
 385
 386 Call the head: `abbrev-mode'."
 387         (interactive)
 388         (hydra-default-pre)
 389         (hydra-keyboard-quit)
 390         (setq hydra-curr-body-fn
 391               (quote hydra-toggle/body))
 392         (progn
 393           (setq this-command
 394                 (quote abbrev-mode))
 395           (call-interactively
 396            (function abbrev-mode))))
 397       (defun hydra-toggle/nil nil
 398         "Create a hydra with no body and the heads:
 399
 400 \"t\":    `toggle-truncate-lines',
 401 \"f\":    `auto-fill-mode',
 402 \"a\":    `abbrev-mode',
 403 \"q\":    nil
 404
 405 The body can be accessed via `hydra-toggle/body'.
 406
 407 Call the head: nil."
 408         (interactive)
 409         (hydra-default-pre)
 410         (hydra-keyboard-quit)
 411         (setq hydra-curr-body-fn
 412               (quote hydra-toggle/body)))
 413       (defun hydra-toggle/body nil
 414         "Create a hydra with no body and the heads:
 415
 416 \"t\":    `toggle-truncate-lines',
 417 \"f\":    `auto-fill-mode',
 418 \"a\":    `abbrev-mode',
 419 \"q\":    nil
 420
 421 The body can be accessed via `hydra-toggle/body'."
 422         (interactive)
 423         (hydra-default-pre)
 424         (let ((hydra--ignore nil))
 425           (hydra-keyboard-quit)
 426           (setq hydra-curr-body-fn
 427                 (quote hydra-toggle/body)))
 428         (when hydra-is-helpful
 429           (if hydra-lv
 430               (lv-message
 431                (eval hydra-toggle/hint))
 432             (message
 433              (eval hydra-toggle/hint))))
 434         (hydra-set-transient-map
 435          hydra-toggle/keymap
 436          (lambda nil
 437            (hydra-keyboard-quit)
 438            nil)
 439          nil)
 440         (setq prefix-arg
 441               current-prefix-arg))))))
 442
 443 (ert-deftest hydra-amaranth-vi ()
 444   (should
 445    (equal
 446     (macroexpand
 447      '(defhydra hydra-vi
 448        (:pre
 449         (set-cursor-color "#e52b50")
 450         :post
 451         (set-cursor-color "#ffffff")
 452         :color amaranth)
 453        "vi"
 454        ("j" next-line)
 455        ("k" previous-line)
 456        ("q" nil "quit")))
 457     '(progn
 458       (set
 459        (defvar hydra-vi/keymap nil
 460          "Keymap for hydra-vi.")
 461        (quote
 462         (keymap
 463          (113 . hydra-vi/nil)
 464          (107 . hydra-vi/previous-line)
 465          (106 . hydra-vi/next-line)
 466          (kp-subtract . hydra--negative-argument)
 467          (kp-9 . hydra--digit-argument)
 468          (kp-8 . hydra--digit-argument)
 469          (kp-7 . hydra--digit-argument)
 470          (kp-6 . hydra--digit-argument)
 471          (kp-5 . hydra--digit-argument)
 472          (kp-4 . hydra--digit-argument)
 473          (kp-3 . hydra--digit-argument)
 474          (kp-2 . hydra--digit-argument)
 475          (kp-1 . hydra--digit-argument)
 476          (kp-0 . hydra--digit-argument)
 477          (57 . hydra--digit-argument)
 478          (56 . hydra--digit-argument)
 479          (55 . hydra--digit-argument)
 480          (54 . hydra--digit-argument)
 481          (53 . hydra--digit-argument)
 482          (52 . hydra--digit-argument)
 483          (51 . hydra--digit-argument)
 484          (50 . hydra--digit-argument)
 485          (49 . hydra--digit-argument)
 486          (48 . hydra--digit-argument)
 487          (45 . hydra--negative-argument)
 488          (21 . hydra--universal-argument))))
 489       (set
 490        (defvar hydra-vi/heads nil
 491          "Heads for hydra-vi.")
 492        (quote
 493         (("j" next-line "" :exit nil)
 494          ("k"
 495           previous-line
 496           ""
 497           :exit nil)
 498          ("q" nil "quit" :exit t))))
 499       (set
 500        (defvar hydra-vi/hint nil
 501          "Dynamic hint for hydra-vi.")
 502        (quote
 503         (format
 504          #("vi: j, k, [q]: quit."
 505            4 5 (face hydra-face-amaranth)
 506            7 8 (face hydra-face-amaranth)
 507            11 12 (face hydra-face-teal)))))
 508       (defun hydra-vi/next-line nil
 509         "Create a hydra with no body and the heads:
 510
 511 \"j\":    `next-line',
 512 \"k\":    `previous-line',
 513 \"q\":    nil
 514
 515 The body can be accessed via `hydra-vi/body'.
 516
 517 Call the head: `next-line'."
 518         (interactive)
 519         (hydra-default-pre)
 520         (set-cursor-color "#e52b50")
 521         (let ((hydra--ignore t))
 522           (hydra-keyboard-quit)
 523           (setq hydra-curr-body-fn
 524                 (quote hydra-vi/body)))
 525         (condition-case err
 526             (progn
 527               (setq this-command
 528                     (quote next-line))
 529               (call-interactively
 530                (function next-line)))
 531           ((quit error)
 532            (message "%S" err)
 533            (unless hydra-lv (sit-for 0.8))))
 534         (when hydra-is-helpful
 535           (if hydra-lv
 536               (lv-message
 537                (eval hydra-vi/hint))
 538             (message (eval hydra-vi/hint))))
 539         (hydra-set-transient-map
 540          hydra-vi/keymap
 541          (lambda nil
 542            (hydra-keyboard-quit)
 543            (set-cursor-color "#ffffff"))
 544          (quote warn)))
 545       (defun hydra-vi/previous-line nil
 546         "Create a hydra with no body and the heads:
 547
 548 \"j\":    `next-line',
 549 \"k\":    `previous-line',
 550 \"q\":    nil
 551
 552 The body can be accessed via `hydra-vi/body'.
 553
 554 Call the head: `previous-line'."
 555         (interactive)
 556         (hydra-default-pre)
 557         (set-cursor-color "#e52b50")
 558         (let ((hydra--ignore t))
 559           (hydra-keyboard-quit)
 560           (setq hydra-curr-body-fn
 561                 (quote hydra-vi/body)))
 562         (condition-case err
 563             (progn
 564               (setq this-command
 565                     (quote previous-line))
 566               (call-interactively
 567                (function previous-line)))
 568           ((quit error)
 569            (message "%S" err)
 570            (unless hydra-lv (sit-for 0.8))))
 571         (when hydra-is-helpful
 572           (if hydra-lv
 573               (lv-message
 574                (eval hydra-vi/hint))
 575             (message (eval hydra-vi/hint))))
 576         (hydra-set-transient-map
 577          hydra-vi/keymap
 578          (lambda nil
 579            (hydra-keyboard-quit)
 580            (set-cursor-color "#ffffff"))
 581          (quote warn)))
 582       (defun hydra-vi/nil nil
 583         "Create a hydra with no body and the heads:
 584
 585 \"j\":    `next-line',
 586 \"k\":    `previous-line',
 587 \"q\":    nil
 588
 589 The body can be accessed via `hydra-vi/body'.
 590
 591 Call the head: nil."
 592         (interactive)
 593         (hydra-default-pre)
 594         (set-cursor-color "#e52b50")
 595         (hydra-keyboard-quit)
 596         (setq hydra-curr-body-fn
 597               (quote hydra-vi/body)))
 598       (defun hydra-vi/body nil
 599         "Create a hydra with no body and the heads:
 600
 601 \"j\":    `next-line',
 602 \"k\":    `previous-line',
 603 \"q\":    nil
 604
 605 The body can be accessed via `hydra-vi/body'."
 606         (interactive)
 607         (hydra-default-pre)
 608         (set-cursor-color "#e52b50")
 609         (let ((hydra--ignore nil))
 610           (hydra-keyboard-quit)
 611           (setq hydra-curr-body-fn
 612                 (quote hydra-vi/body)))
 613         (when hydra-is-helpful
 614           (if hydra-lv
 615               (lv-message
 616                (eval hydra-vi/hint))
 617             (message (eval hydra-vi/hint))))
 618         (hydra-set-transient-map
 619          hydra-vi/keymap
 620          (lambda nil
 621            (hydra-keyboard-quit)
 622            (set-cursor-color "#ffffff"))
 623          (quote warn))
 624         (setq prefix-arg
 625               current-prefix-arg))))))
 626
 627 (ert-deftest hydra-zoom-duplicate-1 ()
 628   (should
 629    (equal
 630     (macroexpand
 631      '(defhydra hydra-zoom ()
 632        "zoom"
 633        ("r" (text-scale-set 0) "reset")
 634        ("0" (text-scale-set 0) :bind nil :exit t)
 635        ("1" (text-scale-set 0) nil :bind nil :exit t)))
 636     '(progn
 637       (set
 638        (defvar hydra-zoom/keymap nil
 639          "Keymap for hydra-zoom.")
 640        (quote
 641         (keymap
 642          (114 . hydra-zoom/lambda-r)
 643          (kp-subtract . hydra--negative-argument)
 644          (kp-9 . hydra--digit-argument)
 645          (kp-8 . hydra--digit-argument)
 646          (kp-7 . hydra--digit-argument)
 647          (kp-6 . hydra--digit-argument)
 648          (kp-5 . hydra--digit-argument)
 649          (kp-4 . hydra--digit-argument)
 650          (kp-3 . hydra--digit-argument)
 651          (kp-2 . hydra--digit-argument)
 652          (kp-1 . hydra--digit-argument)
 653          (kp-0 . hydra--digit-argument)
 654          (57 . hydra--digit-argument)
 655          (56 . hydra--digit-argument)
 656          (55 . hydra--digit-argument)
 657          (54 . hydra--digit-argument)
 658          (53 . hydra--digit-argument)
 659          (52 . hydra--digit-argument)
 660          (51 . hydra--digit-argument)
 661          (50 . hydra--digit-argument)
 662          (49 . hydra-zoom/lambda-0-and-exit)
 663          (48 . hydra-zoom/lambda-0-and-exit)
 664          (45 . hydra--negative-argument)
 665          (21 . hydra--universal-argument))))
 666       (set
 667        (defvar hydra-zoom/heads nil
 668          "Heads for hydra-zoom.")
 669        (quote
 670         (("r"
 671           (text-scale-set 0)
 672           "reset"
 673           :exit nil)
 674          ("0"
 675           (text-scale-set 0)
 676           ""
 677           :bind nil
 678           :exit t)
 679          ("1"
 680           (text-scale-set 0)
 681           nil
 682           :bind nil
 683           :exit t))))
 684       (set
 685        (defvar hydra-zoom/hint nil
 686          "Dynamic hint for hydra-zoom.")
 687        (quote
 688         (format
 689          #("zoom: [r 0]: reset."
 690            7 8 (face hydra-face-red)
 691            9 10 (face hydra-face-blue)))))
 692       (defun hydra-zoom/lambda-r nil
 693         "Create a hydra with no body and the heads:
 694
 695 \"r\":    `(text-scale-set 0)',
 696 \"0\":    `(text-scale-set 0)',
 697 \"1\":    `(text-scale-set 0)'
 698
 699 The body can be accessed via `hydra-zoom/body'.
 700
 701 Call the head: `(text-scale-set 0)'."
 702         (interactive)
 703         (hydra-default-pre)
 704         (let ((hydra--ignore t))
 705           (hydra-keyboard-quit)
 706           (setq hydra-curr-body-fn
 707                 (quote hydra-zoom/body)))
 708         (condition-case err
 709             (call-interactively
 710              (function
 711               (lambda nil
 712                (interactive)
 713                (text-scale-set 0))))
 714           ((quit error)
 715            (message "%S" err)
 716            (unless hydra-lv (sit-for 0.8))))
 717         (when hydra-is-helpful
 718           (if hydra-lv
 719               (lv-message
 720                (eval hydra-zoom/hint))
 721             (message
 722              (eval hydra-zoom/hint))))
 723         (hydra-set-transient-map
 724          hydra-zoom/keymap
 725          (lambda nil
 726            (hydra-keyboard-quit)
 727            nil)
 728          nil))
 729       (defun hydra-zoom/lambda-0-and-exit nil
 730         "Create a hydra with no body and the heads:
 731
 732 \"r\":    `(text-scale-set 0)',
 733 \"0\":    `(text-scale-set 0)',
 734 \"1\":    `(text-scale-set 0)'
 735
 736 The body can be accessed via `hydra-zoom/body'.
 737
 738 Call the head: `(text-scale-set 0)'."
 739         (interactive)
 740         (hydra-default-pre)
 741         (hydra-keyboard-quit)
 742         (setq hydra-curr-body-fn
 743               (quote hydra-zoom/body))
 744         (call-interactively
 745          (function
 746           (lambda nil
 747            (interactive)
 748            (text-scale-set 0)))))
 749       (defun hydra-zoom/body nil
 750         "Create a hydra with no body and the heads:
 751
 752 \"r\":    `(text-scale-set 0)',
 753 \"0\":    `(text-scale-set 0)',
 754 \"1\":    `(text-scale-set 0)'
 755
 756 The body can be accessed via `hydra-zoom/body'."
 757         (interactive)
 758         (hydra-default-pre)
 759         (let ((hydra--ignore nil))
 760           (hydra-keyboard-quit)
 761           (setq hydra-curr-body-fn
 762                 (quote hydra-zoom/body)))
 763         (when hydra-is-helpful
 764           (if hydra-lv
 765               (lv-message
 766                (eval hydra-zoom/hint))
 767             (message
 768              (eval hydra-zoom/hint))))
 769         (hydra-set-transient-map
 770          hydra-zoom/keymap
 771          (lambda nil
 772            (hydra-keyboard-quit)
 773            nil)
 774          nil)
 775         (setq prefix-arg
 776               current-prefix-arg))))))
 777
 778 (ert-deftest hydra-zoom-duplicate-2 ()
 779   (should
 780    (equal
 781     (macroexpand
 782      '(defhydra hydra-zoom ()
 783        "zoom"
 784        ("r" (text-scale-set 0) "reset")
 785        ("0" (text-scale-set 0) :bind nil :exit t)
 786        ("1" (text-scale-set 0) nil :bind nil)))
 787     '(progn
 788       (set
 789        (defvar hydra-zoom/keymap nil
 790          "Keymap for hydra-zoom.")
 791        (quote
 792         (keymap
 793          (114 . hydra-zoom/lambda-r)
 794          (kp-subtract . hydra--negative-argument)
 795          (kp-9 . hydra--digit-argument)
 796          (kp-8 . hydra--digit-argument)
 797          (kp-7 . hydra--digit-argument)
 798          (kp-6 . hydra--digit-argument)
 799          (kp-5 . hydra--digit-argument)
 800          (kp-4 . hydra--digit-argument)
 801          (kp-3 . hydra--digit-argument)
 802          (kp-2 . hydra--digit-argument)
 803          (kp-1 . hydra--digit-argument)
 804          (kp-0 . hydra--digit-argument)
 805          (57 . hydra--digit-argument)
 806          (56 . hydra--digit-argument)
 807          (55 . hydra--digit-argument)
 808          (54 . hydra--digit-argument)
 809          (53 . hydra--digit-argument)
 810          (52 . hydra--digit-argument)
 811          (51 . hydra--digit-argument)
 812          (50 . hydra--digit-argument)
 813          (49 . hydra-zoom/lambda-r)
 814          (48 . hydra-zoom/lambda-0-and-exit)
 815          (45 . hydra--negative-argument)
 816          (21 . hydra--universal-argument))))
 817       (set
 818        (defvar hydra-zoom/heads nil
 819          "Heads for hydra-zoom.")
 820        (quote
 821         (("r"
 822           (text-scale-set 0)
 823           "reset"
 824           :exit nil)
 825          ("0"
 826           (text-scale-set 0)
 827           ""
 828           :bind nil
 829           :exit t)
 830          ("1"
 831           (text-scale-set 0)
 832           nil
 833           :bind nil
 834           :exit nil))))
 835       (set
 836        (defvar hydra-zoom/hint nil
 837          "Dynamic hint for hydra-zoom.")
 838        (quote
 839         (format
 840          #("zoom: [r 0]: reset."
 841            7 8 (face hydra-face-red)
 842            9 10 (face hydra-face-blue)))))
 843       (defun hydra-zoom/lambda-r nil
 844         "Create a hydra with no body and the heads:
 845
 846 \"r\":    `(text-scale-set 0)',
 847 \"0\":    `(text-scale-set 0)',
 848 \"1\":    `(text-scale-set 0)'
 849
 850 The body can be accessed via `hydra-zoom/body'.
 851
 852 Call the head: `(text-scale-set 0)'."
 853         (interactive)
 854         (hydra-default-pre)
 855         (let ((hydra--ignore t))
 856           (hydra-keyboard-quit)
 857           (setq hydra-curr-body-fn
 858                 (quote hydra-zoom/body)))
 859         (condition-case err
 860             (call-interactively
 861              (function
 862               (lambda nil
 863                (interactive)
 864                (text-scale-set 0))))
 865           ((quit error)
 866            (message "%S" err)
 867            (unless hydra-lv (sit-for 0.8))))
 868         (when hydra-is-helpful
 869           (if hydra-lv
 870               (lv-message
 871                (eval hydra-zoom/hint))
 872             (message
 873              (eval hydra-zoom/hint))))
 874         (hydra-set-transient-map
 875          hydra-zoom/keymap
 876          (lambda nil
 877            (hydra-keyboard-quit)
 878            nil)
 879          nil))
 880       (defun hydra-zoom/lambda-0-and-exit nil
 881         "Create a hydra with no body and the heads:
 882
 883 \"r\":    `(text-scale-set 0)',
 884 \"0\":    `(text-scale-set 0)',
 885 \"1\":    `(text-scale-set 0)'
 886
 887 The body can be accessed via `hydra-zoom/body'.
 888
 889 Call the head: `(text-scale-set 0)'."
 890         (interactive)
 891         (hydra-default-pre)
 892         (hydra-keyboard-quit)
 893         (setq hydra-curr-body-fn
 894               (quote hydra-zoom/body))
 895         (call-interactively
 896          (function
 897           (lambda nil
 898            (interactive)
 899            (text-scale-set 0)))))
 900       (defun hydra-zoom/body nil
 901         "Create a hydra with no body and the heads:
 902
 903 \"r\":    `(text-scale-set 0)',
 904 \"0\":    `(text-scale-set 0)',
 905 \"1\":    `(text-scale-set 0)'
 906
 907 The body can be accessed via `hydra-zoom/body'."
 908         (interactive)
 909         (hydra-default-pre)
 910         (let ((hydra--ignore nil))
 911           (hydra-keyboard-quit)
 912           (setq hydra-curr-body-fn
 913                 (quote hydra-zoom/body)))
 914         (when hydra-is-helpful
 915           (if hydra-lv
 916               (lv-message
 917                (eval hydra-zoom/hint))
 918             (message
 919              (eval hydra-zoom/hint))))
 920         (hydra-set-transient-map
 921          hydra-zoom/keymap
 922          (lambda nil
 923            (hydra-keyboard-quit)
 924            nil)
 925          nil)
 926         (setq prefix-arg
 927               current-prefix-arg))))))
 928
 929 (ert-deftest defhydradio ()
 930   (should (equal
 931            (macroexpand
 932             '(defhydradio hydra-test ()
 933               (num "Num" [0 1 2 3 4 5 6 7 8 9 10])
 934               (str "Str" ["foo" "bar" "baz"])))
 935            '(progn
 936              (defvar hydra-test/num 0
 937                "Num")
 938              (put 'hydra-test/num 'range [0 1 2 3 4 5 6 7 8 9 10])
 939              (defun hydra-test/num ()
 940                (hydra--cycle-radio 'hydra-test/num))
 941              (defvar hydra-test/str "foo"
 942                "Str")
 943              (put 'hydra-test/str 'range ["foo" "bar" "baz"])
 944              (defun hydra-test/str ()
 945                (hydra--cycle-radio 'hydra-test/str))
 946              (defvar hydra-test/names '(hydra-test/num hydra-test/str))))))
 947
 948 (ert-deftest hydra-blue-compat ()
 949   (should
 950    (equal
 951     (macroexpand
 952      '(defhydra hydra-toggle (:color blue)
 953        "toggle"
 954        ("t" toggle-truncate-lines "truncate")
 955        ("f" auto-fill-mode "fill")
 956        ("a" abbrev-mode "abbrev")
 957        ("q" nil "cancel")))
 958     (macroexpand
 959      '(defhydra hydra-toggle (:exit t)
 960        "toggle"
 961        ("t" toggle-truncate-lines "truncate")
 962        ("f" auto-fill-mode "fill")
 963        ("a" abbrev-mode "abbrev")
 964        ("q" nil "cancel"))))))
 965
 966 (ert-deftest hydra-amaranth-compat ()
 967   (should
 968    (equal
 969     (macroexpand
 970      '(defhydra hydra-vi
 971        (:pre
 972         (set-cursor-color "#e52b50")
 973         :post
 974         (set-cursor-color "#ffffff")
 975         :color amaranth)
 976        "vi"
 977        ("j" next-line)
 978        ("k" previous-line)
 979        ("q" nil "quit")))
 980     (macroexpand
 981      '(defhydra hydra-vi
 982        (:pre
 983         (set-cursor-color "#e52b50")
 984         :post
 985         (set-cursor-color "#ffffff")
 986         :foreign-keys warn)
 987        "vi"
 988        ("j" next-line)
 989        ("k" previous-line)
 990        ("q" nil "quit"))))))
 991
 992 (ert-deftest hydra-pink-compat ()
 993   (should
 994    (equal
 995     (macroexpand
 996      '(defhydra hydra-zoom (global-map "<f2>"
 997                             :color pink)
 998        "zoom"
 999        ("g" text-scale-increase "in")
1000        ("l" text-scale-decrease "out")
1001        ("q" nil "quit")))
1002     (macroexpand
1003      '(defhydra hydra-zoom (global-map "<f2>"
1004                             :foreign-keys run)
1005        "zoom"
1006        ("g" text-scale-increase "in")
1007        ("l" text-scale-decrease "out")
1008        ("q" nil "quit"))))))
1009
1010 (ert-deftest hydra-teal-compat ()
1011   (should
1012    (equal
1013     (macroexpand
1014      '(defhydra hydra-zoom (global-map "<f2>"
1015                             :color teal)
1016        "zoom"
1017        ("g" text-scale-increase "in")
1018        ("l" text-scale-decrease "out")
1019        ("q" nil "quit")))
1020     (macroexpand
1021      '(defhydra hydra-zoom (global-map "<f2>"
1022                             :foreign-keys warn
1023                             :exit t)
1024        "zoom"
1025        ("g" text-scale-increase "in")
1026        ("l" text-scale-decrease "out")
1027        ("q" nil "quit"))))))
1028
1029 (ert-deftest hydra-format-1 ()
1030   (should (equal
1031            (let ((hydra-fontify-head-function
1032                   'hydra-fontify-head-greyscale))
1033              (hydra--format
1034               'hydra-toggle
1035               nil
1036               "
1037 _a_ abbrev-mode:       %`abbrev-mode
1038 _d_ debug-on-error:    %`debug-on-error
1039 _f_ auto-fill-mode:    %`auto-fill-function
1040 " '(("a" abbrev-mode nil)
1041     ("d" toggle-debug-on-error nil)
1042     ("f" auto-fill-mode nil)
1043     ("g" golden-ratio-mode nil)
1044     ("t" toggle-truncate-lines nil)
1045     ("w" whitespace-mode nil)
1046     ("q" nil "quit"))))
1047            '(concat (format "%s abbrev-mode:       %S
1048 %s debug-on-error:    %S
1049 %s auto-fill-mode:    %S
1050 " "{a}" abbrev-mode "{d}" debug-on-error "{f}" auto-fill-function) "[{q}]: quit."))))
1051
1052 (ert-deftest hydra-format-2 ()
1053   (should (equal
1054            (let ((hydra-fontify-head-function
1055                   'hydra-fontify-head-greyscale))
1056              (hydra--format
1057               'bar
1058               nil
1059               "\n  bar %s`foo\n"
1060               '(("a" (quote t) "" :cmd-name bar/lambda-a :exit nil)
1061                 ("q" nil "" :cmd-name bar/nil :exit t))))
1062            '(concat (format "  bar %s\n" foo) "{a}, [q]."))))
1063
1064 (ert-deftest hydra-format-3 ()
1065   (should (equal
1066            (let ((hydra-fontify-head-function
1067                   'hydra-fontify-head-greyscale))
1068              (hydra--format
1069               'bar
1070               nil
1071               "\n_<SPC>_   ^^ace jump\n"
1072               '(("<SPC>" ace-jump-char-mode nil :cmd-name bar/ace-jump-char-mode))))
1073            '(concat (format "%s   ace jump\n" "{<SPC>}") ""))))
1074
1075 (ert-deftest hydra-format-4 ()
1076   (should
1077    (equal (hydra--format
1078            nil
1079            '(nil nil :hint nil)
1080            "\n_j_,_k_"
1081            '(("j" nil nil :exit t) ("k" nil nil :exit t)))
1082           '(concat (format "%s,%s"
1083                     #("j" 0 1 (face hydra-face-blue))
1084                     #("k" 0 1 (face hydra-face-blue))) ""))))
1085
1086 (ert-deftest hydra-format-5 ()
1087   (should
1088    (equal (hydra--format
1089            nil nil "\n_-_: mark          _u_: unmark\n"
1090            '(("-" Buffer-menu-mark)
1091              ("u" Buffer-menu-unmark)))
1092           '(concat
1093            (format
1094             "%s: mark          %s: unmark\n"
1095             #("-" 0 1 (face hydra-face-red))
1096             #("u" 0 1 (face hydra-face-red)))
1097             ""))))
1098
1099 (ert-deftest hydra-format-6 ()
1100   (should
1101    (equal (hydra--format
1102            nil nil "\n[_]_] forward [_[_] backward\n"
1103            '(("]" forward-char)
1104              ("[" backward-char)))
1105           '(concat
1106             (format
1107              "[%s] forward [%s] backward\n"
1108              #("]"
1109                0 1 (face
1110                     hydra-face-red))
1111              #("["
1112                0 1 (face
1113                     hydra-face-red)))
1114             ""))))
1115
1116 (ert-deftest hydra-format-7 ()
1117   (should
1118    (equal
1119     (hydra--format nil nil "test"
1120                    '(("%" forward-char "" :exit nil)
1121                      ("b" backward-char "" :exit nil)))
1122     '(format
1123       #("test: %%%%, b."
1124         6 7 (face hydra-face-red)
1125         7 8 (face hydra-face-red)
1126         8 9 (face hydra-face-red)
1127         9 10 (face hydra-face-red)
1128         12 13 (face hydra-face-red)))))
1129   (should
1130    (equal
1131     (hydra--format nil nil "\n_%_ forward\n"
1132                    '(("%" forward-char nil :exit nil)))
1133     '(concat
1134       (format
1135        "%s forward\n"
1136        #("%%"
1137          0 2 (face hydra-face-red)))
1138       ""))))
1139
1140 (ert-deftest hydra-format-with-sexp-1 ()
1141   (should (equal
1142            (let ((hydra-fontify-head-function
1143                   'hydra-fontify-head-greyscale))
1144              (hydra--format
1145               'hydra-toggle nil
1146               "\n_n_ narrow-or-widen-dwim %(progn (message \"checking\")(buffer-narrowed-p))asdf\n"
1147               '(("n" narrow-to-region nil) ("q" nil "cancel" :exit t))))
1148            '(concat (format "%s narrow-or-widen-dwim %Sasdf\n"
1149                      "{n}"
1150                      (progn
1151                        (message "checking")
1152                        (buffer-narrowed-p)))
1153              "[[q]]: cancel."))))
1154
1155 (ert-deftest hydra-format-with-sexp-2 ()
1156   (should (equal
1157            (let ((hydra-fontify-head-function
1158                   'hydra-fontify-head-greyscale))
1159              (hydra--format
1160               'hydra-toggle nil
1161               "\n_n_ narrow-or-widen-dwim %s(progn (message \"checking\")(buffer-narrowed-p))asdf\n"
1162               '(("n" narrow-to-region nil) ("q" nil "cancel" :exit t))))
1163            '(concat (format "%s narrow-or-widen-dwim %sasdf\n"
1164                      "{n}"
1165                      (progn
1166                        (message "checking")
1167                        (buffer-narrowed-p)))
1168              "[[q]]: cancel."))))
1169
1170 (ert-deftest hydra-compat-colors-2 ()
1171   (should
1172    (equal
1173     (macroexpand
1174      '(defhydra hydra-test (:color amaranth)
1175        ("a" fun-a)
1176        ("b" fun-b :color blue)
1177        ("c" fun-c :color blue)
1178        ("d" fun-d :color blue)
1179        ("e" fun-e :color blue)
1180        ("f" fun-f :color blue)))
1181     (macroexpand
1182      '(defhydra hydra-test (:color teal)
1183        ("a" fun-a :color red)
1184        ("b" fun-b)
1185        ("c" fun-c)
1186        ("d" fun-d)
1187        ("e" fun-e)
1188        ("f" fun-f))))))
1189
1190 (ert-deftest hydra-compat-colors-3 ()
1191   (should
1192    (equal
1193     (macroexpand
1194      '(defhydra hydra-test ()
1195        ("a" fun-a)
1196        ("b" fun-b :color blue)
1197        ("c" fun-c :color blue)
1198        ("d" fun-d :color blue)
1199        ("e" fun-e :color blue)
1200        ("f" fun-f :color blue)))
1201     (macroexpand
1202      '(defhydra hydra-test (:color blue)
1203        ("a" fun-a :color red)
1204        ("b" fun-b)
1205        ("c" fun-c)
1206        ("d" fun-d)
1207        ("e" fun-e)
1208        ("f" fun-f))))))
1209
1210 (ert-deftest hydra-compat-colors-4 ()
1211   (should
1212    (equal
1213     (macroexpand
1214      '(defhydra hydra-test ()
1215        ("a" fun-a)
1216        ("b" fun-b :exit t)
1217        ("c" fun-c :exit t)
1218        ("d" fun-d :exit t)
1219        ("e" fun-e :exit t)
1220        ("f" fun-f :exit t)))
1221     (macroexpand
1222      '(defhydra hydra-test (:exit t)
1223        ("a" fun-a :exit nil)
1224        ("b" fun-b)
1225        ("c" fun-c)
1226        ("d" fun-d)
1227        ("e" fun-e)
1228        ("f" fun-f))))))
1229
1230 (ert-deftest hydra--pad ()
1231   (should (equal (hydra--pad '(a b c) 3)
1232                  '(a b c)))
1233   (should (equal (hydra--pad '(a) 3)
1234                  '(a nil nil))))
1235
1236 (ert-deftest hydra--matrix ()
1237   (should (equal (hydra--matrix '(a b c) 2 2)
1238                  '((a b) (c nil))))
1239   (should (equal (hydra--matrix '(a b c d e f g h i) 4 3)
1240                  '((a b c d) (e f g h) (i nil nil nil)))))
1241
1242 (ert-deftest hydra--cell ()
1243   (should (equal (hydra--cell "% -75s %%`%s" '(hydra-lv hydra-verbose))
1244                  "When non-nil, `lv-message' (not `message') will be used to display hints.   %`hydra-lv^^^^^
1245 When non-nil, hydra will issue some non essential style warnings.           %`hydra-verbose")))
1246
1247 (ert-deftest hydra--vconcat ()
1248   (should (equal (hydra--vconcat '("abc\ndef" "012\n34" "def\nabc"))
1249                  "abc012def\ndef34abc")))
1250
1251 (defhydradio hydra-tng ()
1252   (picard "_p_ Captain Jean Luc Picard:")
1253   (riker "_r_ Commander William Riker:")
1254   (data "_d_ Lieutenant Commander Data:")
1255   (worf "_w_ Worf:")
1256   (la-forge "_f_ Geordi La Forge:")
1257   (troi "_t_ Deanna Troi:")
1258   (dr-crusher "_c_ Doctor Beverly Crusher:")
1259   (phaser "_h_ Set phasers to " [stun kill]))
1260
1261 (ert-deftest hydra--table ()
1262   (let ((hydra-cell-format "% -30s %% -8`%s"))
1263     (should (equal (hydra--table hydra-tng/names 5 2)
1264                    (substring "
1265 _p_ Captain Jean Luc Picard:   % -8`hydra-tng/picard^^    _t_ Deanna Troi:               % -8`hydra-tng/troi^^^^^^
1266 _r_ Commander William Riker:   % -8`hydra-tng/riker^^^    _c_ Doctor Beverly Crusher:    % -8`hydra-tng/dr-crusher
1267 _d_ Lieutenant Commander Data: % -8`hydra-tng/data^^^^    _h_ Set phasers to             % -8`hydra-tng/phaser^^^^
1268 _w_ Worf:                      % -8`hydra-tng/worf^^^^
1269 _f_ Geordi La Forge:           % -8`hydra-tng/la-forge" 1)))
1270     (should (equal (hydra--table hydra-tng/names 4 3)
1271                    (substring "
1272 _p_ Captain Jean Luc Picard:   % -8`hydra-tng/picard    _f_ Geordi La Forge:           % -8`hydra-tng/la-forge^^
1273 _r_ Commander William Riker:   % -8`hydra-tng/riker^    _t_ Deanna Troi:               % -8`hydra-tng/troi^^^^^^
1274 _d_ Lieutenant Commander Data: % -8`hydra-tng/data^^    _c_ Doctor Beverly Crusher:    % -8`hydra-tng/dr-crusher
1275 _w_ Worf:                      % -8`hydra-tng/worf^^    _h_ Set phasers to             % -8`hydra-tng/phaser^^^^" 1)))))
1276
1277 (ert-deftest hydra--make-funcall ()
1278   (should (equal (let ((body-pre 'foo))
1279                    (hydra--make-funcall body-pre)
1280                    body-pre)
1281                  '(funcall (function foo)))))
1282
1283 (defhydra hydra-simple-1 (global-map "C-c")
1284   ("a" (insert "j"))
1285   ("b" (insert "k"))
1286   ("q" nil))
1287
1288 (defhydra hydra-simple-2 (global-map "C-c" :color amaranth)
1289   ("c" self-insert-command)
1290   ("d" self-insert-command)
1291   ("q" nil))
1292
1293 (defhydra hydra-simple-3 (global-map "C-c")
1294   ("g" goto-line)
1295   ("1" find-file)
1296   ("q" nil))
1297
1298 (defmacro hydra-with (in &rest body)
1299   `(let ((temp-buffer (generate-new-buffer " *temp*")))
1300      (save-window-excursion
1301        (unwind-protect
1302             (progn
1303               (switch-to-buffer temp-buffer)
1304               (transient-mark-mode 1)
1305               (insert ,in)
1306               (goto-char (point-min))
1307               (when (search-forward "~" nil t)
1308                 (backward-delete-char 1)
1309                 (set-mark (point)))
1310               (goto-char (point-max))
1311               (search-backward "|")
1312               (delete-char 1)
1313               (setq current-prefix-arg nil)
1314               ,@body
1315               (insert "|")
1316               (when (region-active-p)
1317                 (exchange-point-and-mark)
1318                 (insert "~"))
1319               (buffer-substring-no-properties
1320                (point-min)
1321                (point-max)))
1322          (and (buffer-name temp-buffer)
1323               (kill-buffer temp-buffer))))))
1324
1325 (ert-deftest hydra-integration-1 ()
1326   (should (string= (hydra-with "|"
1327                                (execute-kbd-macro
1328                                 (kbd "C-c aabbaaqaabbaa")))
1329                    "jjkkjjaabbaa|"))
1330   (should (string= (hydra-with "|"
1331                                (condition-case nil
1332                                    (execute-kbd-macro
1333                                     (kbd "C-c aabb C-g"))
1334                                  (quit nil))
1335                                (execute-kbd-macro "aaqaabbaa"))
1336                    "jjkkaaqaabbaa|")))
1337
1338 (ert-deftest hydra-integration-2 ()
1339   (should (string= (hydra-with "|"
1340                                (execute-kbd-macro
1341                                 (kbd "C-c c 1 c 2 d 4 c q")))
1342                    "ccddcccc|"))
1343   (should (string= (hydra-with "|"
1344                                (execute-kbd-macro
1345                                 (kbd "C-c c 1 c C-u d C-u 10 c q")))
1346                    "ccddddcccccccccc|")))
1347
1348 (ert-deftest hydra-integration-3 ()
1349   (should (string= (hydra-with "foo\nbar|"
1350                                (execute-kbd-macro
1351                                 (kbd "C-c g 1 RET q")))
1352                    "|foo\nbar")))
1353
1354 (ert-deftest hydra-columns-1 ()
1355   (should (equal (eval
1356                   (cadr
1357                    (nth 2
1358                         (nth 3
1359                              (macroexpand
1360                               '(defhydra hydra-info (:color blue
1361                                                      :columns 3)
1362                                 "Info-mode"
1363                                 ("?" Info-summary "summary")
1364                                 ("]" Info-forward-node "forward")
1365                                 ("[" Info-backward-node "backward")
1366                                 ("<" Info-top-node "top node")
1367                                 (">" Info-final-node "final node")
1368                                 ("h" Info-help "help")
1369                                 ("d" Info-directory "info dir")
1370                                 ("f" Info-follow-reference "follow ref")
1371                                 ("g" Info-goto-node "goto node")
1372                                 ("l" Info-history-back "hist back")
1373                                 ("r" Info-history-forward "hist forward")
1374                                 ("i" Info-index "index")
1375                                 ("I" Info-virtual-index "virtual index")
1376                                 ("L" Info-history "hist")
1377                                 ("n" Info-next "next")
1378                                 ("p" Info-prev "previous")
1379                                 ("s" Info-search "search")
1380                                 ("S" Info-search-case-sensitively "case-search")
1381                                 ("T" Info-toc "TOC")
1382                                 ("u" Info-up "up")
1383                                 ("m" Info-menu "menu")
1384                                 ("t" hydra-info-to/body "info-to")))))))
1385                  #("Info-mode:
1386 ?: summary       ]: forward       [: backward
1387 <: top node      >: final node    h: help
1388 d: info dir      f: follow ref    g: goto node
1389 l: hist back     r: hist forward  i: index
1390 I: virtual index L: hist          n: next
1391 p: previous      s: search        S: case-search
1392 T: TOC           u: up            m: menu
1393 t: info-to"
1394                    11 12 (face hydra-face-blue)
1395                    28 29 (face hydra-face-blue)
1396                    45 46 (face hydra-face-blue)
1397                    57 58 (face hydra-face-blue)
1398                    74 75 (face hydra-face-blue)
1399                    91 92 (face hydra-face-blue)
1400                    99 100 (face hydra-face-blue)
1401                    116 117 (face hydra-face-blue)
1402                    133 134 (face hydra-face-blue)
1403                    146 147 (face hydra-face-blue)
1404                    163 164 (face hydra-face-blue)
1405                    180 181 (face hydra-face-blue)
1406                    189 190 (face hydra-face-blue)
1407                    206 207 (face hydra-face-blue)
1408                    223 224 (face hydra-face-blue)
1409                    231 232 (face hydra-face-blue)
1410                    248 249 (face hydra-face-blue)
1411                    265 266 (face hydra-face-blue)
1412                    280 281 (face hydra-face-blue)
1413                    297 298 (face hydra-face-blue)
1414                    314 315 (face hydra-face-blue)
1415                    322 323 (face hydra-face-blue)))))
1416
1417 (provide 'hydra-test)
1418
1419 ;;; hydra-test.el ends here