$ "$TESTDIR/hghave" symlink unix-permissions serve || exit 80

  $ USERCACHE=`pwd`/cache; export USERCACHE

  $ mkdir -p ${USERCACHE}

  $ cat >> $HGRCPATH <<EOF

  > [extensions]

  > largefiles=

  > purge=

  > rebase=

  > transplant=

  > [phases]

  > publish=False

  > [largefiles]

  > minsize=2

  > patterns=glob:**.dat

  > usercache=${USERCACHE}

  > EOF

Create the repo with a couple of revisions of both large and normal

files, testing that status correctly shows largefiles and that summary output

is correct.

  $ hg init a

  $ cd a

  $ mkdir sub

  $ echo normal1 > normal1

  $ echo normal2 > sub/normal2

  $ echo large1 > large1

  $ echo large2 > sub/large2

  $ hg add normal1 sub/normal2

  $ hg add --large large1 sub/large2

  $ hg commit -m "add files"

  $ echo normal11 > normal1

  $ echo normal22 > sub/normal2

  $ echo large11 > large1

  $ echo large22 > sub/large2

  $ hg st

  M large1

  M normal1

  M sub/large2

  M sub/normal2

  $ hg sum

  parent: 0:30d30fe6a5be tip

   add files

  branch: default

  commit: 4 modified

  update: (current)

  $ hg commit -m "edit files"

  $ hg sum --large

  parent: 1:ce8896473775 tip

   edit files

  branch: default

  commit: (clean)

  update: (current)

  largefiles: No remote repo

Commit preserved largefile contents.

  $ cat normal1

  normal11

  $ cat large1

  large11

  $ cat sub/normal2

  normal22

  $ cat sub/large2

  large22

Remove both largefiles and normal files.

  $ hg remove normal1 large1

  $ hg commit -m "remove files"

  $ ls

  sub

  $ echo "testlargefile" > large1-test

  $ hg add --large large1-test

  $ hg st

  A large1-test

  $ hg rm large1-test

  not removing large1-test: file has been marked for add (use forget to undo)

  $ hg st

  A large1-test

  $ hg forget large1-test

  $ hg st

  ? large1-test

  $ rm large1-test

Copy both largefiles and normal files (testing that status output is correct).

  $ hg cp sub/normal2 normal1

  $ hg cp sub/large2 large1

  $ hg st

  A large1

  A normal1

  $ hg commit -m "copy files"

  $ cat normal1

  normal22

  $ cat large1

  large22

Test moving largefiles and verify that normal files are also unaffected.

  $ hg mv normal1 normal3

  $ hg mv large1 large3

  $ hg mv sub/normal2 sub/normal4

  $ hg mv sub/large2 sub/large4

  $ hg commit -m "move files"

  $ cat normal3

  normal22

  $ cat large3

  large22

  $ cat sub/normal4

  normal22

  $ cat sub/large4

  large22

Test archiving the various revisions.  These hit corner cases known with

archiving.

  $ hg archive -r 0 ../archive0

  $ hg archive -r 1 ../archive1

  $ hg archive -r 2 ../archive2

  $ hg archive -r 3 ../archive3

  $ hg archive -r 4 ../archive4

  $ cd ../archive0

  $ cat normal1 

  normal1

  $ cat large1

  large1

  $ cat sub/normal2

  normal2

  $ cat sub/large2

  large2

  $ cd ../archive1

  $ cat normal1

  normal11

  $ cat large1

  large11

  $ cat sub/normal2

  normal22

  $ cat sub/large2

  large22

  $ cd ../archive2

  $ ls

  sub

  $ cat sub/normal2

  normal22

  $ cat sub/large2

  large22

  $ cd ../archive3

  $ cat normal1

  normal22

  $ cat large1

  large22

  $ cat sub/normal2

  normal22

  $ cat sub/large2

  large22

  $ cd ../archive4

  $ cat normal3

  normal22

  $ cat large3

  large22

  $ cat sub/normal4

  normal22

  $ cat sub/large4

  large22

Commit corner case: specify files to commit.

  $ cd ../a

  $ echo normal3 > normal3

  $ echo large3 > large3

  $ echo normal4 > sub/normal4

  $ echo large4 > sub/large4

  $ hg commit normal3 large3 sub/normal4 sub/large4 -m "edit files again"

  $ cat normal3

  normal3

  $ cat large3

  large3

  $ cat sub/normal4

  normal4

  $ cat sub/large4

  large4

One more commit corner case: commit from a subdirectory.

  $ cd ../a

  $ echo normal33 > normal3

  $ echo large33 > large3

  $ echo normal44 > sub/normal4

  $ echo large44 > sub/large4

  $ cd sub

  $ hg commit -m "edit files yet again"

  $ cat ../normal3

  normal33

  $ cat ../large3

  large33

  $ cat normal4

  normal44

  $ cat large4

  large44

Committing standins is not allowed.

  $ cd ..

  $ echo large3 > large3

  $ hg commit .hglf/large3 -m "try to commit standin"

  abort: file ".hglf/large3" is a largefile standin

  (commit the largefile itself instead)

  [255]

Corner cases for adding largefiles.

  $ echo large5 > large5

  $ hg add --large large5

  $ hg add --large large5

  large5 already a largefile

  $ mkdir sub2

  $ echo large6 > sub2/large6

  $ echo large7 > sub2/large7

  $ hg add --large sub2

  adding sub2/large6 as a largefile (glob)

  adding sub2/large7 as a largefile (glob)

  $ hg st

  M large3

  A large5

  A sub2/large6

  A sub2/large7

Config settings (pattern **.dat, minsize 2 MB) are respected.

  $ echo testdata > test.dat

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

  $ hg add

  adding reallylarge as a largefile

  adding test.dat as a largefile

Test that minsize and --lfsize handle float values;

also tests that --lfsize overrides largefiles.minsize.

(0.250 MB = 256 kB = 262144 B)

  $ dd if=/dev/zero of=ratherlarge bs=1024 count=256 > /dev/null 2> /dev/null

  $ dd if=/dev/zero of=medium bs=1024 count=128 > /dev/null 2> /dev/null

  $ hg --config largefiles.minsize=.25 add

  adding ratherlarge as a largefile

  adding medium

  $ hg forget medium

  $ hg --config largefiles.minsize=.25 add --lfsize=.125

  adding medium as a largefile

  $ dd if=/dev/zero of=notlarge bs=1024 count=127 > /dev/null 2> /dev/null

  $ hg --config largefiles.minsize=.25 add --lfsize=.125

  adding notlarge

  $ hg forget notlarge

Test forget on largefiles.

  $ hg forget large3 large5 test.dat reallylarge ratherlarge medium

  $ hg st

  A sub2/large6

  A sub2/large7

  R large3

  ? large5

  ? medium

  ? notlarge

  ? ratherlarge

  ? reallylarge

  ? test.dat

  $ hg commit -m "add/edit more largefiles"

  $ hg st

  ? large3

  ? large5

  ? medium

  ? notlarge

  ? ratherlarge

  ? reallylarge

  ? test.dat

Purge with largefiles: verify that largefiles are still in the working

dir after a purge.

  $ hg purge --all

  $ cat sub/large4

  large44

  $ cat sub2/large6

  large6

  $ cat sub2/large7

  large7

Clone a largefiles repo.

  $ hg clone . ../b

  updating to branch default

  5 files updated, 0 files merged, 0 files removed, 0 files unresolved

  getting changed largefiles

  3 largefiles updated, 0 removed

  $ cd ../b

  $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'

  7:daea875e9014  add/edit more largefiles

  6:4355d653f84f  edit files yet again

  5:9d5af5072dbd  edit files again

  4:74c02385b94c  move files

  3:9e8fbc4bce62  copy files

  2:51a0ae4d5864  remove files

  1:ce8896473775  edit files

  0:30d30fe6a5be  add files

  $ cat normal3

  normal33

  $ cat sub/normal4

  normal44

  $ cat sub/large4

  large44

  $ cat sub2/large6

  large6

  $ cat sub2/large7

  large7

  $ cd ..

  $ hg clone a -r 3 c

  adding changesets

  adding manifests

  adding file changes

  added 4 changesets with 10 changes to 4 files

  updating to branch default

  4 files updated, 0 files merged, 0 files removed, 0 files unresolved

  getting changed largefiles

  2 largefiles updated, 0 removed

  $ cd c

  $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'

  3:9e8fbc4bce62  copy files

  2:51a0ae4d5864  remove files

  1:ce8896473775  edit files

  0:30d30fe6a5be  add files

  $ cat normal1

  normal22

  $ cat large1

  large22

  $ cat sub/normal2

  normal22

  $ cat sub/large2

  large22

Old revisions of a clone have correct largefiles content (this also

tests update).

  $ hg update -r 1 

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

  getting changed largefiles

  1 largefiles updated, 0 removed

  $ cat large1

  large11

  $ cat sub/large2

  large22

Rebasing between two repositories does not revert largefiles to old

revisions (this was a very bad bug that took a lot of work to fix).

  $ cd ..

  $ hg clone a d

  updating to branch default

  5 files updated, 0 files merged, 0 files removed, 0 files unresolved

  getting changed largefiles

  3 largefiles updated, 0 removed

  $ cd b

  $ echo large4-modified > sub/large4

  $ echo normal3-modified > normal3

  $ hg commit -m "modify normal file and largefile in repo b"

  $ cd ../d

  $ echo large6-modified > sub2/large6

  $ echo normal4-modified > sub/normal4

  $ hg commit -m "modify normal file largefile in repo d"

  $ cd ..

  $ hg clone d e

  updating to branch default

  5 files updated, 0 files merged, 0 files removed, 0 files unresolved

  getting changed largefiles

  3 largefiles updated, 0 removed

  $ cd d

  $ hg pull --rebase ../b

  pulling from ../b

  searching for changes

  adding changesets

  adding manifests

  adding file changes

  added 1 changesets with 2 changes to 2 files (+1 heads)

  getting changed largefiles

  1 largefiles updated, 0 removed

  saved backup bundle to $TESTTMP/d/.hg/strip-backup/f574fb32bb45-backup.hg (glob)