#testcases stripbased phasebased

  $ cat <<EOF >> $HGRCPATH

  > [extensions]

  > mq =

  > [defaults]

  > diff = --nodates --git

  > qnew = --date '0 0'

  > [shelve]

  > maxbackups = 2

  > EOF

#if phasebased

  $ cat <<EOF >> $HGRCPATH

  > [format]

  > use-internal-phase = yes

  > EOF

#endif

  $ hg init repo

  $ cd repo

  $ mkdir a b

  $ echo a > a/a

  $ echo b > b/b

  $ echo c > c

  $ echo d > d

  $ echo x > x

  $ hg addremove -q

shelve has a help message

  $ hg shelve -h

  hg shelve [OPTION]... [FILE]...

  save and set aside changes from the working directory

      Shelving takes files that "hg status" reports as not clean, saves the

      modifications to a bundle (a shelved change), and reverts the files so

      that their state in the working directory becomes clean.

      To restore these changes to the working directory, using "hg unshelve";

      this will work even if you switch to a different commit.

      When no files are specified, "hg shelve" saves all not-clean files. If

      specific files or directories are named, only changes to those files are

      shelved.

      In bare shelve (when no files are specified, without interactive, include

      and exclude option), shelving remembers information if the working

      directory was on newly created branch, in other words working directory

      was on different branch than its first parent. In this situation

      unshelving restores branch information to the working directory.

      Each shelved change has a name that makes it easier to find later. The

      name of a shelved change defaults to being based on the active bookmark,

      or if there is no active bookmark, the current named branch.  To specify a

      different name, use "--name".

      To see a list of existing shelved changes, use the "--list" option. For

      each shelved change, this will print its name, age, and description; use "

      --patch" or "--stat" for more details.

      To delete specific shelved changes, use "--delete". To delete all shelved

      changes, use "--cleanup".

  options ([+] can be repeated):

   -A --addremove           mark new/missing files as added/removed before

                            shelving

   -u --unknown             store unknown files in the shelve

      --cleanup             delete all shelved changes

      --date DATE           shelve with the specified commit date

   -d --delete              delete the named shelved change(s)

   -e --edit                invoke editor on commit messages

   -k --keep                shelve, but keep changes in the working directory

   -l --list                list current shelves

   -m --message TEXT        use text as shelve message

   -n --name NAME           use the given name for the shelved commit

   -p --patch               output patches for changes (provide the names of the

                            shelved changes as positional arguments)

   -i --interactive         interactive mode

      --stat                output diffstat-style summary of changes (provide

                            the names of the shelved changes as positional

                            arguments)

   -I --include PATTERN [+] include names matching the given patterns

   -X --exclude PATTERN [+] exclude names matching the given patterns

      --mq                  operate on patch repository

  (some details hidden, use --verbose to show complete help)

shelving in an empty repo should be possible

(this tests also that editor is not invoked, if '--edit' is not

specified)

  $ HGEDITOR=cat hg shelve

  shelved as default

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

  $ hg unshelve

  unshelving change 'default'

  $ hg commit -q -m 'initial commit'

  $ hg shelve

  nothing changed

  [1]

make sure shelve files were backed up

  $ ls .hg/shelve-backup

  default.hg

  default.patch

  default.shelve

checks to make sure we dont create a directory or

hidden file while choosing a new shelve name

when we are given a name

  $ hg shelve -n foo/bar

  abort: shelved change names can not contain slashes

  [255]

  $ hg shelve -n .baz

  abort: shelved change names can not start with '.'

  [255]

  $ hg shelve -n foo\\bar

  abort: shelved change names can not contain slashes

  [255]

when shelve has to choose itself

  $ hg branch x/y -q

  $ hg commit -q -m "Branch commit 0"

  $ hg shelve

  nothing changed

  [1]

  $ hg branch .x -q

  $ hg commit -q -m "Branch commit 1"

  $ hg shelve

  nothing changed

  [1]

  $ hg branch x\\y -q

  $ hg commit -q -m "Branch commit 2"

  $ hg shelve

  nothing changed

  [1]

cleaning the branches made for name checking tests

  $ hg up default -q

  $ hg strip e9177275307e+6a6d231f43d+882bae7c62c2 -q

create an mq patch - shelving should work fine with a patch applied

  $ echo n > n

  $ hg add n

  $ hg commit n -m second

  $ hg qnew second.patch

shelve a change that we will delete later

  $ echo a >> a/a

  $ hg shelve

  shelved as default

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

set up some more complex changes to shelve

  $ echo a >> a/a

  $ hg mv b b.rename

  moving b/b to b.rename/b

  $ hg cp c c.copy

  $ hg mv d ghost

  $ rm ghost

  $ hg status -C

  M a/a

  A b.rename/b

    b/b

  A c.copy

    c

  R b/b

  R d

  ! ghost

    d

the common case - no options or filenames

  $ hg shelve

  shelved as default-01

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

  $ hg status -C

ensure that our shelved changes exist

  $ hg shelve -l

  default-01      (*)* changes to: [mq]: second.patch (glob)

  default         (*)* changes to: [mq]: second.patch (glob)

  $ hg shelve -l -p default

  default         (*)* changes to: [mq]: second.patch (glob)

  diff --git a/a/a b/a/a

  --- a/a/a

  +++ b/a/a

  @@ -1,1 +1,2 @@

   a

  +a

  $ hg shelve --list --addremove

  abort: options '--list' and '--addremove' may not be used together

  [10]

delete our older shelved change

  $ hg shelve -d default

  $ hg qfinish -a -q

ensure shelve backups aren't overwritten

  $ ls .hg/shelve-backup/

  default-1.hg

  default-1.patch

  default-1.shelve

  default.hg

  default.patch

  default.shelve

local edits should not prevent a shelved change from applying

  $ printf "z\na\n" > a/a

  $ hg unshelve --keep

  unshelving change 'default-01'

  temporarily committing pending changes (restore with 'hg unshelve --abort')

  rebasing shelved changes

  merging a/a

  $ hg revert --all -q

  $ rm a/a.orig b.rename/b c.copy

apply it and make sure our state is as expected

(this also tests that same timestamp prevents backups from being

removed, even though there are more than 'maxbackups' backups)

  $ f -t .hg/shelve-backup/default.shelve

  .hg/shelve-backup/default.shelve: file

  $ touch -t 200001010000 .hg/shelve-backup/default.shelve

  $ f -t .hg/shelve-backup/default-1.shelve

  .hg/shelve-backup/default-1.shelve: file

  $ touch -t 200001010000 .hg/shelve-backup/default-1.shelve

  $ hg unshelve

  unshelving change 'default-01'

  $ hg status -C

  M a/a

  A b.rename/b

    b/b

  A c.copy

    c

  R b/b

  R d

  $ hg shelve -l

(both of default.hg and default-1.hg should be still kept, because it

is difficult to decide actual order of them from same timestamp)

  $ ls .hg/shelve-backup/

  default-01.hg

  default-01.patch

  default-01.shelve

  default-1.hg

  default-1.patch

  default-1.shelve

  default.hg

  default.patch

  default.shelve

  $ hg unshelve

  abort: no shelved changes to apply!

  [20]

  $ hg unshelve foo

  abort: shelved change 'foo' not found

  [10]

named shelves, specific filenames, and "commit messages" should all work

(this tests also that editor is invoked, if '--edit' is specified)

  $ hg status -C

  M a/a

  A b.rename/b

    b/b

  A c.copy

    c

  R b/b

  R d

  $ HGEDITOR=cat hg shelve -q -n wibble -m wat -e a

  wat

  HG: Enter commit message.  Lines beginning with 'HG:' are removed.

  HG: Leave message empty to abort commit.

  HG: --

  HG: user: shelve@localhost

  HG: branch 'default'

  HG: changed a/a

expect "a" to no longer be present, but status otherwise unchanged

  $ hg status -C

  A b.rename/b

    b/b

  A c.copy

    c

  R b/b

  R d

  $ hg shelve -l --stat

  wibble          (*)    wat (glob)

   a/a |  1 +

   1 files changed, 1 insertions(+), 0 deletions(-)

and now "a/a" should reappear

  $ cd a

  $ hg unshelve -q wibble

  $ cd ..

  $ hg status -C

  M a/a

  A b.rename/b

    b/b

  A c.copy

    c

  R b/b

  R d

ensure old shelve backups are being deleted automatically

  $ ls .hg/shelve-backup/

  default-01.hg

  default-01.patch

  default-01.shelve

  wibble.hg

  wibble.patch

  wibble.shelve

cause unshelving to result in a merge with 'a' conflicting

  $ hg shelve -q

  $ echo c>>a/a

  $ hg commit -m second

  $ hg tip --template '{files}\n'

  a/a

add an unrelated change that should be preserved

  $ mkdir foo

  $ echo foo > foo/foo

  $ hg add foo/foo

force a conflicted merge to occur

  $ hg unshelve

  unshelving change 'default'

  temporarily committing pending changes (restore with 'hg unshelve --abort')

  rebasing shelved changes

  merging a/a

  warning: conflicts while merging a/a! (edit, then use 'hg resolve --mark')

  unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')

  [240]

  $ hg status -v

  M a/a

  M b.rename/b

  M c.copy

  R b/b

  R d

  ? a/a.orig

  # The repository is in an unfinished *unshelve* state.

  # Unresolved merge conflicts:

  # 

  #     a/a

  # 

  # To mark files as resolved:  hg resolve --mark FILE

  # To continue:    hg unshelve --continue

  # To abort:       hg unshelve --abort

ensure that we have a merge with unresolved conflicts

#if phasebased

  $ hg heads -q --template '{rev}\n'

  8

  5

  $ hg parents -q --template '{rev}\n'

  8

  5

#endif

#if stripbased

  $ hg heads -q --template '{rev}\n'

  5

  4

  $ hg parents -q --template '{rev}\n'

  4

  5