Add a test to assure we can detect conflicts

Author: Byron

gix-worktree/src/index/status/mod.rs

@@ -32,11 +32,11 @@ pub enum Change<T = ()> {
         /// changed than this is `None`.
         content_change: Option<T>,
     },
-    /// An index entry that correspond to an untracked worktree file marked with `git add`.
+    /// An index entry that correspond to an untracked worktree file marked with `git add --intent-to-add`.
     ///
-    /// This means it's not available in the git tree yet that the index was created from,
+    /// This means it's not available in the object database yet or the index was created from,
     /// even though now an entry exists that represents the worktree file.
-    Added,
+    IntentToAdd,
 }
 
 /// Observe changes by comparing an index entry to the worktree or another index.

gix-worktree/src/index/status/worktree.rs

@@ -46,6 +46,9 @@ pub struct Options {
 /// observable in `collector`, along with information produced by `compare` which gets to see blobs that may have changes.
 /// `options` are used to configure the operation.
 ///
+/// Note that `index` is updated with the latest seen stat information from the worktree, and its timestamp is adjusted to
+/// the current time for which it will be considered fresh.
+///
 /// Note that this isn't technically quite what this function does as this also provides some additional information,
 /// like whether a file has conflicts, and files that were added with `git add` are shown as a special
 /// changes despite not technically requiring a change to the index since `git add` already added the file to the index.
@@ -222,7 +225,7 @@ impl<'index> State<'_, 'index> {
             }
         };
         if entry.flags.contains(index::entry::Flags::INTENT_TO_ADD) {
-            return Ok(Some(Change::Added));
+            return Ok(Some(Change::IntentToAdd));
         }
         let new_stat = index::entry::Stat::from_fs(&metadata)?;
         let executable_bit_changed =

gix-worktree/tests/fixtures/generated-archives/status_conflict.tar.xz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd6d32ab7a1e372d80a617926cac2463f6620baedf74642d78fe7f8c956fd031
+size 11036

gix-worktree/tests/fixtures/generated-archives/status_intent_to_add.tar.xz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:876670d74c01249d361aa73d83ab20d846db7c922a3ca825f778b5f9d746c401
+size 9304

gix-worktree/tests/fixtures/status_conflict.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+set -eu -o pipefail
+
+git init -q
+
+echo base > content
+git add -A
+git commit -m "base"
+
+git checkout -b feat
+echo feat > content
+git commit -am "feat"
+
+git checkout main
+echo base-change > content
+git commit -am "new base"
+
+git merge feat || :

gix-worktree/tests/fixtures/status_intent_to_add.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+set -eu -o pipefail
+
+git init -q
+
+touch content
+echo -n "content" > content
+
+git add --intent-to-add -A

gix-worktree/tests/worktree/index/status.rs

@@ -1,13 +1,13 @@
 use bstr::BStr;
 use filetime::{set_file_mtime, FileTime};
-use gix_features::threading::OwnShared;
 use gix_index as index;
 use gix_index::Entry;
 use gix_utils::FilesystemCapabilities;
 use gix_worktree::index::status::content::{FastEq, ReadDataOnce};
 use gix_worktree::index::status::worktree::{self, Options};
 use gix_worktree::index::status::{Change, CompareBlobs, Recorder};
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
 
 use crate::fixture_path;
 
@@ -57,45 +57,36 @@ fn removed() {
     );
 }
 
+#[test]
+fn intent_to_add() {
+    fixture(
+        "status_intent_to_add",
+        &[(BStr::new(b"content"), Some(Change::IntentToAdd), false)],
+    );
+}
+
+#[test]
+fn conflict() {
+    fixture(
+        "status_conflict",
+        &[(
+            BStr::new(b"content"),
+            Some(Change::Modification {
+                executable_bit_changed: false,
+                content_change: Some(()),
+            }),
+            true,
+        )],
+    );
+}
+
 #[test]
 fn unchanged() {
     fixture("status_unchanged", &[]);
 }
 
 #[test]
 fn modified() {
-    // run the same status check twice to ensure that racy detection
-    // doesn't change the result of the status check
-    fixture(
-        "status_changed",
-        &[
-            (
-                BStr::new(b"dir/content"),
-                Some(Change::Modification {
-                    executable_bit_changed: true,
-                    content_change: None,
-                }),
-                false,
-            ),
-            (
-                BStr::new(b"dir/content2"),
-                Some(Change::Modification {
-                    executable_bit_changed: false,
-                    content_change: Some(()),
-                }),
-                false,
-            ),
-            (BStr::new(b"empty"), Some(Change::Type), false),
-            (
-                BStr::new(b"executable"),
-                Some(Change::Modification {
-                    executable_bit_changed: true,
-                    content_change: Some(()),
-                }),
-                false,
-            ),
-        ],
-    );
     fixture(
         "status_changed",
         &[
@@ -141,7 +132,7 @@ fn racy_git() {
     let mut index = gix_index::File::at(git_dir.join("index"), gix_hash::Kind::Sha1, Default::default()).unwrap();
 
     #[derive(Clone)]
-    struct CountCalls(OwnShared<AtomicUsize>, FastEq);
+    struct CountCalls(Arc<AtomicUsize>, FastEq);
     impl CompareBlobs for CountCalls {
         type Output = ();
 
@@ -169,7 +160,7 @@ fn racy_git() {
         .expect("changing filetime works");
     let mut recorder = Recorder::default();
 
-    let count = OwnShared::new(AtomicUsize::new(0));
+    let count = Arc::new(AtomicUsize::new(0));
     let counter = CountCalls(count.clone(), FastEq);
     worktree::changes_to_obtain(
         &mut index,