tests: glob whitespace between path and OK in unzip(1) output

FreeBSD's unzip(1) uses tabs instead of a run of spaces.

tests/test-archive.t

@@ -1,371 +1,371 b''
 #require serve
 
   $ hg init test
   $ cd test
   $ echo foo>foo
   $ hg commit -Am 1 -d '1 0'
   adding foo
   $ echo bar>bar
   $ hg commit -Am 2 -d '2 0'
   adding bar
   $ mkdir baz
   $ echo bletch>baz/bletch
   $ hg commit -Am 3 -d '1000000000 0'
   adding baz/bletch
   $ hg init subrepo
   $ touch subrepo/sub
   $ hg -q -R subrepo ci -Am "init subrepo"
   $ echo "subrepo = subrepo" > .hgsub
   $ hg add .hgsub
   $ hg ci -m "add subrepo"
   $ echo "[web]" >> .hg/hgrc
   $ echo "name = test-archive" >> .hg/hgrc
   $ echo "archivesubrepos = True" >> .hg/hgrc
   $ cp .hg/hgrc .hg/hgrc-base
   > test_archtype() {
   >     echo "allow_archive = $1" >> .hg/hgrc
   >     hg serve -p $HGPORT -d --pid-file=hg.pid -E errors.log
   >     cat hg.pid >> $DAEMON_PIDS
   >     echo % $1 allowed should give 200
   >     get-with-headers.py localhost:$HGPORT "archive/tip.$2" | head -n 1
   >     echo % $3 and $4 disallowed should both give 403
   >     get-with-headers.py localhost:$HGPORT "archive/tip.$3" | head -n 1
   >     get-with-headers.py localhost:$HGPORT "archive/tip.$4" | head -n 1
   >     killdaemons.py
   >     cat errors.log
   >     cp .hg/hgrc-base .hg/hgrc
   > }
 
 check http return codes
 
   $ test_archtype gz tar.gz tar.bz2 zip
   % gz allowed should give 200
   200 Script output follows
   % tar.bz2 and zip disallowed should both give 403
   403 Archive type not allowed: bz2
   403 Archive type not allowed: zip
   $ test_archtype bz2 tar.bz2 zip tar.gz
   % bz2 allowed should give 200
   200 Script output follows
   % zip and tar.gz disallowed should both give 403
   403 Archive type not allowed: zip
   403 Archive type not allowed: gz
   $ test_archtype zip zip tar.gz tar.bz2
   % zip allowed should give 200
   200 Script output follows
   % tar.gz and tar.bz2 disallowed should both give 403
   403 Archive type not allowed: gz
   403 Archive type not allowed: bz2
 
   $ echo "allow_archive = gz bz2 zip" >> .hg/hgrc
   $ hg serve -p $HGPORT -d --pid-file=hg.pid -E errors.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 invalid arch type should give 404
 
   $ get-with-headers.py localhost:$HGPORT "archive/tip.invalid" | head -n 1
   404 Unsupported archive type: None
 
   $ TIP=`hg id -v | cut -f1 -d' '`
   $ QTIP=`hg id -q`
   $ cat > getarchive.py <<EOF
   > from __future__ import absolute_import
   > import os
   > import sys
   > from mercurial import (
   >     util,
   > )
   > try:
   >     # Set stdout to binary mode for win32 platforms
   >     import msvcrt
   >     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
   > except ImportError:
   >     pass
   > if len(sys.argv) <= 3:
   >     node, archive = sys.argv[1:]
   >     requeststr = 'cmd=archive;node=%s;type=%s' % (node, archive)
   > else:
   >     node, archive, file = sys.argv[1:]
   >     requeststr = 'cmd=archive;node=%s;type=%s;file=%s' % (node, archive, file)
   > try:
   >     stdout = sys.stdout.buffer
   > except AttributeError:
   >     stdout = sys.stdout
   > try:
   >     f = util.urlreq.urlopen('http://127.0.0.1:%s/?%s'
   >                     % (os.environ['HGPORT'], requeststr))
   >     stdout.write(f.read())
   > except util.urlerr.httperror as e:
   >     sys.stderr.write(str(e) + '\n')
   > EOF
   $ python getarchive.py "$TIP" gz | gunzip | tar tf - 2>/dev/null
   test-archive-1701ef1f1510/.hg_archival.txt
   test-archive-1701ef1f1510/.hgsub
   test-archive-1701ef1f1510/.hgsubstate
   test-archive-1701ef1f1510/bar
   test-archive-1701ef1f1510/baz/bletch
   test-archive-1701ef1f1510/foo
   test-archive-1701ef1f1510/subrepo/sub
   $ python getarchive.py "$TIP" bz2 | bunzip2 | tar tf - 2>/dev/null
   test-archive-1701ef1f1510/.hg_archival.txt
   test-archive-1701ef1f1510/.hgsub
   test-archive-1701ef1f1510/.hgsubstate
   test-archive-1701ef1f1510/bar
   test-archive-1701ef1f1510/baz/bletch
   test-archive-1701ef1f1510/foo
   test-archive-1701ef1f1510/subrepo/sub
   $ python getarchive.py "$TIP" zip > archive.zip
   $ unzip -t archive.zip
   Archive:  archive.zip
-      testing: test-archive-1701ef1f1510/.hg_archival.txt   OK
-      testing: test-archive-1701ef1f1510/.hgsub   OK
-      testing: test-archive-1701ef1f1510/.hgsubstate   OK
-      testing: test-archive-1701ef1f1510/bar   OK
-      testing: test-archive-1701ef1f1510/baz/bletch   OK
-      testing: test-archive-1701ef1f1510/foo   OK
-      testing: test-archive-1701ef1f1510/subrepo/sub   OK
+      testing: test-archive-1701ef1f1510/.hg_archival.txt*OK (glob)
+      testing: test-archive-1701ef1f1510/.hgsub*OK (glob)
+      testing: test-archive-1701ef1f1510/.hgsubstate*OK (glob)
+      testing: test-archive-1701ef1f1510/bar*OK (glob)
+      testing: test-archive-1701ef1f1510/baz/bletch*OK (glob)
+      testing: test-archive-1701ef1f1510/foo*OK (glob)
+      testing: test-archive-1701ef1f1510/subrepo/sub*OK (glob)
   No errors detected in compressed data of archive.zip.
 
 test that we can download single directories and files
 
   $ python getarchive.py "$TIP" gz baz | gunzip | tar tf - 2>/dev/null
   test-archive-1701ef1f1510/baz/bletch
   $ python getarchive.py "$TIP" gz foo | gunzip | tar tf - 2>/dev/null
   test-archive-1701ef1f1510/foo
 
 test that we detect file patterns that match no files
 
   $ python getarchive.py "$TIP" gz foobar
   HTTP Error 404: file(s) not found: foobar
 
 test that we reject unsafe patterns
 
   $ python getarchive.py "$TIP" gz relre:baz
   HTTP Error 404: file(s) not found: relre:baz
 
   $ killdaemons.py
 
   $ hg archive -t tar test.tar
   $ tar tf test.tar
   test/.hg_archival.txt
   test/.hgsub
   test/.hgsubstate
   test/bar
   test/baz/bletch
   test/foo
 
   $ hg archive --debug -t tbz2 -X baz test.tar.bz2 --config progress.debug=true
   archiving: 0/4 files (0.00%)
   archiving: .hgsub 1/4 files (25.00%)
   archiving: .hgsubstate 2/4 files (50.00%)
   archiving: bar 3/4 files (75.00%)
   archiving: foo 4/4 files (100.00%)
   $ bunzip2 -dc test.tar.bz2 | tar tf - 2>/dev/null
   test/.hg_archival.txt
   test/.hgsub
   test/.hgsubstate
   test/bar
   test/foo
 
   $ hg archive -t tgz -p %b-%h test-%h.tar.gz
   $ gzip -dc test-$QTIP.tar.gz | tar tf - 2>/dev/null
   test-1701ef1f1510/.hg_archival.txt
   test-1701ef1f1510/.hgsub
   test-1701ef1f1510/.hgsubstate
   test-1701ef1f1510/bar
   test-1701ef1f1510/baz/bletch
   test-1701ef1f1510/foo
 
   $ hg archive autodetected_test.tar
   $ tar tf autodetected_test.tar
   autodetected_test/.hg_archival.txt
   autodetected_test/.hgsub
   autodetected_test/.hgsubstate
   autodetected_test/bar
   autodetected_test/baz/bletch
   autodetected_test/foo
 
 The '-t' should override autodetection
 
   $ hg archive -t tar autodetect_override_test.zip
   $ tar tf autodetect_override_test.zip
   autodetect_override_test.zip/.hg_archival.txt
   autodetect_override_test.zip/.hgsub
   autodetect_override_test.zip/.hgsubstate
   autodetect_override_test.zip/bar
   autodetect_override_test.zip/baz/bletch
   autodetect_override_test.zip/foo
 
   $ for ext in tar tar.gz tgz tar.bz2 tbz2 zip; do
   >     hg archive auto_test.$ext
   >     if [ -d auto_test.$ext ]; then
   >         echo "extension $ext was not autodetected."
   >     fi
   > done
 
   $ cat > md5comp.py <<EOF
   > from __future__ import print_function
   > try:
   >     from hashlib import md5
   > except ImportError:
   >     from md5 import md5
   > import sys
   > f1, f2 = sys.argv[1:3]
   > h1 = md5(open(f1, 'rb').read()).hexdigest()
   > h2 = md5(open(f2, 'rb').read()).hexdigest()
   > print(h1 == h2 or "md5 differ: " + repr((h1, h2)))
   > EOF
 
 archive name is stored in the archive, so create similar archives and
 rename them afterwards.
 
   $ hg archive -t tgz tip.tar.gz
   $ mv tip.tar.gz tip1.tar.gz
   $ sleep 1
   $ hg archive -t tgz tip.tar.gz
   $ mv tip.tar.gz tip2.tar.gz
   $ python md5comp.py tip1.tar.gz tip2.tar.gz
   True
 
   $ hg archive -t zip -p /illegal test.zip
   abort: archive prefix contains illegal components
   [255]
   $ hg archive -t zip -p very/../bad test.zip
 
   $ hg archive --config ui.archivemeta=false -t zip -r 2 test.zip
   $ unzip -t test.zip
   Archive:  test.zip
-      testing: test/bar                 OK
-      testing: test/baz/bletch          OK
-      testing: test/foo                 OK
+      testing: test/bar*OK (glob)
+      testing: test/baz/bletch*OK (glob)
+      testing: test/foo*OK (glob)
   No errors detected in compressed data of test.zip.
 
   $ hg archive -t tar - | tar tf - 2>/dev/null
   test-1701ef1f1510/.hg_archival.txt
   test-1701ef1f1510/.hgsub
   test-1701ef1f1510/.hgsubstate
   test-1701ef1f1510/bar
   test-1701ef1f1510/baz/bletch
   test-1701ef1f1510/foo
 
   $ hg archive -r 0 -t tar rev-%r.tar
   $ [ -f rev-0.tar ]
 
 test .hg_archival.txt
 
   $ hg archive ../test-tags
   $ cat ../test-tags/.hg_archival.txt
   repo: daa7f7c60e0a224faa4ff77ca41b2760562af264
   node: 1701ef1f151069b8747038e93b5186bb43a47504
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
   $ hg tag -r 2 mytag
   $ hg tag -r 2 anothertag
   $ hg archive -r 2 ../test-lasttag
   $ cat ../test-lasttag/.hg_archival.txt
   repo: daa7f7c60e0a224faa4ff77ca41b2760562af264
   node: 2c0277f05ed49d1c8328fb9ba92fba7a5ebcb33e
   branch: default
   tag: anothertag
   tag: mytag
 
   $ hg archive -t bogus test.bogus
   abort: unknown archive type 'bogus'
   [255]
 
 enable progress extension:
 
   $ cp $HGRCPATH $HGRCPATH.no-progress
   $ cat >> $HGRCPATH <<EOF
   > [progress]
   > assume-tty = 1
   > format = topic bar number
   > delay = 0
   > refresh = 0
   > width = 60
   > EOF
 
   $ hg archive ../with-progress
   \r (no-eol) (esc)
   archiving [                                           ] 0/6\r (no-eol) (esc)
   archiving [======>                                    ] 1/6\r (no-eol) (esc)
   archiving [=============>                             ] 2/6\r (no-eol) (esc)
   archiving [====================>                      ] 3/6\r (no-eol) (esc)
   archiving [===========================>               ] 4/6\r (no-eol) (esc)
   archiving [==================================>        ] 5/6\r (no-eol) (esc)
   archiving [==========================================>] 6/6\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
 
 cleanup after progress extension test:
 
   $ cp $HGRCPATH.no-progress $HGRCPATH
 
 server errors
 
   $ cat errors.log
 
 empty repo
 
   $ hg init ../empty
   $ cd ../empty
   $ hg archive ../test-empty
   abort: no working directory: please specify a revision
   [255]
 
 old file -- date clamped to 1980
 
   $ touch -t 197501010000 old
   $ hg add old
   $ hg commit -m old
   $ hg archive ../old.zip
   $ unzip -l ../old.zip
   Archive:  ../old.zip
   \s*Length.* (re)
   *-----* (glob)
   *172*80*00:00*old/.hg_archival.txt (glob)
   *0*80*00:00*old/old (glob)
   *-----* (glob)
   \s*172\s+2 files (re)
 
 show an error when a provided pattern matches no files
 
   $ hg archive -I file_that_does_not_exist.foo ../empty.zip
   abort: no files match the archive pattern
   [255]
 
   $ hg archive -X * ../empty.zip
   abort: no files match the archive pattern
   [255]
 
   $ cd ..
 
 issue3600: check whether "hg archive" can create archive files which
 are extracted with expected timestamp, even though TZ is not
 configured as GMT.
 
   $ mkdir issue3600
   $ cd issue3600
 
   $ hg init repo
   $ echo a > repo/a
   $ hg -R repo add repo/a
   $ hg -R repo commit -m '#0' -d '456789012 21600'
   $ cat > show_mtime.py <<EOF
   > from __future__ import print_function
   > import sys, os
   > print(int(os.stat(sys.argv[1]).st_mtime))
   > EOF
 
   $ hg -R repo archive --prefix tar-extracted archive.tar
   $ (TZ=UTC-3; export TZ; tar xf archive.tar)
   $ python show_mtime.py tar-extracted/a
   456789012
 
   $ hg -R repo archive --prefix zip-extracted archive.zip
   $ (TZ=UTC-3; export TZ; unzip -q archive.zip)
   $ python show_mtime.py zip-extracted/a
   456789012
 
   $ cd ..

tests/test-largefiles-wireproto.t

@@ -1,447 +1,447 b''
 This file contains testcases that tend to be related to the wire protocol part
 of largefiles.
 
   $ USERCACHE="$TESTTMP/cache"; export USERCACHE
   $ mkdir "${USERCACHE}"
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles=
   > purge=
   > rebase=
   > transplant=
   > [phases]
   > publish=False
   > [largefiles]
   > minsize=2
   > patterns=glob:**.dat
   > usercache=${USERCACHE}
   > [web]
   > allow_archive = zip
   > [hooks]
   > precommit=sh -c "echo \\"Invoking status precommit hook\\"; hg status"
   > EOF
 
 
 #if serve
 vanilla clients not locked out from largefiles servers on vanilla repos
   $ mkdir r1
   $ cd r1
   $ hg init
   $ echo c1 > f1
   $ hg add f1
   $ hg commit -m "m1"
   Invoking status precommit hook
   A f1
   $ cd ..
   $ hg serve -R r1 -d -p $HGPORT --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg --config extensions.largefiles=! clone http://localhost:$HGPORT r2
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 largefiles clients still work with vanilla servers
   $ hg serve --config extensions.largefiles=! -R r1 -d -p $HGPORT1 --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg clone http://localhost:$HGPORT1 r3
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
 vanilla clients locked out from largefiles http repos
   $ mkdir r4
   $ cd r4
   $ hg init
   $ echo c1 > f1
   $ hg add --large f1
   $ hg commit -m "m1"
   Invoking status precommit hook
   A f1
   $ cd ..
 
 largefiles can be pushed locally (issue3583)
   $ hg init dest
   $ cd r4
   $ hg outgoing ../dest
   comparing with ../dest
   searching for changes
   changeset:   0:639881c12b4c
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     m1
   
   $ hg push ../dest
   pushing to ../dest
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 exit code with nothing outgoing (issue3611)
   $ hg outgoing ../dest
   comparing with ../dest
   searching for changes
   no changes found
   [1]
   $ cd ..
 
 #if serve
   $ hg serve -R r4 -d -p $HGPORT2 --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg --config extensions.largefiles=! clone http://localhost:$HGPORT2 r5
   abort: remote error:
   
   This repository uses the largefiles extension.
   
   Please enable it in your Mercurial config file.
   [255]
 
 used all HGPORTs, kill all daemons
   $ killdaemons.py
 #endif
 
 vanilla clients locked out from largefiles ssh repos
   $ hg --config extensions.largefiles=! clone -e "python \"$TESTDIR/dummyssh\"" ssh://user@dummy/r4 r5
   remote: 
   remote: This repository uses the largefiles extension.
   remote: 
   remote: Please enable it in your Mercurial config file.
   remote: 
   remote: -
   abort: remote error
   (check previous remote output)
   [255]
 
 #if serve
 
 largefiles clients refuse to push largefiles repos to vanilla servers
   $ mkdir r6
   $ cd r6
   $ hg init
   $ echo c1 > f1
   $ hg add f1
   $ hg commit -m "m1"
   Invoking status precommit hook
   A f1
   $ cat >> .hg/hgrc <<!
   > [web]
   > push_ssl = false
   > allow_push = *
   > !
   $ cd ..
   $ hg clone r6 r7
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd r7
   $ echo c2 > f2
   $ hg add --large f2
   $ hg commit -m "m2"
   Invoking status precommit hook
   A f2
   $ hg verify --large
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 2 changesets, 2 total revisions
   searching 1 changesets for largefiles
   verified existence of 1 revisions of 1 largefiles
   $ hg serve --config extensions.largefiles=! -R ../r6 -d -p $HGPORT --pid-file ../hg.pid
   $ cat ../hg.pid >> $DAEMON_PIDS
   $ hg push http://localhost:$HGPORT
   pushing to http://localhost:$HGPORT/
   searching for changes
   abort: http://localhost:$HGPORT/ does not appear to be a largefile store
   [255]
   $ cd ..
 
 putlfile errors are shown (issue3123)
 Corrupt the cached largefile in r7 and move it out of the servers usercache
   $ mv r7/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8 .
   $ echo 'client side corruption' > r7/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8
   $ rm "$USERCACHE/4cdac4d8b084d0b599525cf732437fb337d422a8"
   $ hg init empty
   $ hg serve -R empty -d -p $HGPORT1 --pid-file hg.pid \
   >   --config 'web.allow_push=*' --config web.push_ssl=False
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg push -R r7 http://localhost:$HGPORT1
   pushing to http://localhost:$HGPORT1/
   searching for changes
   remote: largefiles: failed to put 4cdac4d8b084d0b599525cf732437fb337d422a8 into store: largefile contents do not match hash
   abort: remotestore: could not put $TESTTMP/r7/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8 to remote store http://localhost:$HGPORT1/ (glob)
   [255]
   $ mv 4cdac4d8b084d0b599525cf732437fb337d422a8 r7/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8
 Push of file that exists on server but is corrupted - magic healing would be nice ... but too magic
   $ echo "server side corruption" > empty/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8
   $ hg push -R r7 http://localhost:$HGPORT1
   pushing to http://localhost:$HGPORT1/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 2 changesets with 2 changes to 2 files
   $ cat empty/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8
   server side corruption
   $ rm -rf empty
 
 Push a largefiles repository to a served empty repository
   $ hg init r8
   $ echo c3 > r8/f1
   $ hg add --large r8/f1 -R r8
   $ hg commit -m "m1" -R r8
   Invoking status precommit hook
   A f1
   $ hg init empty
   $ hg serve -R empty -d -p $HGPORT2 --pid-file hg.pid \
   >   --config 'web.allow_push=*' --config web.push_ssl=False
   $ cat hg.pid >> $DAEMON_PIDS
   $ rm "${USERCACHE}"/*
   $ hg push -R r8 http://localhost:$HGPORT2/#default
   pushing to http://localhost:$HGPORT2/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   $ [ -f "${USERCACHE}"/02a439e5c31c526465ab1a0ca1f431f76b827b90 ]
   $ [ -f empty/.hg/largefiles/02a439e5c31c526465ab1a0ca1f431f76b827b90 ]
 
 Clone over http, no largefiles pulled on clone.
 
   $ hg clone http://localhost:$HGPORT2/#default http-clone -U
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 Archive contains largefiles
   >>> import urllib2, os
   >>> u = 'http://localhost:%s/archive/default.zip' % os.environ['HGPORT2']
   >>> with open('archive.zip', 'w') as f:
   ...     f.write(urllib2.urlopen(u).read())
   $ unzip -t archive.zip
   Archive:  archive.zip
-      testing: empty-default/.hg_archival.txt   OK
-      testing: empty-default/f1         OK
+      testing: empty-default/.hg_archival.txt*OK (glob)
+      testing: empty-default/f1*OK (glob)
   No errors detected in compressed data of archive.zip.
 
 test 'verify' with remotestore:
 
   $ rm "${USERCACHE}"/02a439e5c31c526465ab1a0ca1f431f76b827b90
   $ mv empty/.hg/largefiles/02a439e5c31c526465ab1a0ca1f431f76b827b90 .
   $ hg -R http-clone verify --large --lfa
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 1 changesets, 1 total revisions
   searching 1 changesets for largefiles
   changeset 0:cf03e5bb9936: f1 missing
   verified existence of 1 revisions of 1 largefiles
   [1]
   $ mv 02a439e5c31c526465ab1a0ca1f431f76b827b90 empty/.hg/largefiles/
   $ hg -R http-clone -q verify --large --lfa
 
 largefiles pulled on update - a largefile missing on the server:
   $ mv empty/.hg/largefiles/02a439e5c31c526465ab1a0ca1f431f76b827b90 .
   $ hg -R http-clone up --config largefiles.usercache=http-clone-usercache
   getting changed largefiles
   f1: largefile 02a439e5c31c526465ab1a0ca1f431f76b827b90 not available from http://localhost:$HGPORT2/
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R http-clone st
   ! f1
   $ hg -R http-clone up -Cqr null
 
 largefiles pulled on update - a largefile corrupted on the server:
   $ echo corruption > empty/.hg/largefiles/02a439e5c31c526465ab1a0ca1f431f76b827b90
   $ hg -R http-clone up --config largefiles.usercache=http-clone-usercache
   getting changed largefiles
   f1: data corruption (expected 02a439e5c31c526465ab1a0ca1f431f76b827b90, got 6a7bb2556144babe3899b25e5428123735bb1e27)
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R http-clone st
   ! f1
   $ [ ! -f http-clone/.hg/largefiles/02a439e5c31c526465ab1a0ca1f431f76b827b90 ]
   $ [ ! -f http-clone/f1 ]
   $ [ ! -f http-clone-usercache ]
   $ hg -R http-clone verify --large --lfc
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 1 changesets, 1 total revisions
   searching 1 changesets for largefiles
   verified contents of 1 revisions of 1 largefiles
   $ hg -R http-clone up -Cqr null
 
 largefiles pulled on update - no server side problems:
   $ mv 02a439e5c31c526465ab1a0ca1f431f76b827b90 empty/.hg/largefiles/
   $ hg -R http-clone --debug up --config largefiles.usercache=http-clone-usercache --config progress.debug=true
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: 000000000000, local: 000000000000+, remote: cf03e5bb9936
    .hglf/f1: remote created -> g
   getting .hglf/f1
   updating: .hglf/f1 1/1 files (100.00%)
   getting changed largefiles
   using http://localhost:$HGPORT2/
   sending capabilities command
   sending batch command
   getting largefiles: 0/1 files (0.00%)
   getting f1:02a439e5c31c526465ab1a0ca1f431f76b827b90
   sending getlfile command
   found 02a439e5c31c526465ab1a0ca1f431f76b827b90 in store
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls http-clone-usercache/*
   http-clone-usercache/02a439e5c31c526465ab1a0ca1f431f76b827b90
 
   $ rm -rf empty http-clone*
 
 used all HGPORTs, kill all daemons
   $ killdaemons.py
 
 largefiles should batch verify remote calls
 
   $ hg init batchverifymain
   $ cd batchverifymain
   $ echo "aaa" >> a
   $ hg add --large a
   $ hg commit -m "a"
   Invoking status precommit hook
   A a
   $ echo "bbb" >> b
   $ hg add --large b
   $ hg commit -m "b"
   Invoking status precommit hook
   A b
   $ cd ..
   $ hg serve -R batchverifymain -d -p $HGPORT --pid-file hg.pid \
   > -A access.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg clone --noupdate http://localhost:$HGPORT batchverifyclone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   $ hg -R batchverifyclone verify --large --lfa
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 2 changesets, 2 total revisions
   searching 2 changesets for largefiles
   verified existence of 2 revisions of 2 largefiles
   $ tail -1 access.log
   127.0.0.1 - - [*] "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=statlfile+sha%3D972a1a11f19934401291cc99117ec614933374ce%3Bstatlfile+sha%3Dc801c9cfe94400963fcb683246217d5db77f9a9a (glob)
   $ hg -R batchverifyclone update
   getting changed largefiles
   2 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Clear log file before next test
 
   $ printf "" > access.log
 
 Verify should check file on remote server only when file is not
 available locally.
 
   $ echo "ccc" >> batchverifymain/c
   $ hg -R batchverifymain status
   ? c
   $ hg -R batchverifymain add --large batchverifymain/c
   $ hg -R batchverifymain commit -m "c"
   Invoking status precommit hook
   A c
   $ hg -R batchverifyclone pull
   pulling from http://localhost:$HGPORT/
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
   $ hg -R batchverifyclone verify --lfa
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   3 files, 3 changesets, 3 total revisions
   searching 3 changesets for largefiles
   verified existence of 3 revisions of 3 largefiles
   $ tail -1 access.log
   127.0.0.1 - - [*] "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=statlfile+sha%3Dc8559c3c9cfb42131794b7d8009230403b9b454c (glob)
 
   $ killdaemons.py
 
 largefiles should not ask for password again after succesfull authorization
 
   $ hg init credentialmain
   $ cd credentialmain
   $ echo "aaa" >> a
   $ hg add --large a
   $ hg commit -m "a"
   Invoking status precommit hook
   A a
 
 Before running server clear the user cache to force clone to download
 a large file from the server rather than to get it from the cache
 
   $ rm "${USERCACHE}"/*
 
   $ cd ..
   $ cat << EOT > userpass.py
   > import base64
   > from mercurial.hgweb import common
   > def perform_authentication(hgweb, req, op):
   >     auth = req.env.get('HTTP_AUTHORIZATION')
   >     if not auth:
   >         raise common.ErrorResponse(common.HTTP_UNAUTHORIZED, 'who',
   >                 [('WWW-Authenticate', 'Basic Realm="mercurial"')])
   >     if base64.b64decode(auth.split()[1]).split(':', 1) != ['user', 'pass']:
   >         raise common.ErrorResponse(common.HTTP_FORBIDDEN, 'no')
   > def extsetup():
   >     common.permhooks.insert(0, perform_authentication)
   > EOT
   $ hg serve --config extensions.x=userpass.py -R credentialmain \
   >          -d -p $HGPORT --pid-file hg.pid -A access.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ cat << EOF > get_pass.py
   > import getpass
   > def newgetpass(arg):
   >   return "pass"
   > getpass.getpass = newgetpass
   > EOF
   $ hg clone --config ui.interactive=true --config extensions.getpass=get_pass.py \
   >          http://user@localhost:$HGPORT credentialclone
   requesting all changes
   http authorization required for http://localhost:$HGPORT/
   realm: mercurial
   user: user
   password: adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ rm hg.pid access.log
   $ killdaemons.py
 
 #endif