patch 7.4.1000

Problem:    Test 49 is slow and doesn't work on MS-Windows.
Solution:   Start moving parts of test 49 to test_viml.

diff --git a/src/Makefile b/src/Makefile
index 4096e556ebc874bdbc0fd9e14cc777877b924152..522678cd6df4d366f0fc8f0a7f0aa553a65aef43 100644 (file)
--- a/src/Makefile
+++ b/src/Makefile
@@ -1976,12 +1976,19 @@ test_assert \
        test_searchpos \
        test_sort \
        test_undolevels \
+       test_viml \
        test_alot:
        cd testdir; rm -f $@.res test.log messages; $(MAKE) -f Makefile $@.res VIMPROG=../$(VIMTARGET) $(GUI_TESTARG) SCRIPTSOURCE=../$(SCRIPTSOURCE)
+       @if test -f testdir/test.log; then \
+               cat testdir/test.log; \
+       fi
        cat testdir/messages
 
 newtests:
        cd testdir; rm -f $@.res test.log messages; $(MAKE) -f Makefile newtests VIMPROG=../$(VIMTARGET) $(GUI_TESTARG) SCRIPTSOURCE=../$(SCRIPTSOURCE)
+       @if test -f testdir/test.log; then \
+               cat testdir/test.log; \
+       fi
        cat testdir/messages
 
 testclean:

diff --git a/src/testdir/runtest.vim b/src/testdir/runtest.vim
index 8314a45d0c6fabdaed4b66211ab6daa827994496..b43274c597705eb4287748b4003122d033b49f21 100644 (file)
--- a/src/testdir/runtest.vim
+++ b/src/testdir/runtest.vim
@@ -33,6 +33,16 @@ if &lines < 24 || &columns < 80
   cquit
 endif
 
+" For consistency run all tests with 'nocompatible' set.
+" This also enables use of line continuation.
+set nocp viminfo+=nviminfo
+
+" Avoid stopping at the "hit enter" prompt
+set nomore
+
+" Output all messages in English.
+lang mess C
+
 " Source the test script.  First grab the file name, in case the script
 " navigates away.
 let testname = expand('%')

diff --git a/src/testdir/test49.ok b/src/testdir/test49.ok
index bf1ceed9afb8e8b51de10bce8d759275cd901d04..9c3e62638339d894498ede55a17b3bb88dd9bb30 100644 (file)
--- a/src/testdir/test49.ok
+++ b/src/testdir/test49.ok
@@ -1,10 +1,4 @@
 Results of test49.vim:
-*** Test   1: OK (34695)
-*** Test   2: OK (34695)
-*** Test   3: OK (1384648195)
-*** Test   4: OK (32883)
-*** Test   5: OK (32883)
-*** Test   6: OK (603978947)
 *** Test   7: OK (90563)
 *** Test   8: OK (562493431)
 *** Test   9: OK (363)

diff --git a/src/testdir/test49.vim b/src/testdir/test49.vim
index 50c17952a7c45def6280eb4ee52ce7a9e4eb56e8..df2f3c99423065856d6903fdd7710374f3249553 100644 (file)
--- a/src/testdir/test49.vim
+++ b/src/testdir/test49.vim
@@ -1,6 +1,6 @@
 " Vim script language tests
 " Author:      Servatius Brandt <Servatius.Brandt@fujitsu-siemens.com>
-" Last Change: 2015 Sep 25
+" Last Change: 2015 Dec 30
 
 "-------------------------------------------------------------------------------
 " Test environment                                                         {{{1
@@ -608,355 +608,8 @@ com! -nargs=1 -bar ExecAsScript call ExecAsScript(<f-args>)
 " END_OF_TEST_ENVIRONMENT - do not change or remove this line.
 
 
-"-------------------------------------------------------------------------------
-" Test 1:   :endwhile in function                                          {{{1
-"
-"          Detect if a broken loop is (incorrectly) reactivated by the
-"          :endwhile.  Use a :return to prevent an endless loop, and make
-"          this test first to get a meaningful result on an error before other
-"          tests will hang.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-function! F()
-    Xpath 1                                    " X: 1
-    let first = 1
-    XloopINIT 2 8
-    while 1
-       Xloop 1                                 " X: 2      + 0 * 16
-       if first
-           Xloop 2                             " X: 4      + 0 * 32
-           let first = 0
-           XloopNEXT
-           break
-       else
-           Xloop 4                             " X: 0      + 0 * 64
-           return
-       endif
-    endwhile
-endfunction
-
-call F()
-Xpath 128                                      " X: 128
-
-function! G()
-    Xpath 256                                  " X: 256    + 0 * 2048
-    let first = 1
-    XloopINIT 512 8
-    while 1
-       Xloop 1                                 " X: 512    + 0 * 4096
-       if first
-           Xloop 2                             " X: 1024   + 0 * 8192
-           let first = 0
-           XloopNEXT
-           break
-       else
-           Xloop 4                             " X: 0      + 0 * 16384
-           return
-       endif
-       if 1    " unmatched :if
-    endwhile
-endfunction
-
-call G()
-Xpath 32768                                    " X: 32768
-
-Xcheck 34695
-
-" Leave F and G for execution as scripts in the next test.
-
-
-"-------------------------------------------------------------------------------
-" Test 2:   :endwhile in script                                                    {{{1
-"
-"          Detect if a broken loop is (incorrectly) reactivated by the
-"          :endwhile.  Use a :finish to prevent an endless loop, and place
-"          this test before others that might hang to get a meaningful result
-"          on an error.
-"
-"          This test executes the bodies of the functions F and G from the
-"          previous test as script files (:return replaced by :finish).
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-ExecAsScript F                                 " X: 1 + 2 + 4
-Xpath 128                                      " X: 128
-
-ExecAsScript G                                 " X: 256 + 512 + 1024
-Xpath 32768                                    " X: 32768
-
-unlet first
-delfunction F
-delfunction G
-
-Xcheck 34695
-
-
-"-------------------------------------------------------------------------------
-" Test 3:   :if, :elseif, :while, :continue, :break                        {{{1
-"-------------------------------------------------------------------------------
-
-XpathINIT
-if 1
-    Xpath 1                                    " X: 1
-    let loops = 3
-    XloopINIT 2 512
-    while loops > -1       " main loop: loops == 3, 2, 1 (which breaks)
-       if loops <= 0
-           let break_err = 1
-           let loops = -1
-       else                                    "    3:  2:      1:
-           Xloop 1                             " X: 2 + 2*512 + 2*512*512
-       endif
-       if (loops == 2)
-           while loops == 2 " dummy loop
-               Xloop 2                         " X:     4*512
-               let loops = loops - 1
-               continue    " stop dummy loop
-               Xloop 4                         " X:     0
-           endwhile
-           XloopNEXT
-           continue        " continue main loop
-           Xloop 8                             " X:     0
-       elseif (loops == 1)
-           let p = 1
-           while p         " dummy loop
-               Xloop 16                        " X:             32*512*512
-               let p = 0
-               break       " break dummy loop
-               Xloop 32                        " X:             0
-           endwhile
-           Xloop 64                            " X:             128*512*512
-           unlet p
-           break           " break main loop
-           Xloop 128                           " X:             0
-       endif
-       if (loops > 0)
-           Xloop 256                           " X: 512
-       endif
-       while loops == 3    " dummy loop
-           let loops = loops - 1
-       endwhile            " end dummy loop
-       XloopNEXT
-    endwhile               " end main loop
-    Xpath 268435456                            " X: 1024*512*512
-else
-    Xpath 536870912                            " X: 0
-endif
-Xpath 1073741824                               " X: 4096*512*512
-if exists("break_err")
-    " The Xpath command does not accept 2^31 (negative); add explicitly:
-    let Xpath = Xpath + 2147483648             " X: 0
-    unlet break_err
-endif
-
-unlet loops
-
-Xcheck 1384648195
-
-
-"-------------------------------------------------------------------------------
-" Test 4:   :return                                                        {{{1
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-function! F()
-    if 1
-       Xpath 1                                 " X: 1
-       let loops = 3
-       XloopINIT 2 16
-       while loops > 0                         "    3:  2:     1:
-           Xloop 1                             " X: 2 + 2*16 + 0*16*16
-           if (loops == 2)
-               Xloop 2                         " X:     4*16
-               return
-               Xloop 4                         " X:     0
-           endif
-           Xloop 8                             " X: 16
-           let loops = loops - 1
-           XloopNEXT
-       endwhile
-       Xpath 8192                              " X: 0
-    else
-       Xpath 16384                             " X: 0
-    endif
-endfunction
-
-call F()
-Xpath 32768                                    " X: 8*16*16*16
-
-Xcheck 32883
-
-" Leave F for execution as a script in the next test.
-
-
-"-------------------------------------------------------------------------------
-" Test 5:   :finish                                                        {{{1
-"
-"          This test executes the body of the function F from the previous test
-"          as a script file (:return replaced by :finish).
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-ExecAsScript F                                 " X: 1 + 2 + 2*16 + 4*16 + 16
-Xpath 32768                                    " X: 32768
-
-unlet loops
-delfunction F
-
-Xcheck 32883
-
-
-"-------------------------------------------------------------------------------
-" Test 6:   Defining functions in :while loops                             {{{1
-"
-"           Functions can be defined inside other functions.  An inner function
-"           gets defined when the outer function is executed.  Functions may
-"           also be defined inside while loops.  Expressions in braces for
-"           defining the function name are allowed.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-if ExtraVim()
-
-    " The command CALL collects the argument of all its invocations in "calls"
-    " when used from a function (that is, when the global variable "calls" needs
-    " the "g:" prefix).  This is to check that the function code is skipped when
-    " the function is defined.  For inner functions, do so only if the outer
-    " function is not being executed.
-    "
-    let calls = ""
-    com! -nargs=1 CALL
-               \ if !exists("calls") && !exists("outer") |
-               \ let g:calls = g:calls . <args> |
-               \ endif
-
-
-    XloopINIT! 1 16
-
-    let i = 0
-    while i < 3
-
-       XloopNEXT
-       let i = i + 1
-
-       if i == 1
-           Xloop 1                             " X: 1
-           function! F1(arg)
-               CALL a:arg
-               let outer = 1
-
-               XloopINIT! 4096 4
-               let j = 0
-               while j < 1
-                   XloopNEXT
-                   Xloop 1                     " X: 4096
-                   let j = j + 1
-                   function! G1(arg)
-                       CALL a:arg
-                   endfunction
-                   Xloop 2                     " X: 8192
-               endwhile
-           endfunction
-           Xloop 2                             " X: 2
-
-           continue
-       endif
-
-       Xloop 4                                 " X: 4 * (16 + 256)
-       function! F{i}(i, arg)
-           CALL a:arg
-           let outer = 1
-
-           XloopINIT! 16384 4
-           if a:i == 3
-               XloopNEXT
-               XloopNEXT
-               XloopNEXT
-           endif
-           let k = 0
-           while k < 3
-               XloopNEXT
-               Xloop 1                         " X: 16384*(1+4+16+64+256+1024)
-               let k = k + 1
-               function! G{a:i}{k}(arg)
-                   CALL a:arg
-               endfunction
-               Xloop 2                         " X: 32768*(1+4+16+64+256+1024)
-           endwhile
-       endfunction
-       Xloop 8                                 " X: 8 * (16 + 256)
-
-    endwhile
-
-    if exists("*G1")
-       Xpath 67108864                          " X: 0
-    endif
-    if exists("*F1")
-       call F1("F1")
-       if exists("*G1")
-           call G1("G1")
-       endif
-    endif
-
-    if exists("G21") || exists("G21") || exists("G21")
-       Xpath 134217728                         " X: 0
-    endif
-    if exists("*F2")
-       call F2(2, "F2")
-       if exists("*G21")
-           call G21("G21")
-       endif
-       if exists("*G22")
-           call G22("G22")
-       endif
-       if exists("*G23")
-           call G23("G23")
-       endif
-    endif
-
-    if exists("G31") || exists("G31") || exists("G31")
-       Xpath 268435456                         " X: 0
-    endif
-    if exists("*F3")
-       call F3(3, "F3")
-       if exists("*G31")
-           call G31("G31")
-       endif
-       if exists("*G32")
-           call G32("G32")
-       endif
-       if exists("*G33")
-           call G33("G33")
-       endif
-    endif
-
-    Xpath 536870912                            " X: 536870912
-
-    if calls != "F1G1F2G21G22G23F3G31G32G33"
-       Xpath 1073741824                        " X: 0
-       Xout "calls is" calls
-    endif
-
-    delfunction F1
-    delfunction G1
-    delfunction F2
-    delfunction G21
-    delfunction G22
-    delfunction G23
-    delfunction G31
-    delfunction G32
-    delfunction G33
-
-endif
-
-Xcheck 603978947
-
+" Tests 1 to 6 were moved to test_viml.vim
+let Xtest = 7
 
 "-------------------------------------------------------------------------------
 " Test 7:   Continuing on errors outside functions                         {{{1

diff --git a/src/version.c b/src/version.c
index 4216cfdc1658d94e87616b480341e596424b0caf..7b2f0aed45e2ed64f06bac0d24d0aeb39f25e2e8 100644 (file)
--- a/src/version.c
+++ b/src/version.c
@@ -741,6 +741,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    1000,
 /**/
     999,
 /**/