public void ShouldResetRepositoryState()
{
InitializePlatformAndEnvironment(TestRepoMasterCleanSynchronized);
const string initialFile = "init-file.txt";
const string testFile = "reset-file.txt";
// Initial commit
initialFile.ToNPath().WriteAllText("Some test text.");
GitClient.Add(new List <string> {
initialFile
}).RunSynchronously();
GitClient.Commit("initial", "commit").RunSynchronously();
// Add file
testFile.ToNPath().WriteAllText("Some test text.");
GitClient.Add(new List <string> {
testFile
}).RunSynchronously();
GitClient.Commit("test", "commit").RunSynchronously();
testFile.ToNPath().Exists().Should().BeTrue();
// Reset to commit without file
GitClient.Reset("HEAD~1", GitResetMode.Hard).RunSynchronously();
testFile.ToNPath().Exists().Should().BeFalse();
}
void OnGUI()
{
GUILayout.Label("Custom Git", EditorStyles.boldLabel);
if (GUILayout.Button("Commit Stuff"))
{
gitClient.AddAll().Then(gitClient.Commit(DateTime.Now.ToString(), string.Empty)).Start();
}
}
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);
}
}
}
public async Task ShouldDetectFileChangesAndCommit()
{
Logger.Trace("Starting ShouldDetectFileChangesAndCommit");
try
{
InitializePlatformAndEnvironment(TestRepoMasterCleanSynchronized);
using (var repositoryWatcher = CreateRepositoryWatcher(TestRepoMasterCleanSynchronized))
{
var watcherAutoResetEvent = new RepositoryWatcherAutoResetEvent();
var repositoryWatcherListener = Substitute.For <IRepositoryWatcherListener>();
repositoryWatcherListener.AttachListener(repositoryWatcher, watcherAutoResetEvent);
repositoryWatcher.Initialize();
repositoryWatcher.Start();
repositoryWatcher.Stop();
try
{
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
Logger.Trace("Issuing Changes");
foobarTxt.WriteAllText("foobar");
await TaskManager.Wait();
Logger.Trace("Continue test");
repositoryWatcher.Start();
watcherAutoResetEvent.RepositoryChanged.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
watcherAutoResetEvent.Reset();
repositoryWatcherListener.DidNotReceive().HeadChanged();
repositoryWatcherListener.DidNotReceive().ConfigChanged();
repositoryWatcherListener.DidNotReceive().RepositoryCommitted();
repositoryWatcherListener.DidNotReceive().IndexChanged();
repositoryWatcherListener.Received().RepositoryChanged();
repositoryWatcherListener.DidNotReceive().LocalBranchesChanged();
repositoryWatcherListener.DidNotReceive().RemoteBranchesChanged();
repositoryWatcherListener.ClearReceivedCalls();
repositoryWatcher.Stop();
Logger.Trace("Issuing Command");
await GitClient.AddAll().StartAsAsync();
Logger.Trace("Completed Command");
repositoryWatcher.Start();
watcherAutoResetEvent.IndexChanged.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
watcherAutoResetEvent.Reset();
repositoryWatcherListener.DidNotReceive().HeadChanged();
repositoryWatcherListener.DidNotReceive().ConfigChanged();
repositoryWatcherListener.DidNotReceive().RepositoryCommitted();
repositoryWatcherListener.Received(1).IndexChanged();
repositoryWatcherListener.DidNotReceive().RepositoryChanged();
repositoryWatcherListener.DidNotReceive().LocalBranchesChanged();
repositoryWatcherListener.DidNotReceive().RemoteBranchesChanged();
repositoryWatcherListener.ClearReceivedCalls();
repositoryWatcher.Stop();
Logger.Trace("Issuing Command");
await GitClient.Commit("Test Commit", string.Empty).StartAsAsync();
Logger.Trace("Completed Command");
repositoryWatcher.Start();
watcherAutoResetEvent.RepositoryCommitted.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
watcherAutoResetEvent.IndexChanged.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
watcherAutoResetEvent.Reset();
repositoryWatcherListener.DidNotReceive().HeadChanged();
repositoryWatcherListener.DidNotReceive().ConfigChanged();
repositoryWatcherListener.Received(1).RepositoryCommitted();
repositoryWatcherListener.Received(1).IndexChanged();
repositoryWatcherListener.DidNotReceive().RepositoryChanged();
repositoryWatcherListener.Received(1).LocalBranchesChanged();
repositoryWatcherListener.DidNotReceive().RemoteBranchesChanged();
repositoryWatcherListener.ClearReceivedCalls();
}
finally
{
repositoryWatcher.Stop();
}
}
}
finally
{
Logger.Trace("Ending ShouldDetectFileChangesAndCommit");
}
}
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 PushChanges()
{
string master = GetTempPath();
using (GitClient git = new GitClient())
{
GitInitArgs ia = new GitInitArgs();
ia.CreateBareRepository = true;
ia.Description = "Harry & Sally root";
git.Init(master, ia);
}
Uri masterUri = new Uri(master);
string harry = GetTempPath();
string sally = GetTempPath();
using (GitClient git = new GitClient()) // Harry
{
git.Clone(masterUri, harry);
using (GitRepository harryRepo = new GitRepository(harry))
{
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Harry");
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string src = Path.Combine(harry, "src");
Directory.CreateDirectory(src);
string index = Path.Combine(src, "index.txt");
File.WriteAllText(index, "This is index.txt\n");
string appCode = Path.Combine(harry, "app.c");
File.WriteAllText(appCode, @"
#include <stdio.h>
int main(int argc, const char **argv)
{
printf(""hello world\n"");
return 0;
}
");
git.Add(index);
git.Add(appCode);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
git.Commit(harry, cma, out result);
using (GitRepository harryRepo = new GitRepository(harry))
{
GitCommit commit;
Assert.That(harryRepo.Lookup(result, out commit));
Assert.That(commit.Author.Name, Is.EqualTo("Harry"));
}
}
using (GitClient git = new GitClient()) // Sally
{
git.Clone(masterUri, sally);
using (GitRepository sallyRepo = new GitRepository(sally))
{
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Sally");
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.False);
}
using (GitClient git = new GitClient()) // Harry
{
GitPushArgs pa = new GitPushArgs();
pa.Mode = GitPushMode.All;
git.Push(harry, pa);
}
using (GitClient git = new GitClient()) // Sally
{
GitPullArgs pa = new GitPullArgs();
pa.FetchArgs.All = true;
git.Pull(sally, pa);
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.True);
string appCode = Path.Combine(sally, "app.c");
File.WriteAllText(appCode, @"
#include <stdio.h>
int main(int argc, const char **argv)
{
int i;
if (argc != 1)
{
fprintf(stderr, ""Usage %s <int>\n"", argv[0]);
return 1;
}
for (i = 0; i < atoi(argv[1]); i++
printf(""hello world %d\n"", i);
return 0;
}
");
git.Add(appCode);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 2, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 2, 0, 0, 0, DateTimeKind.Utc);
git.Commit(sally, cma, out result);
GitPushArgs ph = new GitPushArgs();
ph.Mode = GitPushMode.All;
git.Push(sally, ph);
}
using (GitClient git = new GitClient()) // Harry
{
string appCode = Path.Combine(harry, "app.c");
File.WriteAllText(appCode, @"
#include <stdio.h>
int main(int argc, const char **argv)
{
if (argc > 0 && strcmp(argv[1], ""-V"")
{
printf(""%s version 1.0 (c) QQn\n"");
return 0;
}
printf(""hello world\n"");
return 0;
}
");
git.Add(appCode);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 3, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 3, 0, 0, 0, DateTimeKind.Utc);
git.Commit(harry, cma, out result); // Local commit will succeed
GitPushArgs ph = new GitPushArgs();
ph.Mode = GitPushMode.All;
try
{
git.Push(harry, ph); // But push fails, as it conflicts
Assert.Fail("Should have failed"); // ###
}
catch(GitException ge)
{
Assert.That(ge.Message, Is.StringContaining("Cannot push"));
}
GitPullArgs pa = new GitPullArgs();
pa.FetchArgs.All = true;
git.Pull(harry, pa);
bool gotConflict = false;
git.Status(harry,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.RelativePath)
{
case "app.c":
gotConflict = true;
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.Conflicted, Is.True, "Conflicted");
break;
default:
Assert.Fail("Unexpected path: {0}", e.RelativePath);
break;
}
});
Assert.That(gotConflict, "Found conflict status");
try
{
git.Push(harry, ph); // But push fails, as it conflicts
Assert.Fail("Should still fail");
}
catch (GitException ge)
{
Assert.That(ge.Message, Is.StringContaining("Cannot push"));
}
GitResetArgs ra = new GitResetArgs();
ra.Mode = GitResetMode.Hard;
git.Reset(harry, ra);
}
}
public void DualStart()
{
string master = GetTempPath();
using (GitClient git = new GitClient())
{
GitInitArgs ia = new GitInitArgs();
ia.CreateBareRepository = true;
ia.Description = "Harry & Sally root";
git.Init(master, ia);
}
Uri masterUri = new Uri(master);
string harry = GetTempPath();
string sally = GetTempPath();
using (GitClient git = new GitClient()) // Harry
{
git.Clone(masterUri, harry);
using (GitRepository harryRepo = new GitRepository(harry))
{
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Harry");
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string src = Path.Combine(harry, "src");
Directory.CreateDirectory(src);
string index = Path.Combine(src, "index.txt");
File.WriteAllText(index, "This is index.txt\n");
git.Add(index);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
git.Commit(harry, cma, out result);
using (GitRepository harryRepo = new GitRepository(harry))
{
GitCommit commit;
Assert.That(harryRepo.Lookup(result, out commit));
Assert.That(commit.Author.Name, Is.EqualTo("Harry"));
}
}
using (GitClient git = new GitClient()) // Sally
{
git.Clone(masterUri, sally);
using (GitRepository sallyRepo = new GitRepository(sally))
{
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Sally");
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string iota = Path.Combine(sally, "iota.txt");
File.WriteAllText(iota, "This is iota\n");
git.Stage(iota);
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2001, 1, 1, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2001, 1, 1, 0, 0, 0, DateTimeKind.Utc);
git.Commit(sally, cma);
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.False);
}
using (GitClient git = new GitClient()) // Harry
{
GitPushArgs pa = new GitPushArgs();
pa.Mode = GitPushMode.All;
git.Push(harry, pa);
}
using (GitClient git = new GitClient()) // Sally
{
GitPullArgs pa = new GitPullArgs();
pa.FetchArgs.All = true;
git.Pull(sally, pa);
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.True);
}
}
public void DualStart()
{
string master = GetTempPath();
using (GitClient git = new GitClient())
{
GitInitArgs ia = new GitInitArgs();
ia.CreateBareRepository = true;
ia.Description = "Harry & Sally root";
git.Init(master, ia);
}
Uri masterUri = new Uri(master);
string harry = GetTempPath();
string sally = GetTempPath();
using (GitClient git = new GitClient()) // Harry
{
git.Clone(masterUri, harry);
using (GitRepository harryRepo = new GitRepository(harry))
{
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Harry");
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string src = Path.Combine(harry, "src");
Directory.CreateDirectory(src);
string index = Path.Combine(src, "index.txt");
File.WriteAllText(index, "This is index.txt\n");
git.Add(index);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
git.Commit(harry, cma, out result);
using (GitRepository harryRepo = new GitRepository(harry))
{
GitCommit commit;
Assert.That(harryRepo.Lookup(result, out commit));
Assert.That(commit.Author.Name, Is.EqualTo("Harry"));
}
}
using (GitClient git = new GitClient()) // Sally
{
git.Clone(masterUri, sally);
using (GitRepository sallyRepo = new GitRepository(sally))
{
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Sally");
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string iota = Path.Combine(sally, "iota.txt");
File.WriteAllText(iota, "This is iota\n");
git.Stage(iota);
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2001, 1, 1, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2001, 1, 1, 0, 0, 0, DateTimeKind.Utc);
git.Commit(sally, cma);
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.False);
}
using (GitClient git = new GitClient()) // Harry
{
GitPushArgs pa = new GitPushArgs();
pa.Mode = GitPushMode.All;
git.Push(harry, pa);
}
using (GitClient git = new GitClient()) // Sally
{
GitPullArgs pa = new GitPullArgs();
pa.FetchArgs.All = true;
git.Pull(sally, pa);
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.True);
}
}
public void PushChanges()
{
string master = GetTempPath();
using (GitClient git = new GitClient())
{
GitInitArgs ia = new GitInitArgs();
ia.CreateBareRepository = true;
ia.Description = "Harry & Sally root";
git.Init(master, ia);
}
Uri masterUri = new Uri(master);
string harry = GetTempPath();
string sally = GetTempPath();
using (GitClient git = new GitClient()) // Harry
{
git.Clone(masterUri, harry);
using (GitRepository harryRepo = new GitRepository(harry))
{
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Harry");
harryRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string src = Path.Combine(harry, "src");
Directory.CreateDirectory(src);
string index = Path.Combine(src, "index.txt");
File.WriteAllText(index, "This is index.txt\n");
string appCode = Path.Combine(harry, "app.c");
File.WriteAllText(appCode, @"
#include <stdio.h>
int main(int argc, const char **argv)
{
printf(""hello world\n"");
return 0;
}
");
git.Add(index);
git.Add(appCode);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
git.Commit(harry, cma, out result);
using (GitRepository harryRepo = new GitRepository(harry))
{
GitCommit commit;
Assert.That(harryRepo.Lookup(result, out commit));
Assert.That(commit.Author.Name, Is.EqualTo("Harry"));
}
}
using (GitClient git = new GitClient()) // Sally
{
git.Clone(masterUri, sally);
using (GitRepository sallyRepo = new GitRepository(sally))
{
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.name", "Sally");
sallyRepo.Configuration.Set(GitConfigurationLevel.Repository, "user.email", "*****@*****.**");
}
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.False);
}
using (GitClient git = new GitClient()) // Harry
{
GitPushArgs pa = new GitPushArgs();
pa.Mode = GitPushMode.All;
git.Push(harry, pa);
}
using (GitClient git = new GitClient()) // Sally
{
GitPullArgs pa = new GitPullArgs();
pa.FetchArgs.All = true;
git.Pull(sally, pa);
string src = Path.Combine(sally, "src");
string index = Path.Combine(src, "index.txt");
Assert.That(File.Exists(index), Is.True);
string appCode = Path.Combine(sally, "app.c");
File.WriteAllText(appCode, @"
#include <stdio.h>
int main(int argc, const char **argv)
{
int i;
if (argc != 1)
{
fprintf(stderr, ""Usage %s <int>\n"", argv[0]);
return 1;
}
for (i = 0; i < atoi(argv[1]); i++
printf(""hello world %d\n"", i);
return 0;
}
");
git.Add(appCode);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 2, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 2, 0, 0, 0, DateTimeKind.Utc);
git.Commit(sally, cma, out result);
GitPushArgs ph = new GitPushArgs();
ph.Mode = GitPushMode.All;
git.Push(sally, ph);
}
using (GitClient git = new GitClient()) // Harry
{
string appCode = Path.Combine(harry, "app.c");
File.WriteAllText(appCode, @"
#include <stdio.h>
int main(int argc, const char **argv)
{
if (argc > 0 && strcmp(argv[1], ""-V"")
{
printf(""%s version 1.0 (c) QQn\n"");
return 0;
}
printf(""hello world\n"");
return 0;
}
");
git.Add(appCode);
GitId result;
GitCommitArgs cma = new GitCommitArgs();
cma.Signature.When = new DateTime(2000, 1, 3, 0, 0, 0, DateTimeKind.Utc);
cma.Author.When = new DateTime(2000, 1, 3, 0, 0, 0, DateTimeKind.Utc);
git.Commit(harry, cma, out result); // Local commit will succeed
GitPushArgs ph = new GitPushArgs();
ph.Mode = GitPushMode.All;
try
{
git.Push(harry, ph); // But push fails, as it conflicts
Assert.Fail("Should have failed"); // ###
}
catch (GitException ge)
{
Assert.That(ge.Message, Contains.Substring(/*C*/ "annot push"));
}
GitPullArgs pa = new GitPullArgs();
pa.FetchArgs.All = true;
git.Pull(harry, pa);
bool gotConflict = false;
git.Status(harry,
delegate(object sender, GitStatusEventArgs e)
{
switch (e.RelativePath)
{
case "app.c":
gotConflict = true;
Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal));
Assert.That(e.Conflicted, Is.True, "Conflicted");
break;
default:
Assert.Fail("Unexpected path: {0}", e.RelativePath);
break;
}
});
Assert.That(gotConflict, "Found conflict status");
try
{
git.Push(harry, ph); // But push fails, as it conflicts
Assert.Fail("Should still fail");
}
catch (GitException ge)
{
Assert.That(ge.Message, Contains.Substring(/*C*/ "annot push"));
}
GitResetArgs ra = new GitResetArgs();
ra.Mode = GitResetMode.Hard;
git.Reset(harry, ra);
}
}
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);
}
}
}
