public void StatusTest()
{
string[] A = new string[] { "A/a", "A/b", "A/c", "A/d" };
string[] B = new string[] { "B/a", "B/b", "B/c", "B/d" };
string[] C = new string[] { "C/a", "C/b", "C/c", "C/d" };
List <string> all = new List <string>();
all.AddRange(A);
all.AddRange(B);
all.AddRange(C);
using (GitRepository repo = GitRepository.Create(GetTempPath()))
{
foreach (string d in all)
{
string fp = Path.Combine(repo.WorkingCopyDirectory, d);
Directory.CreateDirectory(Path.GetDirectoryName(fp));
File.WriteAllText(fp, string.Format("This is {0}\n", fp));
repo.Index.Add(d);
}
repo.Index.Write();
using (GitClient git = new GitClient())
{
List <string> found = new List <string>();
GitStatusArgs sa = new GitStatusArgs();
git.Status(Path.Combine(repo.WorkingCopyDirectory, "B"),
delegate(object sender, GitStatusEventArgs e)
{
found.Add(e.RelativePath);
});
Assert.That(found.Count, Is.EqualTo(4));
Assert.That(found, Is.All.GreaterThan("B"));
Assert.That(found, Is.All.LessThan("C"));
found.Clear();
git.Status(Path.Combine(repo.WorkingCopyDirectory, "B/c"),
delegate(object sender, GitStatusEventArgs e)
{
found.Add(e.RelativePath);
});
Assert.That(found.Count, Is.EqualTo(1));
Assert.That(found, Is.All.Contains("B/c"));
}
}
}
public void TreeReplacements()
{
using (GitClient client = new GitClient())
{
string dir = GitTools.GetTruePath(GetTempPath(), true);
client.Init(dir);
GitStatusArgs sa = new GitStatusArgs();
sa.GenerateVersionedDirs = true;
sa.IncludeUnmodified = true;
sa.IncludeIgnored = true; // Directories with 0 files are ignored
sa.IncludeUnversioned = true;
BuildGreek(dir);
foreach (string[] k in GreekTree())
{
string p = Path.Combine(dir, k[0]);
if (File.Exists(p))
{
client.Stage(p);
}
}
client.Commit(dir);
Directory.Delete(Path.Combine(dir, "A"), true);
File.WriteAllText(Path.Combine(dir, "A"), "'A' file");
File.Delete(Path.Combine(dir, "mu"));
Directory.CreateDirectory(Path.Combine(dir, "mu"));
File.WriteAllText(Path.Combine(dir, "mu/AAAA"), "AAAA file");
List <string> paths = new List <string>();
int n = 0;
foreach (string[] s in GreekTree())
{
paths.Add(GitTools.GetNormalizedFullPath(Path.Combine(dir, s[0])));
}
paths.Add(dir);
paths.Add(Path.Combine(dir, "mu"));
paths.Add(Path.Combine(dir, "mu\\AAAA"));
/* Empty dirs are not versioned, so not reported deleted */
paths.Remove(Path.Combine(dir, "A\\C"));
paths.Remove(Path.Combine(dir, "A\\B\\F"));
List <string> paths2 = new List <string>(paths);
n = 0;
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(GitTools.IsNormalizedFullPath(e.FullPath));
Assert.IsTrue(paths.Remove(e.FullPath), "Can remove {0}", e.FullPath);
Assert.IsFalse(e.IndexModified);
Assert.IsFalse(e.WorkingDirectoryModified);
n++;
});
Assert.AreEqual(21, n);
Assert.AreEqual(0, paths.Count);
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.WorkingDirectoryStatus)
{
case GitStatus.New:
case GitStatus.Deleted:
case GitStatus.TypeChanged:
client.Stage(e.FullPath);
break;
default:
if (e.WorkingDirectoryModified)
{
goto case GitStatus.New;
}
break;
}
});
paths = new List <string>(paths2);
n = 0;
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(GitTools.IsNormalizedFullPath(e.FullPath));
Assert.IsTrue(paths.Remove(e.FullPath), "Can remove {0}", e.FullPath);
Assert.IsFalse(e.IndexModified);
Assert.IsFalse(e.WorkingDirectoryModified);
n++;
});
Assert.AreEqual(21, n);
Assert.AreEqual(0, paths.Count);
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.IndexStatus)
{
case GitStatus.New:
case GitStatus.Deleted:
case GitStatus.TypeChanged:
client.Unstage(e.FullPath);
break;
}
});
}
}
public void FullStatus()
{
using (GitClient client = new GitClient())
{
string dir = GitTools.GetTruePath(GetTempPath(), true);
client.Init(dir);
GitStatusArgs sa = new GitStatusArgs();
sa.GenerateVersionedDirs = true;
sa.IncludeUnmodified = true;
sa.IncludeIgnored = true; // Directories with 0 files are ignored
sa.IncludeDirectories = true;
BuildGreek(dir);
{
var paths = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
int n = 0;
foreach (string[] s in GreekTree())
{
paths.Add(GitTools.GetNormalizedFullPath(Path.Combine(dir, s[0])));
}
paths.Add(dir);
n = 0;
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(GitTools.IsNormalizedFullPath(e.FullPath));
Assert.IsTrue(paths.Remove(e.FullPath), "Can remove {0}", e.FullPath);
if (e.NodeKind == GitNodeKind.File)
{
Assert.AreEqual(GitStatus.None, e.IndexStatus, "Invalid index status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.New, e.WorkingDirectoryStatus, "Invalid working status on {0}", e.RelativePath);
Assert.IsFalse(e.Ignored);
}
else if (e.FullPath == dir)
{
Assert.AreEqual(GitStatus.None, e.WorkingDirectoryStatus);
Assert.IsFalse(e.Ignored);
}
else if (Path.GetFileName(e.FullPath) == "F" || Path.GetFileName(e.FullPath) == "C")
{ // Empty directory
Assert.AreEqual(GitStatus.Normal, e.WorkingDirectoryStatus, "Invalid status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.None, e.IndexStatus, "Invalid status on {0}", e.RelativePath);
Assert.IsTrue(e.Ignored);
}
else
{
Assert.AreEqual(GitStatus.None, e.IndexStatus, "Invalid status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.None, e.WorkingDirectoryStatus, "Invalid status on {0}", e.RelativePath);
Assert.IsFalse(e.Ignored);
}
n++;
});
Assert.AreEqual(19, n);
Assert.AreEqual(2, paths.Count);
}
foreach (string[] k in GreekTree())
{
string p = Path.Combine(dir, k[0]);
if (File.Exists(p))
{
client.Stage(p);
}
}
string A_dir = Path.Combine(dir, "A\\B");
{
int n = 0;
client.Status(A_dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(GitTools.IsNormalizedFullPath(e.FullPath));
Assert.IsTrue(e.FullPath.StartsWith(A_dir + "\\") || e.FullPath == A_dir);
n++;
});
Assert.AreEqual(5, n);
}
{
var paths = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
int n = 0;
foreach (string[] s in GreekTree())
{
paths.Add(GitTools.GetNormalizedFullPath(Path.Combine(dir, s[0])));
}
paths.Add(dir);
n = 0;
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(Path.IsPathRooted(e.FullPath));
Assert.IsTrue(paths.Remove(e.FullPath), "Can remove {0}", e.FullPath);
if (e.NodeKind == GitNodeKind.File)
{
Assert.AreEqual(GitStatus.New, e.IndexStatus, "Invalid index status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.Normal, e.WorkingDirectoryStatus, "Invalid working status on {0}", e.RelativePath);
Assert.IsFalse(e.Ignored);
}
else if (e.FullPath == dir)
{
Assert.AreEqual(GitStatus.None, e.WorkingDirectoryStatus);
Assert.IsFalse(e.Ignored);
}
else if (Path.GetFileName(e.FullPath) == "F" || Path.GetFileName(e.FullPath) == "C")
{ // Empty directory
Assert.AreEqual(GitStatus.Normal, e.WorkingDirectoryStatus, "Invalid status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.None, e.IndexStatus, "Invalid status on {0}", e.RelativePath);
Assert.IsTrue(e.Ignored);
}
else
{
Assert.AreEqual(GitStatus.None, e.IndexStatus, "Invalid status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.None, e.WorkingDirectoryStatus, "Invalid status on {0}", e.RelativePath);
Assert.IsFalse(e.Ignored);
}
n++;
});
Assert.AreEqual(19, n);
Assert.AreEqual(2, paths.Count);
}
client.Commit(dir);
{
List <string> paths = new List <string>();
int n = 0;
foreach (string[] s in GreekTree())
{
paths.Add(GitTools.GetNormalizedFullPath(Path.Combine(dir, s[0])));
}
paths.Add(dir);
n = 0;
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(GitTools.IsNormalizedFullPath(e.FullPath));
Assert.IsTrue(paths.Remove(e.FullPath), "Can remove {0}", e.FullPath);
Assert.AreEqual(e.NodeKind, File.Exists(e.FullPath) ? GitNodeKind.File : GitNodeKind.Directory);
Assert.IsFalse(e.IndexModified);
Assert.IsFalse(e.WorkingDirectoryModified);
n++;
});
Assert.AreEqual(19, n);
Assert.AreEqual(2, paths.Count);
}
}
}
/// <summary>
/// Refreshes the specified path using the specified depth
/// </summary>
/// <param name="path">A normalized path</param>
/// <param name="pathKind"></param>
/// <param name="depth"></param>
/// <remarks>
/// If the path is a file and depth is greater that <see cref="GitDepth.Empty"/> the parent folder is walked instead.
///
/// <para>This method guarantees that after calling it at least one up-to-date item exists
/// in the statusmap for <paramref name="path"/>. If we can not find information we create
/// an unspecified item
/// </para>
/// </remarks>
void RefreshPath(string path, SvnNodeKind pathKind)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
string walkPath = path;
bool walkingDirectory = false;
switch (pathKind)
{
case SvnNodeKind.Directory:
walkingDirectory = true;
break;
case SvnNodeKind.File:
walkPath = SvnTools.GetNormalizedDirectoryName(path);
walkingDirectory = true;
break;
default:
try
{
if (File.Exists(path)) // ### Not long path safe
{
pathKind = SvnNodeKind.File;
goto case SvnNodeKind.File;
}
}
catch (PathTooLongException)
{ /* Fall through */ }
break;
}
GitStatusArgs args = new GitStatusArgs();
args.IncludeUnversioned = true;
args.IncludeUnmodified = true;
args.IncludeIgnored = true;
//args.IncludeDirectories = true;
args.IncludeSubmodules = true;
args.GenerateVersionedDirs = true;
lock (_lock)
{
GitDirectory directory;
IGitDirectoryUpdate updateDir;
GitItem walkItem;
// We get more information for free, lets use that to update other items
if (_dirMap.TryGetValue(walkPath, out directory))
{
updateDir = directory;
updateDir.TickAll();
}
else
{
// No existing directory instance, let's create one
updateDir = directory = new GitDirectory(Context, walkPath);
_dirMap[walkPath] = directory;
}
walkItem = directory.Directory;
bool ok;
bool statSelf = false;
bool noWcAtAll = false;
string[] root;
// Don't retry file open/read operations on failure. These would only delay the result
// (default number of delays = 100)
//using (new SharpGit.Implementation.GitFsOperationRetryOverride(0))
try
{
_root = null;
ok = _client.Status(walkPath, args, RefreshCallback);
}
catch
{ ok = false; }
finally
{
root = _root;
}
if (!ok)
{
statSelf = true;
}
else if (directory != null)
{
walkItem = directory.Directory; // Might have changed via casing
}
if (!statSelf)
{
if (((IGitItemUpdate)walkItem).ShouldRefresh())
{
statSelf = true;
}
else if (walkingDirectory && !walkItem.IsVersioned)
{
statSelf = true;
}
}
if (statSelf)
{
// Git did not stat the items for us.. Let's make something up
if (walkingDirectory)
{
StatDirectory(walkPath, directory, noWcAtAll);
}
else
{
// Just stat the item passed and nothing else in the Depth.Empty case
if (walkItem == null)
{
string truepath = SvnTools.GetTruePath(walkPath); // Gets the on-disk casing if it exists
StoreItem(walkItem = CreateItem(truepath ?? walkPath,
(truepath != null) ? NoSccStatus.NotVersioned : NoSccStatus.NotExisting, SvnNodeKind.Unknown));
}
else
{
((IGitItemUpdate)walkItem).RefreshTo(walkItem.Exists ? NoSccStatus.NotVersioned : NoSccStatus.NotExisting, SvnNodeKind.Unknown);
}
}
}
if (directory != null)
{
foreach (IGitItemUpdate item in directory)
{
if (item.IsItemTicked()) // These items were not found in the stat calls
{
item.RefreshTo(NoSccStatus.NotExisting, SvnNodeKind.Unknown);
}
}
if (updateDir.ScheduleForCleanup)
{
ScheduleForCleanup(directory); // Handles removing already deleted items
}
// We keep them cached for the current command only
}
GitItem pathItem; // We promissed to return an updated item for the specified path; check if we updated it
if (!_map.TryGetValue(path, out pathItem))
{
// We did not; it does not even exist in the cache
StoreItem(pathItem = CreateItem(path, NoSccStatus.NotExisting));
if (directory != null)
{
updateDir.Store(pathItem);
ScheduleForCleanup(directory);
}
}
else
{
IGitItemUpdate update = pathItem;
if (!update.IsStatusClean())
{
update.RefreshTo(NoSccStatus.NotExisting, SvnNodeKind.Unknown); // We did not see it in the walker
if (directory != null)
{
((IGitDirectoryUpdate)directory).Store(pathItem);
ScheduleForCleanup(directory);
}
}
}
}
}
public void UseGitClient()
{
GitCommitArgs ga = new GitCommitArgs();
ga.Author.Name = "Tester";
ga.Author.EmailAddress = "*****@*****.**";
ga.Signature.Name = "Other";
ga.Signature.EmailAddress = "*****@*****.**";
// Use stable time and offset to always produce the same hash
DateTime ct = new DateTime(2002, 01, 01, 0, 0, 0, DateTimeKind.Utc);
ga.Author.When = ct;
ga.Author.TimeOffsetInMinutes = 120;
ga.Signature.When = ct;
ga.Signature.TimeOffsetInMinutes = 120;
string repoDir = GetTempPath();
string repo2Dir = GetTempPath();
GitId firstResult;
GitId lastCommit;
using (GitRepository repo = GitRepository.Create(repoDir))
using (GitClient git = new GitClient())
{
string ignoreFile = Path.Combine(repoDir, ".gitignore");
string file = Path.Combine(repoDir, "newfile");
string subDir = Path.Combine(repoDir, "dir");
string fileInSubDir = Path.Combine(subDir, "file2");
string file3 = Path.Combine(repoDir, "other");
string file4 = Path.Combine(repoDir, "q.ignore");
File.WriteAllText(file, "Some body");
Directory.CreateDirectory(subDir);
File.WriteAllText(fileInSubDir, "Some other body");
File.WriteAllText(file3, "file3");
File.WriteAllText(ignoreFile, "*.ignore\n");
File.WriteAllText(file4, "file4");
git.Add(ignoreFile);
git.Add(file);
git.Commit(repoDir, ga, out firstResult);
git.Add(fileInSubDir);
int ticked = 0;
File.AppendAllText(file, "\nExtra Line");
GitStatusArgs gsa = new GitStatusArgs();
gsa.IncludeIgnored = true;
gsa.IncludeUnmodified = true;
Assert.That(git.Status(repoDir, gsa,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.RelativePath)
{
case "newfile":
//Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Added));
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal), "newfile index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal), "newfile wc modified");
Assert.That(e.WorkingDirectoryModified);
Assert.That(e.Ignored, Is.False);
break;
case "dir/file2":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.New), "file2 index added");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal), "file2 wc normal");
Assert.That(e.Ignored, Is.False);
break;
case "other":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None));
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New));
Assert.That(e.Ignored, Is.False);
break;
case ".gitignore":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.Ignored, Is.False);
break;
case "q.ignore":
// TODO: Make this ignored
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None));
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.Ignored, Is.True);
break;
default:
Assert.Fail("Invalid node found: {0}", e.RelativePath);
break;
}
Assert.That(e.FullPath, Is.EqualTo(Path.GetFullPath(Path.Combine(repoDir, e.RelativePath))));
ticked++;
}), Is.True);
Assert.That(ticked, Is.EqualTo(5), "Ticked");
ga.LogMessage = "Intermediate";
git.Commit(repoDir, ga);
Assert.That(git.Delete(fileInSubDir));
Assert.That(git.Add(file));
GitId commit;
ga.LogMessage = "A log message to remember";
// The passed path is currently just used to find the local repository
lastCommit = new GitId("996cf198b49ed6fce3bcba232e2d88eb473560f9");
Assert.That(git.Commit(repoDir, ga, out commit));
Assert.That(commit, Is.EqualTo(lastCommit));
File.Move(file, file + ".a");
ticked = 0;
gsa.IncludeIgnored = false;
gsa.IncludeUnversioned = true;
gsa.IncludeUnmodified = false;
Assert.That(git.Status(repoDir, gsa,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.RelativePath)
{
/*case "dir":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal), "dir index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "dir wc normal");
break;*/
case "newfile":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "newfile index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Deleted), "newfile wc deleted");
break;
case "newfile.a":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "newfile.a index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "newfile.a wc new");
break;
case "other":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "other index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "other wc normal");
break;
default:
Assert.Fail("Invalid node found: {0}", e.RelativePath);
break;
}
Assert.That(e.FullPath, Is.EqualTo(Path.GetFullPath(Path.Combine(repoDir, e.RelativePath))));
ticked++;
}), Is.True);
Assert.That(ticked, Is.EqualTo(3));
GitCloneArgs gc = new GitCloneArgs();
gc.Synchronous = true;
git.Clone(repoDir, repo2Dir, gc);
GitCommit theCommit;
Assert.That(repo.Lookup(commit, out theCommit));
Assert.That(repo.Branches.Create(theCommit, "vNext"));
Assert.That(repo.Branches, Is.Not.Empty);
}
using (GitRepository repo1 = new GitRepository(repoDir))
using (GitRepository repo2 = new GitRepository(repo2Dir))
{
GitReference head = repo1.HeadReference;
Assert.That(head, Is.Not.Null, "Has head");
Assert.That(head.Name, Is.EqualTo("refs/heads/master"));
//Assert.That(repo2.Head, Is.Not.Null);
GitId headId;
Assert.That(repo1.ResolveReference(repo1.HeadReference, out headId));
Assert.That(headId, Is.EqualTo(lastCommit));
GitCommit commit;
Assert.That(repo1.Lookup(headId, out commit));
Assert.That(commit, Is.Not.Null, "Have a commit");
Assert.That(commit.Id, Is.EqualTo(lastCommit));
Assert.That(commit.Ancestors, Is.Not.Empty);
Assert.That(commit.Ancestor, Is.Not.Null);
Assert.That(commit.Ancestor.Ancestor, Is.Not.Null);
Assert.That(commit.Ancestor.Ancestor.Ancestor, Is.Null);
Assert.That(commit.Ancestor.Ancestor.Id, Is.EqualTo(firstResult));
Assert.That(commit.Author, Is.Not.Null);
Assert.That(commit.Author.Name, Is.EqualTo("Tester"));
Assert.That(commit.Author.EmailAddress, Is.EqualTo("*****@*****.**"));
Assert.That(commit.Committer, Is.Not.Null);
Assert.That(commit.Committer.Name, Is.EqualTo("Other"));
Assert.That(commit.Committer.EmailAddress, Is.EqualTo("*****@*****.**"));
Assert.That(commit.Committer.TimeOffsetInMinutes, Is.EqualTo(120), "Time offset"); // CEST dependent
Assert.That(commit.Committer.When, Is.EqualTo(ct), "Exact time");
Assert.That(commit.LogMessage, Is.EqualTo("A log message to remember\n"));
Assert.That(commit.Parents, Is.Not.Empty);
Assert.That(commit.ParentIds, Is.Not.Empty);
Assert.That(commit.Tree, Is.Not.Empty);
Assert.That(commit.Tree.Count, Is.EqualTo(2));
Assert.That(commit.Ancestor.Tree.Count, Is.EqualTo(3));
Assert.That(commit.Ancestor.Ancestor.Tree.Count, Is.EqualTo(2));
Assert.That(commit.Tree.Id, Is.Not.EqualTo(commit.Ancestor.Tree.Id));
GitId id;
Assert.That(repo1.LookupViaPrefix(commit.Id.ToString(), out id));
Assert.That(id, Is.EqualTo(commit.Id));
Assert.That(repo1.LookupViaPrefix(commit.Id.ToString().Substring(0, 10), out id));
Assert.That(id, Is.EqualTo(commit.Id));
Assert.That(commit.Peel<GitObject>().Id, Is.EqualTo(commit.Tree.Id));
Assert.That(commit.Peel<GitTree>(), Is.EqualTo(commit.Tree)); // Compares members
Assert.That(commit.Tree.Peel<GitObject>(), Is.Null);
GitTagArgs ta = new GitTagArgs();
ta.Signature.When = ct;
ta.Signature.Name = "Me";
ta.Signature.EmailAddress = "[email protected]";
ta.LogMessage = "Some message";
ga.Author.TimeOffsetInMinutes = 120;
Assert.That(commit.Tag("MyTag", ta, out id));
Assert.That(id, Is.EqualTo(new GitId("db31f8333fc64d7e7921ea91f6e007b755dcfcbb")));
GitTag tag;
Assert.That(repo1.Lookup(id, out tag));
Assert.That(tag, Is.Not.Null);
Assert.That(tag.Name, Is.EqualTo("MyTag"));
Assert.That(tag.LogMessage, Is.EqualTo("Some message\n"));
Assert.That(tag.Tagger.Name, Is.EqualTo("Me"));
Assert.That(tag.Target.Id, Is.EqualTo(commit.Id));
Assert.That(tag.Peel<GitTree>(), Is.EqualTo(commit.Peel<GitTree>()));
repo1.CheckOut(commit.Tree);
//Console.WriteLine("1:");
//foreach (GitTreeEntry e in commit.Tree)
//{
// Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
//}
//Console.WriteLine("2:");
//foreach (GitTreeEntry e in commit.Ancestor.Tree)
//{
// Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
//}
//Console.WriteLine("3:");
//foreach (GitTreeEntry e in commit.Ancestor.Ancestor.Tree)
//{
// Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
//}
//Console.WriteLine("-");
}
}
public void StatusTest()
{
string[] A = new string[] { "A/a", "A/b", "A/c", "A/d" };
string[] B = new string[] { "B/a", "B/b", "B/c", "B/d" };
string[] C = new string[] { "C/a", "C/b", "C/c", "C/d" };
List<string> all = new List<string>();
all.AddRange(A);
all.AddRange(B);
all.AddRange(C);
using (GitRepository repo = GitRepository.Create(GetTempPath()))
{
foreach (string d in all)
{
string fp = Path.Combine(repo.WorkingCopyDirectory, d);
Directory.CreateDirectory(Path.GetDirectoryName(fp));
File.WriteAllText(fp, string.Format("This is {0}\n", fp));
repo.Index.Add(d);
}
repo.Index.Write();
using (GitClient git = new GitClient())
{
List<string> found = new List<string>();
GitStatusArgs sa = new GitStatusArgs();
git.Status(Path.Combine(repo.WorkingCopyDirectory, "B"),
delegate(object sender, GitStatusEventArgs e)
{
found.Add(e.RelativePath);
});
Assert.That(found.Count, Is.EqualTo(4));
Assert.That(found, Is.All.GreaterThan("B"));
Assert.That(found, Is.All.LessThan("C"));
found.Clear();
git.Status(Path.Combine(repo.WorkingCopyDirectory, "B/c"),
delegate(object sender, GitStatusEventArgs e)
{
found.Add(e.RelativePath);
});
Assert.That(found.Count, Is.EqualTo(1));
Assert.That(found, Is.All.Contains("B/c"));
}
}
}
public void ClonePublic()
{
string repos = GetTempPath();
using (GitClient git = new GitClient())
{
GitCloneArgs ca = new GitCloneArgs();
ca.Synchronous = true;
git.Clone(new Uri("https://github.com/libgit2/TestGitRepository.git"), repos, ca);
List<string> found = new List<string>();
GitStatusArgs sa = new GitStatusArgs();
sa.IncludeUnmodified = true;
sa.UseGlobPath = true;
git.Status(repos, sa,
delegate(object sender, GitStatusEventArgs e)
{
found.Add(e.RelativePath);
});
Assert.That(found.Count, Is.EqualTo(8));
Assert.That(found, Is.All.Not.Null);
Assert.That(found, Is.Unique);
found.Clear();
git.Status(repos + "/a/*", sa,
delegate(object sender, GitStatusEventArgs e)
{
found.Add(e.RelativePath);
});
Assert.That(found.Count, Is.EqualTo(3));
Assert.That(found, Is.All.Not.Null);
Assert.That(found, Is.Unique);
GitFetchArgs fa = new GitFetchArgs();
fa.All = true;
git.Fetch(repos, fa);
using (GitRepository repo = new GitRepository(repos))
{
Assert.That(repo.HeadBranch, Is.Not.Null);
Assert.That(repo.HeadBranch.Name, Is.EqualTo("refs/heads/master"));
Assert.That(repo.HeadBranch.UpstreamReference, Is.Not.Null);
Assert.That(repo.HeadBranch.UpstreamReference.Name, Is.EqualTo("refs/remotes/origin/master"));
Assert.That(repo.HeadBranch.IsHead, "Head knows that it is head");
//Assert.That(repo.HeadBranch.TrackedBranch, Is.Null);
Assert.That(repo.HeadBranch.Name, Is.EqualTo("refs/heads/master"));
Assert.That(repo.HeadBranch.IsRemote, Is.False, "Local branch");
Assert.That(repo.HeadBranch.RemoteName, Is.EqualTo("origin"));
foreach (GitBranch b in repo.Branches.Remote)
{
Assert.That(b.IsRemote, "Remote branch");
Assert.That(b.IsLocal, Is.False, "Not local");
Assert.That(b.Name, Is.StringStarting("refs/remotes/origin/"));
Assert.That(b.IsHead, Is.False);
Assert.That(b.UpstreamReference, Is.Null);
Assert.That(b.LocalUpstreamName, Is.Null);
Assert.That(b.RemoteName, Is.EqualTo("origin"));
}
foreach (GitBranch b in repo.Branches.Local)
{
Assert.That(b.IsLocal, "Local branch");
Assert.That(b.IsRemote, Is.False, "Not remote");
Assert.That(b.Name, Is.StringStarting("refs/").Or.EqualTo("master"));
Assert.That(b.IsHead, Is.EqualTo(b.ShortName == "master"));
Assert.That(b.RemoteName, Is.EqualTo("origin"));
if (!b.IsHead)
{
Assert.That(b.LocalUpstreamName, Is.Not.Null);
GitBranch tracked = b.TrackedBranch;
Assert.That(tracked, Is.Not.Null, "Have tracked");
Assert.That(b.RemoteName, Is.Not.Null);
}
}
foreach (GitRemote r in repo.Remotes)
{
Assert.That(r.Name, Is.Not.Null);
Assert.That(r.TagSynchronize, Is.EqualTo(GitTagSynchronize.Auto));
//Assert.That(r.Save(new GitFetchArgs()));
foreach (GitRefSpec rs in r.FetchRefSpecs)
{
}
foreach (GitRefSpec rs in r.PushRefSpecs)
{
}
}
}
git.Pull(repos);
// libgit2's local push code only supports bare repositories at
// this time, so we use a few more clones to test the real push
string cloneDir = GetTempPath();
GitCloneArgs cca = new GitCloneArgs();
cca.InitArgs.CreateBareRepository = true;
git.Clone(repos, cloneDir, cca);
string clone2Dir = GetTempPath();
git.Clone(cloneDir, clone2Dir);
GitPushArgs pa = new GitPushArgs();
pa.Mode = GitPushMode.All;
git.Push(clone2Dir, pa);
}
}
public void ClonePublic()
{
string repos = GetTempPath();
using (GitClient git = new GitClient())
{
GitCloneArgs ca = new GitCloneArgs();
ca.Synchronous = true;
git.Clone(new Uri("https://github.com/libgit2/TestGitRepository.git"), repos, ca);
List <string> found = new List <string>();
GitStatusArgs sa = new GitStatusArgs();
sa.IncludeUnmodified = true;
sa.UseGlobPath = true;
git.Status(repos, sa,
delegate(object sender, GitStatusEventArgs e)
{
found.Add(e.RelativePath);
});
Assert.That(found.Count, Is.EqualTo(8));
Assert.That(found, Is.All.Not.Null);
Assert.That(found, Is.Unique);
found.Clear();
git.Status(repos + "/a/*", sa,
delegate(object sender, GitStatusEventArgs e)
{
found.Add(e.RelativePath);
});
Assert.That(found.Count, Is.EqualTo(3));
Assert.That(found, Is.All.Not.Null);
Assert.That(found, Is.Unique);
GitFetchArgs fa = new GitFetchArgs();
fa.All = true;
git.Fetch(repos, fa);
using (GitRepository repo = new GitRepository(repos))
{
Assert.That(repo.HeadBranch, Is.Not.Null);
Assert.That(repo.HeadBranch.Name, Is.EqualTo("refs/heads/master"));
Assert.That(repo.HeadBranch.UpstreamReference, Is.Not.Null);
Assert.That(repo.HeadBranch.UpstreamReference.Name, Is.EqualTo("refs/remotes/origin/master"));
Assert.That(repo.HeadBranch.IsHead, "Head knows that it is head");
//Assert.That(repo.HeadBranch.TrackedBranch, Is.Null);
Assert.That(repo.HeadBranch.Name, Is.EqualTo("refs/heads/master"));
Assert.That(repo.HeadBranch.IsRemote, Is.False, "Local branch");
Assert.That(repo.HeadBranch.RemoteName, Is.EqualTo("origin"));
foreach (GitBranch b in repo.Branches.Remote)
{
Assert.That(b.IsRemote, "Remote branch");
Assert.That(b.IsLocal, Is.False, "Not local");
Assert.That(b.Name, Is.SubPathOf("refs/remotes/origin/"));
Assert.That(b.IsHead, Is.False);
Assert.That(b.UpstreamReference, Is.Null);
Assert.That(b.LocalUpstreamName, Is.Null);
Assert.That(b.RemoteName, Is.EqualTo("origin"));
}
foreach (GitBranch b in repo.Branches.Local)
{
Assert.That(b.IsLocal, "Local branch");
Assert.That(b.IsRemote, Is.False, "Not remote");
Assert.That(b.Name, Is.SubPathOf("refs/").Or.EqualTo("master"));
Assert.That(b.IsHead, Is.EqualTo(b.ShortName == "master"));
Assert.That(b.RemoteName, Is.EqualTo("origin"));
if (!b.IsHead)
{
Assert.That(b.LocalUpstreamName, Is.Not.Null);
GitBranch tracked = b.TrackedBranch;
Assert.That(tracked, Is.Not.Null, "Have tracked");
Assert.That(b.RemoteName, Is.Not.Null);
}
}
foreach (GitRemote r in repo.Remotes)
{
Assert.That(r.Name, Is.Not.Null);
Assert.That(r.TagSynchronize, Is.EqualTo(GitTagSynchronize.Auto));
//Assert.That(r.Save(new GitFetchArgs()));
foreach (GitRefSpec rs in r.FetchRefSpecs)
{
}
foreach (GitRefSpec rs in r.PushRefSpecs)
{
}
}
}
git.Pull(repos);
// libgit2's local push code only supports bare repositories at
// this time, so we use a few more clones to test the real push
string cloneDir = GetTempPath();
GitCloneArgs cca = new GitCloneArgs();
cca.InitArgs.CreateBareRepository = true;
git.Clone(repos, cloneDir, cca);
string clone2Dir = GetTempPath();
git.Clone(cloneDir, clone2Dir);
GitPushArgs pa = new GitPushArgs();
pa.Mode = GitPushMode.All;
git.Push(clone2Dir, pa);
}
}
public void UseGitClient()
{
GitCommitArgs ga = new GitCommitArgs();
ga.Author.Name = "Tester";
ga.Author.EmailAddress = "*****@*****.**";
ga.Signature.Name = "Other";
ga.Signature.EmailAddress = "*****@*****.**";
// Use stable time and offset to always produce the same hash
DateTime ct = new DateTime(2002, 01, 01, 0, 0, 0, DateTimeKind.Utc);
ga.Author.When = ct;
ga.Author.TimeOffsetInMinutes = 120;
ga.Signature.When = ct;
ga.Signature.TimeOffsetInMinutes = 120;
string repoDir = GetTempPath();
string repo2Dir = GetTempPath();
GitId firstResult;
GitId lastCommit;
using (GitRepository repo = GitRepository.Create(repoDir))
using (GitClient git = new GitClient())
{
string ignoreFile = Path.Combine(repoDir, ".gitignore");
string file = Path.Combine(repoDir, "newfile");
string subDir = Path.Combine(repoDir, "dir");
string fileInSubDir = Path.Combine(subDir, "file2");
string file3 = Path.Combine(repoDir, "other");
string file4 = Path.Combine(repoDir, "q.ignore");
File.WriteAllText(file, "Some body");
Directory.CreateDirectory(subDir);
File.WriteAllText(fileInSubDir, "Some other body");
File.WriteAllText(file3, "file3");
File.WriteAllText(ignoreFile, "*.ignore\n");
File.WriteAllText(file4, "file4");
git.Add(ignoreFile);
git.Add(file);
git.Commit(repoDir, ga, out firstResult);
git.Add(fileInSubDir);
int ticked = 0;
File.AppendAllText(file, "\nExtra Line");
GitStatusArgs gsa = new GitStatusArgs();
gsa.IncludeIgnored = true;
gsa.IncludeUnmodified = true;
Assert.That(git.Status(repoDir, gsa,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.RelativePath)
{
case "newfile":
//Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Added));
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal), "newfile index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal), "newfile wc modified");
Assert.That(e.WorkingDirectoryModified);
Assert.That(e.Ignored, Is.False);
break;
case "dir/file2":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.New), "file2 index added");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal), "file2 wc normal");
Assert.That(e.Ignored, Is.False);
break;
case "other":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None));
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New));
Assert.That(e.Ignored, Is.False);
break;
case ".gitignore":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.Ignored, Is.False);
break;
case "q.ignore":
// TODO: Make this ignored
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None));
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.Ignored, Is.True);
break;
default:
Assert.Fail("Invalid node found: {0}", e.RelativePath);
break;
}
Assert.That(e.FullPath, Is.EqualTo(Path.GetFullPath(Path.Combine(repoDir, e.RelativePath))));
ticked++;
}), Is.True);
Assert.That(ticked, Is.EqualTo(5), "Ticked");
ga.LogMessage = "Intermediate";
git.Commit(repoDir, ga);
Assert.That(git.Delete(fileInSubDir));
Assert.That(git.Add(file));
GitId commit;
ga.LogMessage = "A log message to remember";
// The passed path is currently just used to find the local repository
lastCommit = new GitId("996cf198b49ed6fce3bcba232e2d88eb473560f9");
Assert.That(git.Commit(repoDir, ga, out commit));
Assert.That(commit, Is.EqualTo(lastCommit));
File.Move(file, file + ".a");
ticked = 0;
gsa.IncludeIgnored = false;
gsa.IncludeUnversioned = true;
gsa.IncludeUnmodified = false;
Assert.That(git.Status(repoDir, gsa,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.RelativePath)
{
/*case "dir":
* Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal), "dir index normal");
* Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "dir wc normal");
* break;*/
case "newfile":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "newfile index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Deleted), "newfile wc deleted");
break;
case "newfile.a":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "newfile.a index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "newfile.a wc new");
break;
case "other":
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "other index normal");
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "other wc normal");
break;
default:
Assert.Fail("Invalid node found: {0}", e.RelativePath);
break;
}
Assert.That(e.FullPath, Is.EqualTo(Path.GetFullPath(Path.Combine(repoDir, e.RelativePath))));
ticked++;
}), Is.True);
Assert.That(ticked, Is.EqualTo(3));
GitCloneArgs gc = new GitCloneArgs();
gc.Synchronous = true;
git.Clone(repoDir, repo2Dir, gc);
GitCommit theCommit;
Assert.That(repo.Lookup(commit, out theCommit));
Assert.That(repo.Branches.Create(theCommit, "vNext"));
Assert.That(repo.Branches, Is.Not.Empty);
}
using (GitRepository repo1 = new GitRepository(repoDir))
using (GitRepository repo2 = new GitRepository(repo2Dir))
{
GitReference head = repo1.HeadReference;
Assert.That(head, Is.Not.Null, "Has head");
Assert.That(head.Name, Is.EqualTo("refs/heads/master"));
//Assert.That(repo2.Head, Is.Not.Null);
GitId headId;
Assert.That(repo1.ResolveReference(repo1.HeadReference, out headId));
Assert.That(headId, Is.EqualTo(lastCommit));
GitCommit commit;
Assert.That(repo1.Lookup(headId, out commit));
Assert.That(commit, Is.Not.Null, "Have a commit");
Assert.That(commit.Id, Is.EqualTo(lastCommit));
Assert.That(commit.Ancestors, Is.Not.Empty);
Assert.That(commit.Ancestor, Is.Not.Null);
Assert.That(commit.Ancestor.Ancestor, Is.Not.Null);
Assert.That(commit.Ancestor.Ancestor.Ancestor, Is.Null);
Assert.That(commit.Ancestor.Ancestor.Id, Is.EqualTo(firstResult));
Assert.That(commit.Author, Is.Not.Null);
Assert.That(commit.Author.Name, Is.EqualTo("Tester"));
Assert.That(commit.Author.EmailAddress, Is.EqualTo("*****@*****.**"));
Assert.That(commit.Committer, Is.Not.Null);
Assert.That(commit.Committer.Name, Is.EqualTo("Other"));
Assert.That(commit.Committer.EmailAddress, Is.EqualTo("*****@*****.**"));
Assert.That(commit.Committer.TimeOffsetInMinutes, Is.EqualTo(120), "Time offset"); // CEST dependent
Assert.That(commit.Committer.When, Is.EqualTo(ct), "Exact time");
Assert.That(commit.LogMessage, Is.EqualTo("A log message to remember\n"));
Assert.That(commit.Parents, Is.Not.Empty);
Assert.That(commit.ParentIds, Is.Not.Empty);
Assert.That(commit.Tree, Is.Not.Empty);
Assert.That(commit.Tree.Count, Is.EqualTo(2));
Assert.That(commit.Ancestor.Tree.Count, Is.EqualTo(3));
Assert.That(commit.Ancestor.Ancestor.Tree.Count, Is.EqualTo(2));
Assert.That(commit.Tree.Id, Is.Not.EqualTo(commit.Ancestor.Tree.Id));
GitId id;
Assert.That(repo1.LookupViaPrefix(commit.Id.ToString(), out id));
Assert.That(id, Is.EqualTo(commit.Id));
Assert.That(repo1.LookupViaPrefix(commit.Id.ToString().Substring(0, 10), out id));
Assert.That(id, Is.EqualTo(commit.Id));
Assert.That(commit.Peel <GitObject>().Id, Is.EqualTo(commit.Tree.Id));
Assert.That(commit.Peel <GitTree>(), Is.EqualTo(commit.Tree)); // Compares members
Assert.That(commit.Tree.Peel <GitObject>(), Is.Null);
GitTagArgs ta = new GitTagArgs();
ta.Signature.When = ct;
ta.Signature.Name = "Me";
ta.Signature.EmailAddress = "[email protected]";
ta.LogMessage = "Some message";
ga.Author.TimeOffsetInMinutes = 120;
Assert.That(commit.Tag("MyTag", ta, out id));
Assert.That(id, Is.EqualTo(new GitId("db31f8333fc64d7e7921ea91f6e007b755dcfcbb")));
GitTag tag;
Assert.That(repo1.Lookup(id, out tag));
Assert.That(tag, Is.Not.Null);
Assert.That(tag.Name, Is.EqualTo("MyTag"));
Assert.That(tag.LogMessage, Is.EqualTo("Some message\n"));
Assert.That(tag.Tagger.Name, Is.EqualTo("Me"));
Assert.That(tag.Target.Id, Is.EqualTo(commit.Id));
Assert.That(tag.Peel <GitTree>(), Is.EqualTo(commit.Peel <GitTree>()));
repo1.CheckOut(commit.Tree);
//Console.WriteLine("1:");
//foreach (GitTreeEntry e in commit.Tree)
//{
// Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
//}
//Console.WriteLine("2:");
//foreach (GitTreeEntry e in commit.Ancestor.Tree)
//{
// Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
//}
//Console.WriteLine("3:");
//foreach (GitTreeEntry e in commit.Ancestor.Ancestor.Tree)
//{
// Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
//}
//Console.WriteLine("-");
}
}
public void TreeReplacements()
{
using (GitClient client = new GitClient())
{
string dir = GitTools.GetTruePath(GetTempPath(), true);
client.Init(dir);
GitStatusArgs sa = new GitStatusArgs();
sa.GenerateVersionedDirs = true;
sa.IncludeUnmodified = true;
sa.IncludeIgnored = true; // Directories with 0 files are ignored
sa.IncludeUnversioned = true;
BuildGreek(dir);
foreach (string[] k in GreekTree())
{
string p = Path.Combine(dir, k[0]);
if (File.Exists(p))
client.Stage(p);
}
client.Commit(dir);
Directory.Delete(Path.Combine(dir, "A"), true);
File.WriteAllText(Path.Combine(dir, "A"), "'A' file");
File.Delete(Path.Combine(dir, "mu"));
Directory.CreateDirectory(Path.Combine(dir, "mu"));
File.WriteAllText(Path.Combine(dir, "mu/AAAA"), "AAAA file");
List<string> paths = new List<string>();
int n = 0;
foreach (string[] s in GreekTree())
paths.Add(GitTools.GetNormalizedFullPath(Path.Combine(dir, s[0])));
paths.Add(dir);
paths.Add(Path.Combine(dir, "mu"));
paths.Add(Path.Combine(dir, "mu\\AAAA"));
/* Empty dirs are not versioned, so not reported deleted */
paths.Remove(Path.Combine(dir, "A\\C"));
paths.Remove(Path.Combine(dir, "A\\B\\F"));
List<string> paths2 = new List<string>(paths);
n = 0;
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(GitTools.IsNormalizedFullPath(e.FullPath));
Assert.IsTrue(paths.Remove(e.FullPath), "Can remove {0}", e.FullPath);
Assert.IsFalse(e.IndexModified);
Assert.IsFalse(e.WorkingDirectoryModified);
n++;
});
Assert.AreEqual(21, n);
Assert.AreEqual(0, paths.Count);
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.WorkingDirectoryStatus)
{
case GitStatus.New:
case GitStatus.Deleted:
case GitStatus.TypeChanged:
client.Stage(e.FullPath);
break;
default:
if (e.WorkingDirectoryModified)
goto case GitStatus.New;
break;
}
});
paths = new List<string>(paths2);
n = 0;
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(GitTools.IsNormalizedFullPath(e.FullPath));
Assert.IsTrue(paths.Remove(e.FullPath), "Can remove {0}", e.FullPath);
Assert.IsFalse(e.IndexModified);
Assert.IsFalse(e.WorkingDirectoryModified);
n++;
});
Assert.AreEqual(21, n);
Assert.AreEqual(0, paths.Count);
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.IndexStatus)
{
case GitStatus.New:
case GitStatus.Deleted:
case GitStatus.TypeChanged:
client.Unstage(e.FullPath);
break;
}
});
}
}
public void FullStatus()
{
using(GitClient client = new GitClient())
{
string dir = GitTools.GetTruePath(GetTempPath(), true);
client.Init(dir);
GitStatusArgs sa = new GitStatusArgs();
sa.GenerateVersionedDirs = true;
sa.IncludeUnmodified = true;
sa.IncludeIgnored = true; // Directories with 0 files are ignored
BuildGreek(dir);
{
List<string> paths = new List<string>();
int n = 0;
foreach (string[] s in GreekTree())
paths.Add(GitTools.GetNormalizedFullPath(Path.Combine(dir, s[0])));
paths.Add(dir);
n = 0;
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(GitTools.IsNormalizedFullPath(e.FullPath));
Assert.IsTrue(paths.Remove(e.FullPath), "Can remove {0}", e.FullPath);
if (e.NodeKind == GitNodeKind.File)
{
Assert.AreEqual(GitStatus.None, e.IndexStatus, "Invalid index status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.New, e.WorkingDirectoryStatus, "Invalid working status on {0}", e.RelativePath);
Assert.IsFalse(e.Ignored);
}
else if (e.FullPath == dir)
{
Assert.AreEqual(GitStatus.None, e.WorkingDirectoryStatus);
Assert.IsFalse(e.Ignored);
}
else if (Path.GetFileName(e.FullPath) == "F" || Path.GetFileName(e.FullPath) == "C")
{ // Empty directory
Assert.AreEqual(GitStatus.Normal, e.WorkingDirectoryStatus, "Invalid status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.None, e.IndexStatus, "Invalid status on {0}", e.RelativePath);
Assert.IsTrue(e.Ignored);
}
else
{
Assert.AreEqual(GitStatus.None, e.IndexStatus, "Invalid status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.None, e.WorkingDirectoryStatus, "Invalid status on {0}", e.RelativePath);
Assert.IsFalse(e.Ignored);
}
n++;
});
Assert.AreEqual(21, n);
Assert.AreEqual(0, paths.Count);
}
foreach (string[] k in GreekTree())
{
string p = Path.Combine(dir, k[0]);
if (File.Exists(p))
client.Stage(p);
}
string A_dir = Path.Combine(dir, "A\\B");
{
int n = 0;
client.Status(A_dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(GitTools.IsNormalizedFullPath(e.FullPath));
Assert.IsTrue(e.FullPath.StartsWith(A_dir + "\\") || e.FullPath == A_dir);
n++;
});
Assert.AreEqual(6, n);
}
{
List<string> paths = new List<string>();
int n = 0;
foreach (string[] s in GreekTree())
paths.Add(GitTools.GetNormalizedFullPath(Path.Combine(dir, s[0])));
paths.Add(dir);
n = 0;
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(Path.IsPathRooted(e.FullPath));
Assert.IsTrue(paths.Remove(e.FullPath), "Can remove {0}", e.FullPath);
if (e.NodeKind == GitNodeKind.File)
{
Assert.AreEqual(GitStatus.New, e.IndexStatus, "Invalid index status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.Normal, e.WorkingDirectoryStatus, "Invalid working status on {0}", e.RelativePath);
Assert.IsFalse(e.Ignored);
}
else if (e.FullPath == dir)
{
Assert.AreEqual(GitStatus.None, e.WorkingDirectoryStatus);
Assert.IsFalse(e.Ignored);
}
else if (Path.GetFileName(e.FullPath) == "F" || Path.GetFileName(e.FullPath) == "C")
{ // Empty directory
Assert.AreEqual(GitStatus.Normal, e.WorkingDirectoryStatus, "Invalid status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.None, e.IndexStatus, "Invalid status on {0}", e.RelativePath);
Assert.IsTrue(e.Ignored);
}
else
{
Assert.AreEqual(GitStatus.None, e.IndexStatus, "Invalid status on {0}", e.RelativePath);
Assert.AreEqual(GitStatus.None, e.WorkingDirectoryStatus, "Invalid status on {0}", e.RelativePath);
Assert.IsFalse(e.Ignored);
}
n++;
});
Assert.AreEqual(21, n);
Assert.AreEqual(0, paths.Count);
}
client.Commit(dir);
{
List<string> paths = new List<string>();
int n = 0;
foreach (string[] s in GreekTree())
paths.Add(GitTools.GetNormalizedFullPath(Path.Combine(dir, s[0])));
paths.Add(dir);
n = 0;
client.Status(dir, sa,
delegate(object sender, GitStatusEventArgs e)
{
Assert.IsTrue(GitTools.IsNormalizedFullPath(e.FullPath));
Assert.IsTrue(paths.Remove(e.FullPath), "Can remove {0}", e.FullPath);
Assert.AreEqual(e.NodeKind, File.Exists(e.FullPath) ? GitNodeKind.File : GitNodeKind.Directory);
Assert.IsFalse(e.IndexModified);
Assert.IsFalse(e.WorkingDirectoryModified);
n++;
});
Assert.AreEqual(21, n);
Assert.AreEqual(0, paths.Count);
}
}
}
