This file contains testcases that tend to be related to special cases or less

common commands affecting largefile.

Each sections should be independent of each others.

  $ 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}

  > [hooks]

  > precommit=sh -c "echo \\"Invoking status precommit hook\\"; hg status"

  > EOF

Test copies and moves from a directory other than root (issue3516)

=========================================================================

  $ hg init lf_cpmv

  $ cd lf_cpmv

  $ mkdir dira

  $ mkdir dira/dirb

  $ touch dira/dirb/largefile

  $ hg add --large dira/dirb/largefile

  $ hg commit -m "added"

  Invoking status precommit hook

  A dira/dirb/largefile

  $ cd dira

  $ hg cp dirb/largefile foo/largefile

  $ hg ci -m "deep copy"

  Invoking status precommit hook

  A dira/foo/largefile

  $ find . | sort

  .

  ./dirb

  ./dirb/largefile

  ./foo

  ./foo/largefile

  $ hg mv foo/largefile baz/largefile

  $ hg ci -m "moved"

  Invoking status precommit hook

  A dira/baz/largefile

  R dira/foo/largefile

  $ find . | sort

  .

  ./baz

  ./baz/largefile

  ./dirb

  ./dirb/largefile

  $ cd ..

  $ hg mv dira dirc

  moving .hglf/dira/baz/largefile to .hglf/dirc/baz/largefile (glob)

  moving .hglf/dira/dirb/largefile to .hglf/dirc/dirb/largefile (glob)

  $ find * | sort

  dirc

  dirc/baz

  dirc/baz/largefile

  dirc/dirb

  dirc/dirb/largefile

  $ hg up -qC

  $ cd ..

Clone a local repository owned by another user

===================================================

#if unix-permissions

We have to simulate that here by setting $HOME and removing write permissions

  $ ORIGHOME="$HOME"

  $ mkdir alice

  $ HOME="`pwd`/alice"

  $ cd alice

  $ hg init pubrepo

  $ cd pubrepo

  $ dd if=/dev/zero bs=1k count=11k > a-large-file 2> /dev/null

  $ hg add --large a-large-file

  $ hg commit -m "Add a large file"

  Invoking status precommit hook

  A a-large-file

  $ cd ..

  $ chmod -R a-w pubrepo

  $ cd ..

  $ mkdir bob

  $ HOME="`pwd`/bob"

  $ cd bob

  $ hg clone --pull ../alice/pubrepo pubrepo

  requesting all changes

  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

  $ cd ..

  $ chmod -R u+w alice/pubrepo

  $ HOME="$ORIGHOME"

#endif

Symlink to a large largefile should behave the same as a symlink to a normal file

=====================================================================================

#if symlink

  $ hg init largesymlink

  $ cd largesymlink

  $ dd if=/dev/zero bs=1k count=10k of=largefile 2>/dev/null

  $ hg add --large largefile

  $ hg commit -m "commit a large file"

  Invoking status precommit hook

  A largefile

  $ ln -s largefile largelink

  $ hg add largelink

  $ hg commit -m "commit a large symlink"

  Invoking status precommit hook

  A largelink

  $ rm -f largelink

  $ hg up >/dev/null

  $ test -f largelink

  [1]

  $ test -L largelink

  [1]

  $ rm -f largelink # make next part of the test independent of the previous

  $ hg up -C >/dev/null

  $ test -f largelink

  $ test -L largelink

  $ cd ..

#endif

test for pattern matching on 'hg status':

==============================================

to boost performance, largefiles checks whether specified patterns are

related to largefiles in working directory (NOT to STANDIN) or not.

  $ hg init statusmatch

  $ cd statusmatch

  $ mkdir -p a/b/c/d

  $ echo normal > a/b/c/d/e.normal.txt

  $ hg add a/b/c/d/e.normal.txt

  $ echo large > a/b/c/d/e.large.txt

  $ hg add --large a/b/c/d/e.large.txt

  $ mkdir -p a/b/c/x

  $ echo normal > a/b/c/x/y.normal.txt

  $ hg add a/b/c/x/y.normal.txt

  $ hg commit -m 'add files'

  Invoking status precommit hook

  A a/b/c/d/e.large.txt

  A a/b/c/d/e.normal.txt

  A a/b/c/x/y.normal.txt

(1) no pattern: no performance boost

  $ hg status -A

  C a/b/c/d/e.large.txt

  C a/b/c/d/e.normal.txt

  C a/b/c/x/y.normal.txt

(2) pattern not related to largefiles: performance boost

  $ hg status -A a/b/c/x

  C a/b/c/x/y.normal.txt

(3) pattern related to largefiles: no performance boost

  $ hg status -A a/b/c/d

  C a/b/c/d/e.large.txt

  C a/b/c/d/e.normal.txt

(4) pattern related to STANDIN (not to largefiles): performance boost

  $ hg status -A .hglf/a

  C .hglf/a/b/c/d/e.large.txt

(5) mixed case: no performance boost

  $ hg status -A a/b/c/x a/b/c/d

  C a/b/c/d/e.large.txt

  C a/b/c/d/e.normal.txt

  C a/b/c/x/y.normal.txt

verify that largefiles doesn't break filesets

  $ hg log --rev . --exclude "set:binary()"

  changeset:   0:41bd42f10efa

  tag:         tip

  user:        test

  date:        Thu Jan 01 00:00:00 1970 +0000

  summary:     add files

verify that large files in subrepos handled properly

  $ hg init subrepo

  $ echo "subrepo = subrepo" > .hgsub

  $ hg add .hgsub

  $ hg ci -m "add subrepo"

  Invoking status precommit hook

  A .hgsub

  ? .hgsubstate

  $ echo "rev 1" > subrepo/large.txt

  $ hg -R subrepo add --large subrepo/large.txt

  $ hg sum

  parent: 1:8ee150ea2e9c tip

   add subrepo

  branch: default

  commit: 1 subrepos

  update: (current)

  $ hg st

  $ hg st -S

  A subrepo/large.txt

  $ hg ci -S -m "commit top repo"

  committing subrepository subrepo

  Invoking status precommit hook

  A large.txt

  Invoking status precommit hook

  M .hgsubstate

# No differences

  $ hg st -S

  $ hg sum

  parent: 2:ce4cd0c527a6 tip

   commit top repo

  branch: default

  commit: (clean)

  update: (current)

  $ echo "rev 2" > subrepo/large.txt

  $ hg st -S

  M subrepo/large.txt

  $ hg sum

  parent: 2:ce4cd0c527a6 tip

   commit top repo

  branch: default

  commit: 1 subrepos

  update: (current)

  $ hg ci -m "this commit should fail without -S"

  abort: uncommitted changes in subrepo subrepo

  (use --subrepos for recursive commit)

  [255]

Add a normal file to the subrepo, then test archiving

  $ echo 'normal file' > subrepo/normal.txt

  $ hg -R subrepo add subrepo/normal.txt

Lock in subrepo, otherwise the change isn't archived

  $ hg ci -S -m "add normal file to top level"

  committing subrepository subrepo

  Invoking status precommit hook

  M large.txt

  A normal.txt

  Invoking status precommit hook

  M .hgsubstate

  $ hg archive -S ../lf_subrepo_archive

  $ find ../lf_subrepo_archive | sort

  ../lf_subrepo_archive

  ../lf_subrepo_archive/.hg_archival.txt

  ../lf_subrepo_archive/.hgsub

  ../lf_subrepo_archive/.hgsubstate

  ../lf_subrepo_archive/a

  ../lf_subrepo_archive/a/b

  ../lf_subrepo_archive/a/b/c

  ../lf_subrepo_archive/a/b/c/d

  ../lf_subrepo_archive/a/b/c/d/e.large.txt

  ../lf_subrepo_archive/a/b/c/d/e.normal.txt

  ../lf_subrepo_archive/a/b/c/x

  ../lf_subrepo_archive/a/b/c/x/y.normal.txt

  ../lf_subrepo_archive/subrepo

  ../lf_subrepo_archive/subrepo/large.txt

  ../lf_subrepo_archive/subrepo/normal.txt

Test update with subrepos.

  $ hg update 0

  getting changed largefiles

  0 largefiles updated, 1 removed

  0 files updated, 0 files merged, 2 files removed, 0 files unresolved

  $ hg status -S

  $ hg update tip

  getting changed largefiles

  1 largefiles updated, 0 removed

  2 files updated, 0 files merged, 0 files removed, 0 files unresolved

  $ hg status -S

# modify a large file

  $ echo "modified" > subrepo/large.txt

  $ hg st -S

  M subrepo/large.txt

# update -C should revert the change.

  $ hg update -C

  getting changed largefiles

  1 largefiles updated, 0 removed

  getting changed largefiles

  0 largefiles updated, 0 removed

  1 files updated, 0 files merged, 0 files removed, 0 files unresolved

  $ hg status -S

Test archiving a revision that references a subrepo that is not yet

cloned (see test-subrepo-recursion.t):

  $ hg clone -U . ../empty

  $ cd ../empty

  $ hg archive --subrepos -r tip ../archive.tar.gz

  cloning subrepo subrepo from $TESTTMP/statusmatch/subrepo

  $ cd ..

Test addremove, forget and others

==============================================

Test that addremove picks up largefiles prior to the initial commit (issue3541)

  $ hg init addrm2

  $ cd addrm2

  $ touch large.dat

  $ touch large2.dat

  $ touch normal

  $ hg add --large large.dat

  $ hg addremove -v

  adding large2.dat as a largefile

  adding normal

Test that forgetting all largefiles reverts to islfilesrepo() == False

(addremove will add *.dat as normal files now)

  $ hg forget large.dat

  $ hg forget large2.dat

  $ hg addremove -v

  adding large.dat

  adding large2.dat

Test commit's addremove option prior to the first commit

  $ hg forget large.dat

  $ hg forget large2.dat

  $ hg add --large large.dat

  $ hg ci -Am "commit"

  adding large2.dat as a largefile

  Invoking status precommit hook

  A large.dat

  A large2.dat

  A normal

  $ find .hglf | sort

  .hglf

  .hglf/large.dat

  .hglf/large2.dat

Test actions on largefiles using relative paths from subdir

  $ mkdir sub

  $ cd sub

  $ echo anotherlarge > anotherlarge

  $ hg add --large anotherlarge

  $ hg st

  A sub/anotherlarge

  $ hg st anotherlarge

  A anotherlarge

  $ hg commit -m anotherlarge anotherlarge

  Invoking status precommit hook

  A sub/anotherlarge

  $ hg log anotherlarge

  changeset:   1:9627a577c5e9

  tag:         tip

  user:        test

  date:        Thu Jan 01 00:00:00 1970 +0000

  summary:     anotherlarge

  $ hg log -G anotherlarge

  @  changeset:   1:9627a577c5e9

  |  tag:         tip

  |  user:        test

  |  date:        Thu Jan 01 00:00:00 1970 +0000

  |  summary:     anotherlarge

  |

  $ echo more >> anotherlarge

  $ hg st .

  M anotherlarge

  $ hg cat anotherlarge

  anotherlarge

  $ hg revert anotherlarge

  $ hg st

  ? sub/anotherlarge.orig

  $ cd ..

  $ cd ..

Check error message while exchange