1. 24 Aug, 2018 1 commit
  2. 13 Jul, 2018 1 commit
    • treewide: remove use of C++ style comments · 9994cd3f
      C++ style comment ("//") are not specified by the ISO C90 standard and
      thus do not conform to it. While libgit2 aims to conform to C90, we did
      not enforce it until now, which is why quite a lot of these
      non-conforming comments have snuck into our codebase. Do a tree-wide
      conversion of all C++ style comments to the supported C style comments
      to allow us enforcing strict C90 compliance in a later commit.
      Patrick Steinhardt committed
  3. 29 Jun, 2018 4 commits
    • settings: optional unsaved index safety · bfa1f022
      Add the `GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY` option, which will cause
      commands that reload the on-disk index to fail if the current
      `git_index` has changed that have not been saved.  This will prevent
      users from - for example - adding a file to the index then calling a
      function like `git_checkout` and having that file be silently removed
      from the index since it was re-read from disk.
      
      Now calls that would re-read the index will fail if the index is
      "dirty", meaning changes have been made to it but have not been written.
      Users can either `git_index_read` to discard those changes explicitly,
      or `git_index_write` to write them.
      Edward Thomson committed
    • index: return a unique error code on dirty index · 787768c2
      When the index is dirty, return GIT_EINDEXDIRTY so that consumers can
      identify the exact problem programatically.
      Edward Thomson committed
    • index: commit the changes to the index properly · b242cdbf
      Now that the index has a "dirty" state, where it has changes that have
      not yet been committed or rolled back, our tests need to be adapted to
      actually commit or rollback the changes instead of assuming that the
      index can be operated on in its indeterminate state.
      Edward Thomson committed
    • index: test dirty index bit · dc4a18c7
      Test that any changes to the index will mark the index as dirty.  Also
      ensure that when we initialize a new index, read the index contents
      from disk, or write the index contents to disk that we reset the dirty
      flag to zero.  Further ensure that an unforced read with dirty contents
      (when the on-disk index has not changed) does _not_ reset the dirty
      flag as we have not updated the contents of our index and our unsaved
      contents remain intact.
      Edward Thomson committed
  4. 26 Jun, 2018 3 commits
    • index::addall tests: write the index · 7330ae67
      When running `git_index_add_all`, we should write the index to disk so
      that we can re-read it safely during status.
      Edward Thomson committed
    • index::reuc tests: test that checkout succeeds · 08ea0d7d
      The index::reuc tests must test that the checkout itself succeeds,
      otherwise subsequent tests are not valid.
      
      In fact, the checkouts were failing because when checking out `SAFE`,
      they cannot update the files that are in conflict.  Change the checkout
      level to `FORCE` to ensure that they get updated correctly.
      Edward Thomson committed
    • index::names tests: add conflicts with high stages · c4ce017f
      We add entries into the main index to correspond with the NAME entries
      that we're going to test.  NAME entries store the results of conflicts
      occuring with rename detection during merge, and they must correspond to
      conflicts in the index.
      
      This test was mistakenly adding regular entries.  The checkout
      validation failed, since it requires NAME entries to correspond to
      high-stage (conflict) entries.  Correct the test to actually create
      conflicts.
      Edward Thomson committed
  5. 10 Jun, 2018 1 commit
  6. 19 Feb, 2018 1 commit
    • tests: index::filemodes: fix use of uninitialized memory · cabe16df
      The new index entry structure was not being initialized to all-zeroes.
      As that structure is used to add a new entry to the current index, and
      the hashing algorithm of the index making use of the uninitialized flags
      to calculate the state, we might miscompute the hash of the entry and
      add it at the wrong position. Later lookups would then fail.
      
      Initialize the structure with `memset` to fix the test breaking on some
      platforms.
      Patrick Steinhardt committed
  7. 18 Feb, 2018 1 commit
  8. 23 Jun, 2017 1 commit
    • tests: index::tests: create sandboxed repo for locking · 6ee7d37a
      The test `index::tests::can_lock_index` operates on the "testrepo.git"
      repository located inside of our source tree. While this is okay for
      tests which do read-only operations on these resouces, this specific
      test tries to lock the index by creating a lock. This will obviously
      fail on out-of-tree builds with read-only source trees.
      
      Fix the issue by creating a sandbox first.
      Patrick Steinhardt committed
  9. 06 Jun, 2017 4 commits
    • tests: index::version: improve write test for index v4 · 92d3ea4e
      The current write test does not trigger some edge-cases in the index
      version 4 path compression code. Rewrite the test to start off the an
      empty standard repository, creating index entries with interesting paths
      itself. This allows for more fine-grained control over checked paths.
      Furthermore, we now also verify that entry paths are actually
      reconstructed correctly.
      Patrick Steinhardt committed
    • tests: index::version: verify we write compressed index entries · 8fe33538
      While we do have a test which checks whether a written index of version
      4 has the correct version set, we do not check whether this actually
      enables path compression for index entries. This commit adds a new test
      by adding a number of index entries with equal path prefixes to the
      index and subsequently flushing that to disk. With suffix compression
      enabled by index version 4, only the last few bytes of these paths will
      actually have to be written to the index, saving a lot of disk space.
      For the test, differences are about an order of magnitude, allowing us
      to easily verify without taking a deeper look at actual on-disk
      contents.
      Patrick Steinhardt committed
    • tests: index::version: add test to read index version v4 · 82368b1b
      While we have a simple test to determine whether we can write an index
      of version 4, we never verified that we are able to read this kind of
      index (and in fact, we were not able to do so). Add a new repository
      which has an index of version 4. This repository is then read from a new
      test.
      Patrick Steinhardt committed
    • tests: index::version: move up cleanup function · fea0c81e
      The init and cleanup functions for test suites are usually prepended to
      our actual tests. The index::version test suite does not adhere to this
      stile. Fix this.
      Patrick Steinhardt committed
  10. 29 Aug, 2016 1 commit
  11. 10 Aug, 2016 1 commit
  12. 06 Aug, 2016 1 commit
  13. 29 Jun, 2016 1 commit
  14. 02 Jun, 2016 2 commits
  15. 11 Mar, 2016 1 commit
  16. 08 Mar, 2016 1 commit
  17. 07 Mar, 2016 1 commit
  18. 28 Feb, 2016 3 commits
  19. 25 Feb, 2016 1 commit
    • nsec: update staging test for GIT_USE_NSECS · a4c55069
      The index::nsec::staging_maintains_other_nanos test was created to
      ensure that when we stage an entry when GIT_USE_NSECS is *unset* that
      we truncate the index entry and do not persist the (old, invalid)
      nanosec values.  Ensure that when GIT_USE_NSECS is *set* that we do
      not do that, and actually write the correct nanosecond values.
      Edward Thomson committed
  20. 12 Feb, 2016 1 commit
  21. 21 Dec, 2015 1 commit
  22. 30 Nov, 2015 1 commit
  23. 20 Nov, 2015 1 commit
  24. 17 Nov, 2015 4 commits
    • racy: make git_index_read_index handle raciness · 5f32c506
      Ensure that `git_index_read_index` clears the uptodate bit on
      files that it modifies.
      
      Further, do not propagate the cache from an on-disk index into
      another on-disk index.  Although this should not be done, as
      `git_index_read_index` is used to bring an in-memory index into
      another index (that may or may not be on-disk), ensure that we do
      not accidentally bring in these bits when misused.
      Edward Thomson committed
    • racy: ensure git_index_read_tree clears uptodate · c30051f0
      Ensure that `git_index_read_tree` clears the uptodate bit on files
      that it modifies.
      Edward Thomson committed
    • index: test for smudged entries on write only · 956f4da8
      Test that entries are only smudged when we write the index: the
      entry smudging is to prevent us from updating an index in a way
      that it would be impossible to tell that an item was racy.
      Consider when we load an index:  any entries that have the same
      (or newer) timestamp than the index itself are considered racy,
      and are subject to further scrutiny.
      
      If we *save* that index with the same entries that we loaded,
      then the index would now have a newer timestamp than the entries,
      and they would no longer be given that additional scrutiny, failing
      our racy detection!  So test that we smudge those entries only on
      writing the new index, but that we can detect them (in diff) without
      having to write.
      Edward Thomson committed
    • index: don't detect raciness in uptodate entries · d1101263
      Keep track of entries that we believe are up-to-date, because we
      added the index entries since the index was loaded.  This prevents
      us from unnecessarily examining files that we wrote during the
      cleanup of racy entries (when we smudge racily clean files that have
      a timestamp newer than or equal to the index's timestamp when we
      read it).  Without keeping track of this, we would examine every
      file that we just checked out for raciness, since all their timestamps
      would be newer than the index's timestamp.
      Edward Thomson committed
  25. 12 Nov, 2015 1 commit
  26. 03 Nov, 2015 1 commit