test/UnitTests/GitTest.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2015-2018 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19
  20 #include "stdafx.h"
  21 #include "Git.h"
  22 #include "StringUtils.h"
  23 #include "RepositoryFixtures.h"
  24
  25 // For performance reason, turn LIBGIT off by default,
  26 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitFixture, testing::Values(GIT_CLI, /*LIBGIT,*/ LIBGIT2, LIBGIT2_ALL));
  27 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitWithEmptyRepositoryFixture, testing::Values(GIT_CLI, /*LIBGIT,*/ LIBGIT2, LIBGIT2_ALL));
  28 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitWithEmptyBareRepositoryFixture, testing::Values(GIT_CLI, /*LIBGIT,*/ LIBGIT2, LIBGIT2_ALL));
  29 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitWithTestRepoFixture, testing::Values(GIT_CLI, LIBGIT, LIBGIT2, LIBGIT2_ALL));
  30 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitWithTestRepoBareFixture, testing::Values(GIT_CLI, LIBGIT, LIBGIT2, LIBGIT2_ALL));
  31 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitWithSubmoduleRepositoryFixture, testing::Values(GIT_CLI, /*LIBGIT,*/ LIBGIT2, LIBGIT2_ALL));
  32
  33 TEST(CGit, RunSet)
  34 {
  35         CString output;
  36         CGit cgit;
  37         ASSERT_EQ(0, cgit.Run(L"cmd /c set", &output, CP_UTF8));
  38         ASSERT_FALSE(output.IsEmpty());
  39         ASSERT_TRUE(output.Find(L"windir")); // should be there on any MS OS ;)
  40 }
  41
  42 TEST(CGit, RunGit)
  43 {
  44         CString output;
  45         CGit cgit;
  46         ASSERT_EQ(0, cgit.Run(L"git --version", &output, CP_UTF8));
  47         ASSERT_FALSE(output.IsEmpty());
  48 }
  49
  50 TEST(CGit, RunGit_BashPipe)
  51 {
  52         CString tmpfile = GetTempFile();
  53         tmpfile.Replace(L'\\', L'/');
  54         ASSERT_TRUE(CStringUtils::WriteStringToTextFile(tmpfile, L"testing piping..."));
  55         SCOPE_EXIT{ ::DeleteFile(tmpfile); };
  56         CString pipefile = GetTempFile();
  57         pipefile.Replace(L'\\', L'/');
  58         CString pipecmd;
  59         pipecmd.Format(L"cat < %s", (LPCTSTR)tmpfile);
  60         ASSERT_TRUE(CStringUtils::WriteStringToTextFile(pipefile, pipecmd));
  61         SCOPE_EXIT{ ::DeleteFile(pipefile); };
  62         CString output;
  63         CGit cgit;
  64         ASSERT_EQ(0, cgit.Run(L"bash.exe " + pipefile, &output, CP_UTF8));
  65         ASSERT_STREQ(L"testing piping...", output);
  66 }
  67
  68 TEST(CGit, RunGit_Error)
  69 {
  70         CAutoTempDir tempdir;
  71         CGit cgit;
  72         cgit.m_CurrentDir = tempdir.GetTempDir();
  73
  74         CString output;
  75         EXPECT_NE(0, cgit.Run(L"git-not-found.exe", &output, CP_UTF8)); // Git for Windows returns 2, cygwin-hack returns 127
  76         //EXPECT_STREQ(L"", output); with cygwin-hack we get an error message from sh.exe
  77
  78         output.Empty();
  79         EXPECT_EQ(128, cgit.Run(L"git.exe add file.txt", &output, CP_UTF8));
  80         EXPECT_TRUE(CStringUtils::StartsWithI(output, L"fatal: not a git repository (or any"));
  81 }
  82
  83 TEST_P(CBasicGitWithTestRepoBareFixture, RunGit_AbsolutePath)
  84 {
  85         CAutoTempDir tempdir;
  86
  87         CString output;
  88         EXPECT_EQ(0, m_Git.Run(L"git archive -o " + tempdir.GetTempDir() + L"\\export.zip HEAD", &output, CP_UTF8));
  89         EXPECT_STREQ(L"", output);
  90
  91         EXPECT_TRUE(PathFileExists(tempdir.GetTempDir() + L"\\export.zip"));
  92 }
  93
  94 TEST(CGit, RunLogFile)
  95 {
  96         CAutoTempDir tempdir;
  97         CString tmpfile = tempdir.GetTempDir() + L"\\output.txt";
  98         CString error;
  99         CGit cgit;
 100         ASSERT_EQ(0, cgit.RunLogFile(L"git --version", tmpfile, &error));
 101         EXPECT_STREQ(L"", error);
 102         CString fileContents;
 103         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpfile, fileContents));
 104         EXPECT_TRUE(CStringUtils::StartsWith(fileContents, L"git version "));
 105 }
 106
 107 TEST(CGit, RunLogFile_Set)
 108 {
 109         CAutoTempDir tempdir;
 110         CString tmpfile = tempdir.GetTempDir() + L"\\output.txt";
 111         CString error;
 112         CGit cgit;
 113         ASSERT_EQ(0, cgit.RunLogFile(L"cmd /c set", tmpfile, &error));
 114         EXPECT_STREQ(L"", error);
 115         CString fileContents;
 116         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpfile, fileContents));
 117         EXPECT_TRUE(fileContents.Find(L"windir")); // should be there on any MS OS ;)
 118 }
 119
 120 TEST(CGit, RunLogFile_Error)
 121 {
 122         CAutoTempDir tempdir;
 123         CString tmpfile = tempdir.GetTempDir() + L"\\output.txt";
 124         CString error;
 125         CGit cgit;
 126         cgit.m_CurrentDir = tempdir.GetTempDir();
 127
 128         EXPECT_EQ(128, cgit.RunLogFile(L"git.exe add file.txt", tmpfile, &error));
 129         EXPECT_TRUE(CStringUtils::StartsWithI(error, L"fatal: not a git repository (or any"));
 130         __int64 size = -1;
 131         EXPECT_EQ(0, CGit::GetFileModifyTime(tmpfile, nullptr, nullptr, &size));
 132         EXPECT_EQ(0, size);
 133 }
 134
 135 TEST(CGit, StringAppend)
 136 {
 137         CGit::StringAppend(nullptr, nullptr); // string may be null
 138         CString string = L"something";
 139         CGit::StringAppend(&string, nullptr, CP_UTF8, 0);
 140         EXPECT_STREQ(L"something", string);
 141         const BYTE somebytes[1] = { 0 };
 142         CGit::StringAppend(&string, somebytes, CP_UTF8, 0);
 143         EXPECT_STREQ(L"something", string);
 144         CGit::StringAppend(&string, somebytes);
 145         EXPECT_STREQ(L"something", string);
 146         const BYTE moreBytesUTFEight[] = { 0x68, 0x65, 0x6C, 0x6C, 0xC3, 0xB6, 0x0A, 0x00 };
 147         CGit::StringAppend(&string, moreBytesUTFEight, CP_UTF8, 3);
 148         EXPECT_STREQ(L"somethinghel", string);
 149         CGit::StringAppend(&string, moreBytesUTFEight + 3, CP_ACP, 1);
 150         EXPECT_STREQ(L"somethinghell", string);
 151         CGit::StringAppend(&string, moreBytesUTFEight);
 152         EXPECT_STREQ(L"somethinghellhellö\n", string);
 153         CGit::StringAppend(&string, moreBytesUTFEight, CP_UTF8, sizeof(moreBytesUTFEight));
 154         EXPECT_STREQ(L"somethinghellhellö\nhellö\n\0", string);
 155         CGit::StringAppend(&string, moreBytesUTFEight, CP_UTF8, 3);
 156         EXPECT_STREQ(L"somethinghellhellö\nhellö\n\0hel", string);
 157 }
 158
 159 TEST(CGit, GetFileModifyTime)
 160 {
 161         __int64 time = -1;
 162         bool isDir = false;
 163         __int64 size = -1;
 164         EXPECT_EQ(-1, CGit::GetFileModifyTime(L"does-not-exist.txt", &time, &isDir, &size));
 165
 166         time = -1;
 167         isDir = false;
 168         size = -1;
 169         EXPECT_EQ(0, CGit::GetFileModifyTime(L"c:\\Windows", &time, &isDir, &size));
 170         EXPECT_TRUE(isDir);
 171
 172         time = -1;
 173         isDir = false;
 174         size = -1;
 175         EXPECT_EQ(0, CGit::GetFileModifyTime(L"c:\\Windows\\", &time, &isDir, &size));
 176         EXPECT_TRUE(isDir);
 177
 178         CAutoTempDir tempdir;
 179         CString testFile = tempdir.GetTempDir() + L"\\test.txt";
 180         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing fileöäü."));
 181
 182         time = -1;
 183         EXPECT_EQ(0, CGit::GetFileModifyTime(testFile, &time));
 184         EXPECT_NE(-1, time);
 185
 186         __int64 time2 = -1;
 187         isDir = false;
 188         size = -1;
 189         ULONGLONG ticks = GetTickCount64();
 190         EXPECT_EQ(0, CGit::GetFileModifyTime(testFile, &time2, &isDir, &size));
 191         EXPECT_EQ(time, time2);
 192         EXPECT_FALSE(isDir);
 193         EXPECT_EQ(27, size);
 194
 195         Sleep(250);
 196         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing fileöü."));
 197         __int64 time3 = -1;
 198         isDir = false;
 199         size = -1;
 200         EXPECT_EQ(0, CGit::GetFileModifyTime(testFile, &time3, &isDir, &size));
 201         EXPECT_NE(-1, time3);
 202         EXPECT_FALSE(isDir);
 203         EXPECT_EQ(25, size);
 204         EXPECT_GE(time3, time);
 205         EXPECT_LE(time3 - time, (__int64)(GetTickCount64() - ticks + 10) * 10000);
 206 }
 207
 208 TEST(CGit, LoadTextFile)
 209 {
 210         CAutoTempDir tempdir;
 211
 212         CString msg = L"something--";
 213         EXPECT_FALSE(CGit::LoadTextFile(L"does-not-exist.txt", msg));
 214         EXPECT_STREQ(L"something--", msg);
 215
 216         CString testFile = tempdir.GetTempDir() + L"\\test.txt";
 217         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing fileöäü."));
 218         EXPECT_TRUE(CGit::LoadTextFile(testFile, msg));
 219         EXPECT_STREQ(L"something--this is testing fileöäü.\n", msg);
 220
 221         msg.Empty();
 222         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing\nfileöäü."));
 223         EXPECT_TRUE(CGit::LoadTextFile(testFile, msg));
 224         EXPECT_STREQ(L"this is testing\nfileöäü.\n", msg);
 225
 226         msg.Empty();
 227         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is\r\ntesting\nfileöäü.\r\n\r\n"));
 228         EXPECT_TRUE(CGit::LoadTextFile(testFile, msg));
 229         EXPECT_STREQ(L"this is\ntesting\nfileöäü.\n", msg);
 230 }
 231
 232 TEST(CGit, IsBranchNameValid)
 233 {
 234         CGit cgit;
 235         EXPECT_TRUE(cgit.IsBranchNameValid(L"master"));
 236         EXPECT_TRUE(cgit.IsBranchNameValid(L"def/master"));
 237         EXPECT_FALSE(cgit.IsBranchNameValid(L"HEAD"));
 238         EXPECT_FALSE(cgit.IsBranchNameValid(L"-test"));
 239         EXPECT_FALSE(cgit.IsBranchNameValid(L"jfjf>ff"));
 240         EXPECT_FALSE(cgit.IsBranchNameValid(L"jf ff"));
 241         EXPECT_FALSE(cgit.IsBranchNameValid(L"jf~ff"));
 242 }
 243
 244 TEST(CGit, StripRefName)
 245 {
 246         EXPECT_STREQ(L"abc", CGit::StripRefName(L"abc"));
 247         EXPECT_STREQ(L"bcd", CGit::StripRefName(L"refs/bcd"));
 248         EXPECT_STREQ(L"cde", CGit::StripRefName(L"refs/heads/cde"));
 249
 250         EXPECT_STREQ(L"notes/commits", CGit::StripRefName(L"refs/notes/commits"));
 251         EXPECT_STREQ(L"remotes/origin/abc", CGit::StripRefName(L"refs/remotes/origin/abc"));
 252         EXPECT_STREQ(L"tags/abc", CGit::StripRefName(L"refs/tags/abc"));
 253 }
 254
 255 TEST(CGit, CombinePath)
 256 {
 257         CGit cgit;
 258         cgit.m_CurrentDir = L"c:\\something";
 259         EXPECT_STREQ(L"c:\\something", cgit.CombinePath(L""));
 260         EXPECT_STREQ(L"c:\\something\\file.txt", cgit.CombinePath(L"file.txt"));
 261         EXPECT_STREQ(L"c:\\something\\sub\\file.txt", cgit.CombinePath(L"sub\\file.txt"));
 262         EXPECT_STREQ(L"c:\\something\\subdir\\file2.txt", cgit.CombinePath(CTGitPath(L"subdir/file2.txt")));
 263 }
 264
 265 TEST(CGit, GetShortName)
 266 {
 267         CGit::REF_TYPE type = CGit::UNKNOWN;
 268         EXPECT_STREQ(L"master", CGit::GetShortName(L"refs/heads/master", &type));
 269         EXPECT_EQ(CGit::LOCAL_BRANCH, type);
 270
 271         type = CGit::UNKNOWN;
 272         EXPECT_STREQ(L"somedir/mastr", CGit::GetShortName(L"refs/heads/somedir/mastr", &type));
 273         EXPECT_EQ(CGit::LOCAL_BRANCH, type);
 274
 275         type = CGit::BISECT_BAD; // do not use UNKNOWN here to make sure it gets set
 276         EXPECT_STREQ(L"svn/something", CGit::GetShortName(L"refs/svn/something", &type));
 277         EXPECT_EQ(CGit::UNKNOWN, type);
 278
 279         type = CGit::UNKNOWN;
 280         EXPECT_STREQ(L"origin/master", CGit::GetShortName(L"refs/remotes/origin/master", &type));
 281         EXPECT_EQ(CGit::REMOTE_BRANCH, type);
 282
 283         type = CGit::UNKNOWN;
 284         EXPECT_STREQ(L"origin/sub/master", CGit::GetShortName(L"refs/remotes/origin/sub/master", &type));
 285         EXPECT_EQ(CGit::REMOTE_BRANCH, type);
 286
 287         type = CGit::UNKNOWN;
 288         EXPECT_STREQ(L"release1", CGit::GetShortName(L"refs/tags/release1", &type));
 289         EXPECT_EQ(CGit::TAG, type);
 290
 291         type = CGit::UNKNOWN;
 292         EXPECT_STREQ(L"releases/v1", CGit::GetShortName(L"refs/tags/releases/v1", &type));
 293         EXPECT_EQ(CGit::TAG, type);
 294
 295         type = CGit::UNKNOWN;
 296         EXPECT_STREQ(L"release2", CGit::GetShortName(L"refs/tags/release2^{}", &type));
 297         EXPECT_EQ(CGit::ANNOTATED_TAG, type);
 298
 299         type = CGit::UNKNOWN;
 300         EXPECT_STREQ(L"releases/v2", CGit::GetShortName(L"refs/tags/releases/v2^{}", &type));
 301         EXPECT_EQ(CGit::ANNOTATED_TAG, type);
 302
 303         type = CGit::UNKNOWN;
 304         EXPECT_STREQ(L"stash", CGit::GetShortName(L"refs/stash", &type));
 305         EXPECT_EQ(CGit::STASH, type);
 306
 307         type = CGit::BISECT_BAD; // do not use UNKNOWN here to make sure it gets set
 308         EXPECT_STREQ(L"something", CGit::GetShortName(L"refs/something", &type));
 309         EXPECT_EQ(CGit::UNKNOWN, type);
 310
 311         type = CGit::BISECT_BAD; // do not use UNKNOWN here to make sure it gets set
 312         EXPECT_STREQ(L"sth", CGit::GetShortName(L"sth", &type));
 313         EXPECT_EQ(CGit::UNKNOWN, type);
 314
 315         type = CGit::UNKNOWN;
 316         EXPECT_STREQ(L"good", CGit::GetShortName(L"refs/bisect/good", &type));
 317         EXPECT_EQ(CGit::BISECT_GOOD, type);
 318
 319         type = CGit::UNKNOWN;
 320         EXPECT_STREQ(L"good", CGit::GetShortName(L"refs/bisect/good-5809ac97a1115a8380b1d6bb304b62cd0b0fa9bb", &type));
 321         EXPECT_EQ(CGit::BISECT_GOOD, type);
 322
 323         type = CGit::UNKNOWN;
 324         EXPECT_STREQ(L"bad", CGit::GetShortName(L"refs/bisect/bad", &type));
 325         EXPECT_EQ(CGit::BISECT_BAD, type);
 326
 327         type = CGit::UNKNOWN;
 328         EXPECT_STREQ(L"bad", CGit::GetShortName(L"refs/bisect/bad-5809ac97a1115a8380b1d6bb304b62cd0b0fd9bb", &type));
 329         EXPECT_EQ(CGit::BISECT_BAD, type);
 330
 331         type = CGit::UNKNOWN;
 332         EXPECT_STREQ(L"ab", CGit::GetShortName(L"refs/notes/ab", &type));
 333         EXPECT_EQ(CGit::NOTES, type);
 334
 335         type = CGit::UNKNOWN;
 336         EXPECT_STREQ(L"a/b", CGit::GetShortName(L"refs/notes/a/b", &type));
 337         EXPECT_EQ(CGit::NOTES, type);
 338 }
 339
 340 TEST(CGit, GetRepository)
 341 {
 342         CAutoTempDir tempdir;
 343         CGit cgit;
 344         cgit.m_CurrentDir = tempdir.GetTempDir();
 345
 346         CAutoRepository repo = cgit.GetGitRepository();
 347         EXPECT_FALSE(repo.IsValid());
 348
 349         cgit.m_CurrentDir = tempdir.GetTempDir() + L"\\aöäüb";
 350         ASSERT_TRUE(CreateDirectory(cgit.m_CurrentDir, nullptr));
 351
 352         CString output;
 353         EXPECT_EQ(0, cgit.Run(L"git.exe init", &output, CP_UTF8));
 354         EXPECT_STRNE(L"", output);
 355
 356         CAutoRepository repo2 = cgit.GetGitRepository(); // this tests GetGitRepository as well as m_Git.GetGitPathStringA
 357         EXPECT_TRUE(repo2.IsValid());
 358
 359         cgit.m_CurrentDir = tempdir.GetTempDir() + L"\\aöäüb.git";
 360         ASSERT_TRUE(CreateDirectory(cgit.m_CurrentDir, nullptr));
 361
 362         output.Empty();
 363         EXPECT_EQ(0, cgit.Run(L"git.exe init --bare", &output, CP_UTF8));
 364         EXPECT_STRNE(L"", output);
 365
 366         CAutoRepository repo3 = cgit.GetGitRepository(); // this tests GetGitRepository as well as m_Git.GetGitPathStringA
 367         EXPECT_TRUE(repo3.IsValid());
 368 }
 369
 370 TEST_P(CBasicGitWithEmptyRepositoryFixture, IsInitRepos_GetInitAddList)
 371 {
 372         EXPECT_STREQ(L"master", m_Git.GetCurrentBranch());
 373
 374         CString output;
 375         CString testFile = m_Dir.GetTempDir() + L"\\test.txt";
 376
 377         CTGitPathList addedFiles;
 378
 379         EXPECT_TRUE(m_Git.IsInitRepos());
 380         EXPECT_EQ(0, m_Git.GetInitAddList(addedFiles));
 381         EXPECT_TRUE(addedFiles.IsEmpty());
 382
 383         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing file."));
 384         EXPECT_EQ(0, m_Git.GetInitAddList(addedFiles));
 385         EXPECT_TRUE(addedFiles.IsEmpty());
 386         EXPECT_EQ(0, m_Git.Run(L"git.exe add test.txt", &output, CP_UTF8));
 387         EXPECT_STREQ(L"", output);
 388         EXPECT_EQ(0, m_Git.GetInitAddList(addedFiles));
 389         ASSERT_EQ(1, addedFiles.GetCount());
 390         EXPECT_STREQ(L"test.txt", addedFiles[0].GetGitPathString());
 391
 392         output.Empty();
 393         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Add test.txt\"", &output, CP_UTF8));
 394         EXPECT_STRNE(L"", output);
 395
 396         EXPECT_FALSE(m_Git.IsInitRepos());
 397
 398         EXPECT_STREQ(L"master", m_Git.GetCurrentBranch());
 399 }
 400
 401 TEST_P(CBasicGitWithTestRepoFixture, IsInitRepos)
 402 {
 403         EXPECT_FALSE(m_Git.IsInitRepos());
 404
 405         CString output;
 406         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
 407         EXPECT_STRNE(L"", output);
 408
 409         EXPECT_TRUE(m_Git.IsInitRepos());
 410 }
 411
 412 TEST_P(CBasicGitWithTestRepoFixture, HasWorkingTreeConflicts)
 413 {
 414         CString output;
 415         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
 416         EXPECT_STRNE(L"", output);
 417
 418         EXPECT_EQ(FALSE, m_Git.HasWorkingTreeConflicts());
 419
 420         output.Empty();
 421         EXPECT_EQ(0, m_Git.Run(L"git.exe merge forconflict", &output, CP_UTF8));
 422         EXPECT_STRNE(L"", output);
 423         EXPECT_EQ(FALSE, m_Git.HasWorkingTreeConflicts());
 424
 425         output.Empty();
 426         EXPECT_EQ(1, m_Git.Run(L"git.exe merge simple-conflict", &output, CP_UTF8));
 427         EXPECT_STRNE(L"", output);
 428         EXPECT_EQ(TRUE, m_Git.HasWorkingTreeConflicts());
 429
 430         output.Empty();
 431         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
 432         EXPECT_STRNE(L"", output);
 433
 434         output.Empty();
 435         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout forconflict", &output, CP_UTF8));
 436         EXPECT_STRNE(L"", output);
 437
 438         output.Empty();
 439         EXPECT_EQ(1, m_Git.Run(L"git.exe merge simple-conflict", &output, CP_UTF8));
 440         EXPECT_STRNE(L"", output);
 441         EXPECT_EQ(TRUE, m_Git.HasWorkingTreeConflicts());
 442 }
 443
 444 TEST_P(CBasicGitWithTestRepoFixture, GetCurrentBranch)
 445 {
 446         EXPECT_STREQ(L"master", m_Git.GetCurrentBranch());
 447         EXPECT_STREQ(L"master", m_Git.GetCurrentBranch(true));
 448
 449         CString output;
 450         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout simple-conflict", &output, CP_UTF8));
 451         EXPECT_STREQ(L"simple-conflict", m_Git.GetCurrentBranch());
 452         EXPECT_STREQ(L"simple-conflict", m_Git.GetCurrentBranch(true));
 453
 454         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout subdir/branch", &output, CP_UTF8));
 455         EXPECT_STREQ(L"subdir/branch", m_Git.GetCurrentBranch());
 456         EXPECT_STREQ(L"subdir/branch", m_Git.GetCurrentBranch(true));
 457
 458         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout 560deea87853158b22d0c0fd73f60a458d47838a", &output, CP_UTF8));
 459         EXPECT_STREQ(L"(no branch)", m_Git.GetCurrentBranch());
 460         EXPECT_STREQ(L"560deea87853158b22d0c0fd73f60a458d47838a", m_Git.GetCurrentBranch(true));
 461
 462         output.Empty();
 463         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
 464         EXPECT_STRNE(L"", output);
 465
 466         EXPECT_STREQ(L"orphanic", m_Git.GetCurrentBranch());
 467         EXPECT_STREQ(L"orphanic", m_Git.GetCurrentBranch(true));
 468 }
 469
 470 TEST_P(CBasicGitWithTestRepoBareFixture, GetCurrentBranch)
 471 {
 472         EXPECT_STREQ(L"master", m_Git.GetCurrentBranch());
 473         EXPECT_STREQ(L"master", m_Git.GetCurrentBranch(true));
 474 }
 475
 476 static void IsLocalBranch(CGit& m_Git)
 477 {
 478         EXPECT_TRUE(m_Git.IsLocalBranch(L"master"));
 479         EXPECT_TRUE(m_Git.IsLocalBranch(L"subdir/branch"));
 480
 481         EXPECT_FALSE(m_Git.IsLocalBranch(L"no_branch_in_repo"));
 482
 483         EXPECT_FALSE(m_Git.IsLocalBranch(L"commits")); // notes/commits
 484
 485         EXPECT_FALSE(m_Git.IsLocalBranch(L"stash"));
 486
 487         EXPECT_FALSE(m_Git.IsLocalBranch(L"3686b9cf74f1a4ef96d6bfe736595ef9abf0fb8d"));
 488
 489         // exist tags
 490         EXPECT_FALSE(m_Git.IsLocalBranch(L"normal-tag"));
 491         EXPECT_FALSE(m_Git.IsLocalBranch(L"also-signed"));
 492 }
 493
 494 TEST_P(CBasicGitWithTestRepoFixture, IsLocalBranch)
 495 {
 496         IsLocalBranch(m_Git);
 497 }
 498
 499 TEST_P(CBasicGitWithTestRepoBareFixture, IsLocalBranch)
 500 {
 501         IsLocalBranch(m_Git);
 502 }
 503
 504 static void BranchTagExists_IsBranchTagNameUnique(CGit& m_Git)
 505 {
 506         EXPECT_TRUE(m_Git.BranchTagExists(L"master", true));
 507         EXPECT_FALSE(m_Git.BranchTagExists(L"origin/master", true));
 508         EXPECT_FALSE(m_Git.BranchTagExists(L"normal-tag", true));
 509         EXPECT_FALSE(m_Git.BranchTagExists(L"also-signed", true));
 510         EXPECT_FALSE(m_Git.BranchTagExists(L"wuseldusel", true));
 511
 512         EXPECT_FALSE(m_Git.BranchTagExists(L"master", false));
 513         EXPECT_TRUE(m_Git.BranchTagExists(L"normal-tag", false));
 514         EXPECT_TRUE(m_Git.BranchTagExists(L"also-signed", false));
 515         EXPECT_FALSE(m_Git.BranchTagExists(L"wuseldusel", false));
 516
 517         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"master"));
 518         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"simpleconflict"));
 519         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"normal-tag"));
 520         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"also-signed"));
 521         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"origin/master"));
 522
 523         CString output;
 524         EXPECT_EQ(0, m_Git.Run(L"git.exe tag master HEAD~2", &output, CP_UTF8));
 525         EXPECT_STREQ(L"", output);
 526
 527         EXPECT_EQ(0, m_Git.Run(L"git.exe branch normal-tag HEAD~2", &output, CP_UTF8));
 528         EXPECT_STREQ(L"", output);
 529
 530         EXPECT_FALSE(m_Git.IsBranchTagNameUnique(L"master"));
 531         EXPECT_FALSE(m_Git.IsBranchTagNameUnique(L"normal-tag"));
 532         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"also-signed"));
 533 }
 534
 535 TEST_P(CBasicGitWithTestRepoFixture, BranchTagExists_IsBranchTagNameUnique)
 536 {
 537         BranchTagExists_IsBranchTagNameUnique(m_Git);
 538 }
 539
 540 TEST_P(CBasicGitWithTestRepoBareFixture, BranchTagExists_IsBranchTagNameUnique)
 541 {
 542         BranchTagExists_IsBranchTagNameUnique(m_Git);
 543 }
 544
 545 static void GetFullRefName(CGit& m_Git)
 546 {
 547         EXPECT_STREQ(L"", m_Git.GetFullRefName(L"does_not_exist"));
 548         EXPECT_STREQ(L"refs/heads/master", m_Git.GetFullRefName(L"master"));
 549         EXPECT_STREQ(L"refs/remotes/origin/master", m_Git.GetFullRefName(L"origin/master"));
 550         EXPECT_STREQ(L"refs/tags/normal-tag", m_Git.GetFullRefName(L"normal-tag"));
 551         EXPECT_STREQ(L"refs/tags/also-signed", m_Git.GetFullRefName(L"also-signed"));
 552
 553         CString output;
 554         EXPECT_EQ(0, m_Git.Run(L"git.exe tag master HEAD~2", &output, CP_UTF8));
 555         EXPECT_STREQ(L"", output);
 556         EXPECT_STREQ(L"", m_Git.GetFullRefName(L"master"));
 557         EXPECT_STREQ(L"refs/remotes/origin/master", m_Git.GetFullRefName(L"origin/master"));
 558
 559         EXPECT_EQ(0, m_Git.Run(L"git.exe branch normal-tag HEAD~2", &output, CP_UTF8));
 560         EXPECT_STREQ(L"", output);
 561         EXPECT_STREQ(L"", m_Git.GetFullRefName(L"normal-tag"));
 562
 563         EXPECT_EQ(0, m_Git.Run(L"git.exe branch origin/master HEAD~2", &output, CP_UTF8));
 564         EXPECT_STREQ(L"", output);
 565         EXPECT_STREQ(L"", m_Git.GetFullRefName(L"origin/master"));
 566 }
 567
 568 TEST_P(CBasicGitWithTestRepoFixture, GetFullRefName)
 569 {
 570         GetFullRefName(m_Git);
 571
 572         CString output;
 573         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
 574         EXPECT_STRNE(L"", output);
 575         EXPECT_STREQ(L"", m_Git.GetFullRefName(L"orphanic"));
 576 }
 577
 578 TEST_P(CBasicGitWithTestRepoBareFixture, GetFullRefName)
 579 {
 580         GetFullRefName(m_Git);
 581 }
 582
 583 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetRemoteTrackedBranch)
 584 {
 585         CString remote, branch;
 586         m_Git.GetRemoteTrackedBranchForHEAD(remote, branch);
 587         EXPECT_STREQ(L"", remote);
 588         EXPECT_STREQ(L"", branch);
 589
 590         m_Git.GetRemoteTrackedBranch(L"master", remote, branch);
 591         EXPECT_STREQ(L"", remote);
 592         EXPECT_STREQ(L"", branch);
 593
 594         m_Git.GetRemoteTrackedBranch(L"non-existing", remote, branch);
 595         EXPECT_STREQ(L"", remote);
 596         EXPECT_STREQ(L"", branch);
 597 }
 598
 599 static void GetRemoteTrackedBranch(CGit& m_Git)
 600 {
 601         CString remote, branch;
 602         m_Git.GetRemoteTrackedBranchForHEAD(remote, branch);
 603         EXPECT_STREQ(L"origin", remote);
 604         EXPECT_STREQ(L"master", branch);
 605
 606         remote.Empty();
 607         branch.Empty();
 608         m_Git.GetRemoteTrackedBranch(L"master", remote, branch);
 609         EXPECT_STREQ(L"origin", remote);
 610         EXPECT_STREQ(L"master", branch);
 611
 612         remote.Empty();
 613         branch.Empty();
 614         m_Git.GetRemoteTrackedBranch(L"non-existing", remote, branch);
 615         EXPECT_STREQ(L"", remote);
 616         EXPECT_STREQ(L"", branch);
 617 }
 618
 619 TEST_P(CBasicGitWithTestRepoFixture, GetRemoteTrackedBranch)
 620 {
 621         GetRemoteTrackedBranch(m_Git);
 622 }
 623
 624 TEST_P(CBasicGitWithTestRepoBareFixture, GetRemoteTrackedBranch)
 625 {
 626         GetRemoteTrackedBranch(m_Git);
 627 }
 628
 629 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetRemotePushBranch)
 630 {
 631         CString remote, branch;
 632         m_Git.GetRemotePushBranch(L"master", remote, branch);
 633         EXPECT_STREQ(L"", remote);
 634         EXPECT_STREQ(L"", branch);
 635
 636         m_Git.GetRemotePushBranch(L"non-existing", remote, branch);
 637         EXPECT_STREQ(L"", remote);
 638         EXPECT_STREQ(L"", branch);
 639 }
 640
 641 static void GetRemotePushBranch(CGit& m_Git)
 642 {
 643         CString remote, branch;
 644         m_Git.GetRemotePushBranch(L"master", remote, branch);
 645         EXPECT_STREQ(L"origin", remote);
 646         EXPECT_STREQ(L"master", branch);
 647
 648         remote.Empty();
 649         branch.Empty();
 650         m_Git.GetRemotePushBranch(L"non-existing", remote, branch);
 651         EXPECT_STREQ(L"", remote);
 652         EXPECT_STREQ(L"", branch);
 653
 654         CAutoRepository repo(m_Git.GetGitRepository());
 655         ASSERT_TRUE(repo.IsValid());
 656         CAutoConfig config(repo);
 657         ASSERT_TRUE(config.IsValid());
 658
 659         remote.Empty();
 660         branch.Empty();
 661         EXPECT_EQ(0, git_config_set_string(config, "remote.pushDefault", "originpush2"));
 662         m_Git.GetRemotePushBranch(L"master", remote, branch);
 663         EXPECT_STREQ(L"originpush2", remote);
 664         EXPECT_STREQ(L"master", branch);
 665
 666         remote.Empty();
 667         branch.Empty();
 668         EXPECT_EQ(0, git_config_set_string(config, "branch.master.pushremote", "originpush3"));
 669         m_Git.GetRemotePushBranch(L"master", remote, branch);
 670         EXPECT_STREQ(L"originpush3", remote);
 671         EXPECT_STREQ(L"master", branch);
 672
 673         remote.Empty();
 674         branch.Empty();
 675         EXPECT_EQ(0, git_config_set_string(config, "branch.master.pushbranch", "masterbranch2"));
 676         m_Git.GetRemotePushBranch(L"master", remote, branch);
 677         EXPECT_STREQ(L"originpush3", remote);
 678         EXPECT_STREQ(L"masterbranch2", branch);
 679
 680         remote.Empty();
 681         branch.Empty();
 682         m_Git.GetRemotePushBranch(L"non-existing", remote, branch);
 683         EXPECT_STREQ(L"originpush2", remote);
 684         EXPECT_STREQ(L"", branch);
 685 }
 686
 687 TEST_P(CBasicGitWithTestRepoFixture, GetRemotePushBranch)
 688 {
 689         GetRemotePushBranch(m_Git);
 690 }
 691
 692 TEST_P(CBasicGitWithTestRepoBareFixture, GetRemotePushBranch)
 693 {
 694         GetRemotePushBranch(m_Git);
 695 }
 696
 697 static void CanParseRev(CGit& m_Git)
 698 {
 699         EXPECT_TRUE(m_Git.CanParseRev(L""));
 700         EXPECT_TRUE(m_Git.CanParseRev(L"HEAD"));
 701         EXPECT_TRUE(m_Git.CanParseRev(L"master"));
 702         EXPECT_TRUE(m_Git.CanParseRev(L"heads/master"));
 703         EXPECT_TRUE(m_Git.CanParseRev(L"refs/heads/master"));
 704         EXPECT_TRUE(m_Git.CanParseRev(L"master~1"));
 705         EXPECT_TRUE(m_Git.CanParseRev(L"master forconflict"));
 706         EXPECT_TRUE(m_Git.CanParseRev(L"origin/master..master"));
 707         EXPECT_TRUE(m_Git.CanParseRev(L"origin/master...master"));
 708         EXPECT_TRUE(m_Git.CanParseRev(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd"));
 709         EXPECT_FALSE(m_Git.CanParseRev(L"non-existing"));
 710         EXPECT_TRUE(m_Git.CanParseRev(L"normal-tag"));
 711         EXPECT_TRUE(m_Git.CanParseRev(L"tags/normal-tag"));
 712         EXPECT_TRUE(m_Git.CanParseRev(L"refs/tags/normal-tag"));
 713         EXPECT_TRUE(m_Git.CanParseRev(L"all-files-signed"));
 714         EXPECT_TRUE(m_Git.CanParseRev(L"all-files-signed^{}"));
 715
 716         EXPECT_FALSE(m_Git.CanParseRev(L"orphanic"));
 717 }
 718
 719 TEST_P(CBasicGitWithTestRepoFixture, CanParseRev)
 720 {
 721         CanParseRev(m_Git);
 722
 723         CString output;
 724         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
 725         EXPECT_STRNE(L"", output);
 726         EXPECT_FALSE(m_Git.CanParseRev(L""));
 727         EXPECT_FALSE(m_Git.CanParseRev(L"HEAD"));
 728         EXPECT_FALSE(m_Git.CanParseRev(L"orphanic"));
 729         EXPECT_TRUE(m_Git.CanParseRev(L"master"));
 730 }
 731
 732 TEST_P(CBasicGitWithTestRepoBareFixture, CanParseRev)
 733 {
 734         CanParseRev(m_Git);
 735 }
 736
 737 static void FETCHHEAD(CGit& m_Git, bool isBare)
 738 {
 739         CString repoDir = m_Git.m_CurrentDir;
 740         if (!isBare)
 741                 repoDir += L"\\.git";
 742
 743         STRING_VECTOR list;
 744         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 745         EXPECT_EQ(6U, list.size());
 746         list.clear();
 747         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 748         EXPECT_EQ(6U, list.size());
 749
 750         EXPECT_STREQ(L"HEAD", m_Git.FixBranchName(L"HEAD"));
 751         EXPECT_STREQ(L"master", m_Git.FixBranchName(L"master"));
 752         EXPECT_STREQ(L"non-existing", m_Git.FixBranchName(L"non-existing"));
 753         CString branch = L"master";
 754         EXPECT_STREQ(L"master", m_Git.FixBranchName_Mod(branch));
 755         EXPECT_STREQ(L"master", branch);
 756         branch = L"non-existing";
 757         EXPECT_STREQ(L"non-existing", m_Git.FixBranchName_Mod(branch));
 758         EXPECT_STREQ(L"non-existing", branch);
 759         CGitHash hash;
 760         EXPECT_NE(0, m_Git.GetHash(hash, L"FETCH_HEAD"));
 761
 762         CString testFile = repoDir + L"\\FETCH_HEAD";
 763         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb            branch 'master' of https://code.google.com/p/tortoisegit\n737878a4e2eabfa4fab580867c2b060c70999d31      not-for-merge   branch 'extend_hooks' of https://code.google.com/p/tortoisegit\n"));
 764
 765         list.clear();
 766         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 767         EXPECT_EQ(6U, list.size());
 768         list.clear();
 769         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 770         EXPECT_EQ(7U, list.size());
 771
 772         EXPECT_STREQ(L"master", m_Git.FixBranchName(L"master"));
 773         EXPECT_STREQ(L"non-existing", m_Git.FixBranchName(L"non-existing"));
 774         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", m_Git.FixBranchName(L"FETCH_HEAD"));
 775         branch = L"HEAD";
 776         EXPECT_STREQ(L"HEAD", m_Git.FixBranchName_Mod(branch));
 777         EXPECT_STREQ(L"HEAD", branch);
 778         branch = L"master";
 779         EXPECT_STREQ(L"master", m_Git.FixBranchName_Mod(branch));
 780         EXPECT_STREQ(L"master", branch);
 781         branch = L"non-existing";
 782         EXPECT_STREQ(L"non-existing", m_Git.FixBranchName_Mod(branch));
 783         EXPECT_STREQ(L"non-existing", branch);
 784         branch = L"FETCH_HEAD";
 785         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", m_Git.FixBranchName_Mod(branch));
 786         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", branch);
 787         EXPECT_EQ(0, m_Git.GetHash(hash, L"FETCH_HEAD"));
 788         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", hash.ToString());
 789
 790         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"737878a4e2eabfa4fab580867c2b060c70999d31    not-for-merge   branch 'extend_hooks' of https://code.google.com/p/tortoisegit\nb9ef30183497cdad5c30b88d32dc1bed7951dfeb                branch 'master' of https://code.google.com/p/tortoisegit\n"));
 791
 792         list.clear();
 793         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 794         EXPECT_EQ(6U, list.size());
 795         list.clear();
 796         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 797         EXPECT_EQ(7U, list.size());
 798
 799         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", m_Git.FixBranchName(L"FETCH_HEAD"));
 800         branch = L"FETCH_HEAD";
 801         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", m_Git.FixBranchName_Mod(branch));
 802         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", branch);
 803         // libgit2 fails here
 804         //EXPECT_EQ(0, m_Git.GetHash(hash, L"FETCH_HEAD"));
 805         //EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", hash.ToString());
 806 }
 807
 808 TEST_P(CBasicGitWithTestRepoFixture, FETCHHEAD)
 809 {
 810         FETCHHEAD(m_Git, false);
 811 }
 812
 813 TEST_P(CBasicGitWithTestRepoBareFixture, FETCHHEAD)
 814 {
 815         FETCHHEAD(m_Git, true);
 816 }
 817
 818 TEST_P(CBasicGitWithTestRepoFixture, IsFastForward)
 819 {
 820         CGitHash commonAncestor;
 821         EXPECT_TRUE(m_Git.IsFastForward(L"origin/master", L"master", &commonAncestor));
 822         EXPECT_STREQ(L"a9d53b535cb49640a6099860ac4999f5a0857b91", commonAncestor.ToString());
 823
 824         EXPECT_FALSE(m_Git.IsFastForward(L"simple-conflict", L"master", &commonAncestor));
 825         EXPECT_STREQ(L"b02add66f48814a73aa2f0876d6bbc8662d6a9a8", commonAncestor.ToString());
 826 }
 827
 828 static void GetHash(CGit& m_Git)
 829 {
 830         CGitHash hash;
 831         EXPECT_EQ(0, m_Git.GetHash(hash, L"HEAD"));
 832         EXPECT_STREQ(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6", hash.ToString());
 833         EXPECT_EQ(0, m_Git.GetHash(hash, L"HEAD~1"));
 834         EXPECT_STREQ(L"1fc3c9688e27596d8717b54f2939dc951568f6cb", hash.ToString());
 835         EXPECT_EQ(0, m_Git.GetHash(hash, L"ff1fbef1a54a9849afd4a5e94d2ca4d80d5b96c2"));
 836         EXPECT_STREQ(L"ff1fbef1a54a9849afd4a5e94d2ca4d80d5b96c2", hash.ToString());
 837         EXPECT_EQ(0, m_Git.GetHash(hash, L"master"));
 838         EXPECT_STREQ(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6", hash.ToString());
 839         EXPECT_EQ(0, m_Git.GetHash(hash, L"origin/master"));
 840         EXPECT_STREQ(L"a9d53b535cb49640a6099860ac4999f5a0857b91", hash.ToString());
 841         EXPECT_EQ(0, m_Git.GetHash(hash, L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd"));
 842         EXPECT_STREQ(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd", hash.ToString());
 843         EXPECT_EQ(0, m_Git.GetHash(hash, L"normal-tag"));
 844         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", hash.ToString());
 845         EXPECT_EQ(0, m_Git.GetHash(hash, L"all-files-signed"));
 846         EXPECT_STREQ(L"ab555b2776c6b700ad93848d0dd050e7d08be779", hash.ToString()); // maybe we need automatically to dereference it
 847         EXPECT_EQ(0, m_Git.GetHash(hash, L"all-files-signed^{}"));
 848         EXPECT_STREQ(L"313a41bc88a527289c87d7531802ab484715974f", hash.ToString());
 849
 850         EXPECT_NE(0, m_Git.GetHash(hash, L"non-existing"));
 851 }
 852
 853 TEST_P(CBasicGitWithTestRepoFixture, GetHash)
 854 {
 855         GetHash(m_Git);
 856 }
 857
 858 TEST_P(CBasicGitWithTestRepoBareFixture, GetHash)
 859 {
 860         GetHash(m_Git);
 861 }
 862
 863 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetHash_EmptyRepo)
 864 {
 865         CGitHash hash;
 866         EXPECT_EQ(0, m_Git.GetHash(hash, L"HEAD"));
 867         EXPECT_TRUE(hash.IsEmpty());
 868 }
 869
 870 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetEmptyBranchesTagsRefs)
 871 {
 872         STRING_VECTOR branches;
 873         int current = -2;
 874         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
 875         EXPECT_TRUE(branches.empty());
 876         EXPECT_EQ(-2, current); // not touched
 877
 878         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
 879         EXPECT_TRUE(branches.empty());
 880         EXPECT_EQ(-2, current); // not touched
 881
 882         STRING_VECTOR tags;
 883         EXPECT_EQ(0, m_Git.GetTagList(tags));
 884         EXPECT_TRUE(tags.empty());
 885
 886         STRING_VECTOR refs;
 887         EXPECT_EQ(0, m_Git.GetRefList(refs));
 888         EXPECT_TRUE(refs.empty());
 889
 890         MAP_HASH_NAME map;
 891         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
 892         EXPECT_TRUE(map.empty());
 893
 894         STRING_VECTOR remotes;
 895         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
 896         EXPECT_TRUE(remotes.empty());
 897 }
 898
 899 static void GetBranchesTagsRefs(CGit& m_Git, config testConfig)
 900 {
 901         STRING_VECTOR branches;
 902         int current = -2;
 903         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
 904         ASSERT_EQ(6U, branches.size());
 905         EXPECT_EQ(1, current);
 906         EXPECT_STREQ(L"forconflict", branches[0]);
 907         EXPECT_STREQ(L"master", branches[1]);
 908         EXPECT_STREQ(L"master2", branches[2]);
 909         EXPECT_STREQ(L"signed-commit", branches[3]);
 910         EXPECT_STREQ(L"simple-conflict", branches[4]);
 911         EXPECT_STREQ(L"subdir/branch", branches[5]);
 912
 913         branches.clear();
 914         current = -2;
 915         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
 916         ASSERT_EQ(7U, branches.size());
 917         EXPECT_EQ(1, current);
 918         EXPECT_STREQ(L"forconflict", branches[0]);
 919         EXPECT_STREQ(L"master", branches[1]);
 920         EXPECT_STREQ(L"master2", branches[2]);
 921         EXPECT_STREQ(L"signed-commit", branches[3]);
 922         EXPECT_STREQ(L"simple-conflict", branches[4]);
 923         EXPECT_STREQ(L"subdir/branch", branches[5]);
 924         EXPECT_STREQ(L"remotes/origin/master", branches[6]);
 925
 926         branches.clear();
 927         current = -2;
 928         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL, true));
 929         ASSERT_EQ(6U, branches.size());
 930         EXPECT_EQ(-2, current); // not touched
 931         EXPECT_STREQ(L"forconflict", branches[0]);
 932         EXPECT_STREQ(L"master2", branches[1]);
 933         EXPECT_STREQ(L"signed-commit", branches[2]);
 934         EXPECT_STREQ(L"simple-conflict", branches[3]);
 935         EXPECT_STREQ(L"subdir/branch", branches[4]);
 936         EXPECT_STREQ(L"remotes/origin/master", branches[5]);
 937
 938         branches.clear();
 939         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL, true));
 940         ASSERT_EQ(6U, branches.size());
 941         EXPECT_STREQ(L"forconflict", branches[0]);
 942         EXPECT_STREQ(L"master2", branches[1]);
 943         EXPECT_STREQ(L"signed-commit", branches[2]);
 944         EXPECT_STREQ(L"simple-conflict", branches[3]);
 945         EXPECT_STREQ(L"subdir/branch", branches[4]);
 946         EXPECT_STREQ(L"remotes/origin/master", branches[5]);
 947
 948         branches.clear();
 949         current = -2;
 950         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_REMOTE));
 951         ASSERT_EQ(1U, branches.size());
 952         EXPECT_EQ(-2, current); // not touched
 953         EXPECT_STREQ(L"remotes/origin/master", branches[0]);
 954
 955         STRING_VECTOR tags;
 956         EXPECT_EQ(0, m_Git.GetTagList(tags));
 957         ASSERT_EQ(3U, tags.size());
 958         EXPECT_STREQ(L"all-files-signed", tags[0]);
 959         EXPECT_STREQ(L"also-signed", tags[1]);
 960         EXPECT_STREQ(L"normal-tag", tags[2]);
 961
 962         STRING_VECTOR refs;
 963         EXPECT_EQ(0, m_Git.GetRefList(refs));
 964         ASSERT_EQ(12U, refs.size());
 965         EXPECT_STREQ(L"refs/heads/forconflict", refs[0]);
 966         EXPECT_STREQ(L"refs/heads/master", refs[1]);
 967         EXPECT_STREQ(L"refs/heads/master2", refs[2]);
 968         EXPECT_STREQ(L"refs/heads/signed-commit", refs[3]);
 969         EXPECT_STREQ(L"refs/heads/simple-conflict", refs[4]);
 970         EXPECT_STREQ(L"refs/heads/subdir/branch", refs[5]);
 971         EXPECT_STREQ(L"refs/notes/commits", refs[6]);
 972         EXPECT_STREQ(L"refs/remotes/origin/master", refs[7]);
 973         EXPECT_STREQ(L"refs/stash", refs[8]);
 974         EXPECT_STREQ(L"refs/tags/all-files-signed", refs[9]);
 975         EXPECT_STREQ(L"refs/tags/also-signed", refs[10]);
 976         EXPECT_STREQ(L"refs/tags/normal-tag", refs[11]);
 977
 978         MAP_HASH_NAME map;
 979         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
 980         if (testConfig == GIT_CLI || testConfig == LIBGIT)
 981                 ASSERT_EQ(13U, map.size()); // also contains the undereferenced tags with hashes
 982         else
 983                 ASSERT_EQ(11U, map.size());
 984
 985         ASSERT_EQ(1U, map[CGitHash(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6")].size());
 986         EXPECT_STREQ(L"refs/heads/master", map[CGitHash(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6")][0]);
 987         ASSERT_EQ(1U, map[CGitHash(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44")].size());
 988         EXPECT_STREQ(L"refs/heads/signed-commit", map[CGitHash(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44")][0]);
 989         ASSERT_EQ(1U, map[CGitHash(L"31ff87c86e9f6d3853e438cb151043f30f09029a")].size());
 990         EXPECT_STREQ(L"refs/heads/subdir/branch", map[CGitHash(L"31ff87c86e9f6d3853e438cb151043f30f09029a")][0]);
 991         ASSERT_EQ(1U, map[CGitHash(L"5e702e1712aa6f8cd8e0328a87be006f3a923710")].size());
 992         EXPECT_STREQ(L"refs/notes/commits", map[CGitHash(L"5e702e1712aa6f8cd8e0328a87be006f3a923710")][0]);
 993         ASSERT_EQ(1U, map[CGitHash(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb")].size());
 994         EXPECT_STREQ(L"refs/stash", map[CGitHash(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb")][0]);
 995         ASSERT_EQ(1U, map[CGitHash(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")].size());
 996         EXPECT_STREQ(L"refs/heads/simple-conflict", map[CGitHash(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")][0]);
 997         ASSERT_EQ(1U, map[CGitHash(L"10385764a4d42d7428bbeb245015f8f338fc1e40")].size());
 998         EXPECT_STREQ(L"refs/heads/forconflict", map[CGitHash(L"10385764a4d42d7428bbeb245015f8f338fc1e40")][0]);
 999         ASSERT_EQ(2U, map[CGitHash(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")].size());
1000         EXPECT_STREQ(L"refs/heads/master2", map[CGitHash(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")][0]);
1001         EXPECT_STREQ(L"refs/tags/also-signed^{}", map[CGitHash(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")][1]);
1002         ASSERT_EQ(1U, map[CGitHash(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb")].size());//
1003         EXPECT_STREQ(L"refs/tags/normal-tag", map[CGitHash(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb")][0]);
1004         ASSERT_EQ(1U, map[CGitHash(L"a9d53b535cb49640a6099860ac4999f5a0857b91")].size());
1005         EXPECT_STREQ(L"refs/remotes/origin/master", map[CGitHash(L"a9d53b535cb49640a6099860ac4999f5a0857b91")][0]);
1006         ASSERT_EQ(1U, map[CGitHash(L"313a41bc88a527289c87d7531802ab484715974f")].size());
1007         EXPECT_STREQ(L"refs/tags/all-files-signed^{}", map[CGitHash(L"313a41bc88a527289c87d7531802ab484715974f")][0]);
1008
1009         STRING_VECTOR remotes;
1010         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
1011         ASSERT_EQ(1U, remotes.size());
1012         EXPECT_STREQ(L"origin", remotes[0]);
1013
1014         EXPECT_EQ(-1, m_Git.DeleteRef(L"refs/tags/gibbednet"));
1015         branches.clear();
1016         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1017         EXPECT_EQ(7U, branches.size());
1018         tags.clear();
1019         EXPECT_EQ(0, m_Git.GetTagList(tags));
1020         EXPECT_EQ(3U, tags.size());
1021         refs.clear();
1022         EXPECT_EQ(0, m_Git.GetRefList(refs));
1023         EXPECT_EQ(12U, refs.size());
1024
1025         EXPECT_EQ(-1, m_Git.DeleteRef(L"refs/heads/gibbednet"));
1026         branches.clear();
1027         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1028         EXPECT_EQ(7U, branches.size());
1029         tags.clear();
1030         EXPECT_EQ(0, m_Git.GetTagList(tags));
1031         EXPECT_EQ(3U, tags.size());
1032         refs.clear();
1033         EXPECT_EQ(0, m_Git.GetRefList(refs));
1034         EXPECT_EQ(12U, refs.size());
1035
1036         EXPECT_EQ(-1, m_Git.DeleteRef(L"refs/remotes/origin/gibbednet"));
1037         branches.clear();
1038         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1039         EXPECT_EQ(7U, branches.size());
1040         tags.clear();
1041         EXPECT_EQ(0, m_Git.GetTagList(tags));
1042         EXPECT_EQ(3U, tags.size());
1043         refs.clear();
1044         EXPECT_EQ(0, m_Git.GetRefList(refs));
1045         EXPECT_EQ(12U, refs.size());
1046
1047         EXPECT_EQ(0, m_Git.DeleteRef(L"refs/tags/normal-tag"));
1048         branches.clear();
1049         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1050         EXPECT_EQ(7U, branches.size());
1051         tags.clear();
1052         EXPECT_EQ(0, m_Git.GetTagList(tags));
1053         EXPECT_EQ(2U, tags.size());
1054         refs.clear();
1055         EXPECT_EQ(0, m_Git.GetRefList(refs));
1056         EXPECT_EQ(11U, refs.size());
1057
1058         EXPECT_EQ(0, m_Git.DeleteRef(L"refs/tags/all-files-signed^{}"));
1059         branches.clear();
1060         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1061         EXPECT_EQ(7U, branches.size());
1062         tags.clear();
1063         EXPECT_EQ(0, m_Git.GetTagList(tags));
1064         EXPECT_EQ(1U, tags.size());
1065         refs.clear();
1066         EXPECT_EQ(0, m_Git.GetRefList(refs));
1067         EXPECT_EQ(10U, refs.size());
1068
1069         EXPECT_EQ(0, m_Git.DeleteRef(L"refs/heads/subdir/branch"));
1070         branches.clear();
1071         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1072         EXPECT_EQ(6U, branches.size());
1073         tags.clear();
1074         EXPECT_EQ(0, m_Git.GetTagList(tags));
1075         EXPECT_EQ(1U, tags.size());
1076         refs.clear();
1077         EXPECT_EQ(0, m_Git.GetRefList(refs));
1078         EXPECT_EQ(9U, refs.size());
1079
1080         EXPECT_EQ(0, m_Git.DeleteRef(L"refs/remotes/origin/master"));
1081         branches.clear();
1082         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1083         EXPECT_EQ(5U, branches.size());
1084         tags.clear();
1085         EXPECT_EQ(0, m_Git.GetTagList(tags));
1086         EXPECT_EQ(1U, tags.size());
1087         refs.clear();
1088         EXPECT_EQ(0, m_Git.GetRefList(refs));
1089         EXPECT_EQ(8U, refs.size());
1090 }
1091
1092 TEST_P(CBasicGitWithTestRepoFixture, GetBranchesTagsRefs)
1093 {
1094         GetBranchesTagsRefs(m_Git, GetParam());
1095 }
1096
1097 TEST_P(CBasicGitWithTestRepoBareFixture, GetBranchesTagsRefs)
1098 {
1099         GetBranchesTagsRefs(m_Git, GetParam());
1100 }
1101
1102 TEST_P(CBasicGitWithTestRepoFixture, GetBranchList_orphan)
1103 {
1104         CString output;
1105         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
1106         EXPECT_STRNE(L"", output);
1107
1108         STRING_VECTOR branches;
1109         int current = -2;
1110         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1111         ASSERT_EQ(6U, branches.size());
1112         EXPECT_EQ(-2, current);
1113         EXPECT_STREQ(L"forconflict", branches[0]);
1114         EXPECT_STREQ(L"master", branches[1]);
1115         EXPECT_STREQ(L"master2", branches[2]);
1116         EXPECT_STREQ(L"signed-commit", branches[3]);
1117         EXPECT_STREQ(L"simple-conflict", branches[4]);
1118         EXPECT_STREQ(L"subdir/branch", branches[5]);
1119 }
1120
1121 TEST_P(CBasicGitWithTestRepoFixture, GetBranchList_detachedhead)
1122 {
1123         CString output;
1124         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout a9d53b535cb49640a6099860ac4999f5a0857b91", &output, CP_UTF8));
1125         EXPECT_STRNE(L"", output);
1126
1127         STRING_VECTOR branches;
1128         int current = -2;
1129         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1130         ASSERT_EQ(6U, branches.size());
1131         EXPECT_EQ(-2, current);
1132         EXPECT_STREQ(L"forconflict", branches[0]);
1133         EXPECT_STREQ(L"master", branches[1]);
1134         EXPECT_STREQ(L"master2", branches[2]);
1135         EXPECT_STREQ(L"signed-commit", branches[3]);
1136         EXPECT_STREQ(L"simple-conflict", branches[4]);
1137         EXPECT_STREQ(L"subdir/branch", branches[5]);
1138
1139         branches.clear();
1140         current = -2;
1141         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_LOCAL, true));
1142         ASSERT_EQ(6U, branches.size());
1143         EXPECT_EQ(-2, current);
1144         EXPECT_STREQ(L"forconflict", branches[0]);
1145         EXPECT_STREQ(L"master", branches[1]);
1146         EXPECT_STREQ(L"master2", branches[2]);
1147         EXPECT_STREQ(L"signed-commit", branches[3]);
1148         EXPECT_STREQ(L"simple-conflict", branches[4]);
1149         EXPECT_STREQ(L"subdir/branch", branches[5]);
1150
1151         // cygwin fails here
1152         if (CGit::ms_bCygwinGit)
1153                 return;
1154
1155         output.Empty();
1156         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout -b (HEAD a9d53b535cb49640a6099860ac4999f5a0857b91", &output, CP_UTF8));
1157         EXPECT_STRNE(L"", output);
1158
1159         branches.clear();
1160         current = -2;
1161         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1162         ASSERT_EQ(7U, branches.size());
1163         EXPECT_EQ(0, current);
1164         EXPECT_STREQ(L"(HEAD", branches[0]);
1165         EXPECT_STREQ(L"forconflict", branches[1]);
1166         EXPECT_STREQ(L"master", branches[2]);
1167         EXPECT_STREQ(L"master2", branches[3]);
1168         EXPECT_STREQ(L"signed-commit", branches[4]);
1169         EXPECT_STREQ(L"simple-conflict", branches[5]);
1170         EXPECT_STREQ(L"subdir/branch", branches[6]);
1171 }
1172
1173 TEST_P(CBasicGitWithEmptyBareRepositoryFixture, GetEmptyBranchesTagsRefs)
1174 {
1175         EXPECT_STREQ(L"master", m_Git.GetCurrentBranch());
1176
1177         STRING_VECTOR branches;
1178         int current = -2;
1179         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1180         EXPECT_TRUE(branches.empty());
1181         EXPECT_EQ(-2, current); // not touched
1182
1183         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
1184         EXPECT_TRUE(branches.empty());
1185         EXPECT_EQ(-2, current); // not touched
1186
1187         STRING_VECTOR tags;
1188         EXPECT_EQ(0, m_Git.GetTagList(tags));
1189         EXPECT_TRUE(tags.empty());
1190
1191         STRING_VECTOR refs;
1192         EXPECT_EQ(0, m_Git.GetRefList(refs));
1193         EXPECT_TRUE(refs.empty());
1194
1195         MAP_HASH_NAME map;
1196         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
1197         EXPECT_TRUE(map.empty());
1198
1199         STRING_VECTOR remotes;
1200         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
1201         EXPECT_TRUE(remotes.empty());
1202 }
1203
1204 TEST_P(CBasicGitWithEmptyRepositoryFixture, CheckCleanWorkTree)
1205 {
1206         // this test is known to fail with cygwin and also not enabled by default
1207         if (GetParam() == LIBGIT2_ALL && CGit::ms_bCygwinGit)
1208                 return;
1209
1210         CString output;
1211         CString testFile = m_Dir.GetTempDir() + L"\\test.txt";
1212         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing file."));
1213         EXPECT_EQ(0, m_Git.Run(L"git.exe add test.txt", &output, CP_UTF8));
1214         output.Empty();
1215         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Add test.txt\"", &output, CP_UTF8));
1216         // repo with 1 versioned file
1217         EXPECT_STRNE(L"", output);
1218         EXPECT_TRUE(m_Git.CheckCleanWorkTree());
1219         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
1220
1221         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"Overwriting this testing file."));
1222         // repo with 1 modified versioned file
1223         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
1224         EXPECT_FALSE(m_Git.CheckCleanWorkTree(true));
1225
1226         output.Empty();
1227         EXPECT_EQ(0, m_Git.Run(L"git.exe add test.txt", &output, CP_UTF8));
1228         // repo with 1 modified versioned and staged file
1229         EXPECT_STREQ(L"", output);
1230         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
1231         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
1232
1233         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Modified test.txt\"", &output, CP_UTF8));
1234         testFile = m_Dir.GetTempDir() + L"\\test2.txt";
1235         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is ANOTHER testing file."));
1236         EXPECT_TRUE(m_Git.CheckCleanWorkTree());
1237         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
1238
1239         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
1240         EXPECT_STRNE(L"", output);
1241         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
1242         EXPECT_FALSE(m_Git.CheckCleanWorkTree(true));
1243 }
1244
1245 TEST(CGit, CEnvironment)
1246 {
1247         CEnvironment env;
1248         wchar_t** basePtr = env;
1249         ASSERT_TRUE(basePtr);
1250         EXPECT_FALSE(*basePtr);
1251         EXPECT_TRUE(env.empty());
1252         env.SetEnv(L"not-found", nullptr);
1253         EXPECT_FALSE(static_cast<wchar_t*>(env));
1254         EXPECT_STREQ(L"", env.GetEnv(L"test"));
1255         env.SetEnv(L"key1", L"value1");
1256         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1257         EXPECT_STREQ(L"value1", env.GetEnv(L"kEy1")); // check case insensitivity
1258         EXPECT_TRUE(*basePtr);
1259         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1260         EXPECT_FALSE(env.empty());
1261         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1262         env.SetEnv(L"key1", nullptr); // delete first
1263         EXPECT_FALSE(*basePtr);
1264         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1265         EXPECT_TRUE(env.empty());
1266         env.SetEnv(L"key1", L"value1");
1267         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1268         EXPECT_TRUE(*basePtr);
1269         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1270         EXPECT_FALSE(env.empty());
1271         env.SetEnv(L"key2", L"value2");
1272         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1273         EXPECT_STREQ(L"value2", env.GetEnv(L"key2"));
1274         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1275         env.SetEnv(L"not-found", nullptr);
1276         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1277         EXPECT_STREQ(L"value2", env.GetEnv(L"key2"));
1278         env.SetEnv(L"key2", nullptr); // delete last
1279         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1280         EXPECT_STREQ(L"", env.GetEnv(L"key2"));
1281         env.SetEnv(L"key3", L"value3");
1282         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1283         EXPECT_STREQ(L"value3", env.GetEnv(L"key3"));
1284         env.SetEnv(L"key4", L"value4");
1285         env.SetEnv(L"value3", nullptr); // delete middle
1286         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1287         EXPECT_STREQ(L"value4", env.GetEnv(L"key4"));
1288         env.SetEnv(L"key5", L"value5");
1289         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1290         EXPECT_STREQ(L"value4", env.GetEnv(L"key4"));
1291         EXPECT_STREQ(L"value5", env.GetEnv(L"key5"));
1292         env.SetEnv(L"key4", L"value4a");
1293         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1294         EXPECT_STREQ(L"value4a", env.GetEnv(L"key4"));
1295         EXPECT_STREQ(L"value5", env.GetEnv(L"key5"));
1296         env.SetEnv(L"key5", L"value5a");
1297         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1298         EXPECT_STREQ(L"value4a", env.GetEnv(L"key4"));
1299         EXPECT_STREQ(L"value5a", env.GetEnv(L"key5"));
1300 #pragma warning(push)
1301 #pragma warning(disable: 4996)
1302         CString windir = _wgetenv(L"windir");
1303 #pragma warning(pop)
1304         env.CopyProcessEnvironment();
1305         EXPECT_STREQ(windir, env.GetEnv(L"windir"));
1306         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1307         EXPECT_STREQ(L"value4a", env.GetEnv(L"key4"));
1308         EXPECT_STREQ(L"value5a", env.GetEnv(L"key5"));
1309         env.clear();
1310         EXPECT_FALSE(*basePtr);
1311         EXPECT_TRUE(env.empty());
1312         EXPECT_STREQ(L"", env.GetEnv(L"key4"));
1313         env.CopyProcessEnvironment();
1314         EXPECT_STREQ(windir, env.GetEnv(L"windir"));
1315         EXPECT_TRUE(*basePtr);
1316
1317         // make sure baseptr always points to current values
1318         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1319
1320         env.clear();
1321         CString path = L"c:\\windows;c:\\windows\\system32";
1322         env.SetEnv(L"PATH", path);
1323         env.AddToPath(L"");
1324         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1325         env.AddToPath(L"c:\\windows");
1326         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1327         env.AddToPath(L"c:\\windows\\");
1328         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1329         env.AddToPath(L"c:\\windows\\system32");
1330         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1331         env.AddToPath(L"c:\\windows\\system32\\");
1332         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1333         path += L";c:\\windows\\system";
1334         env.AddToPath(L"c:\\windows\\system");
1335         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1336         path += L";c:\\test";
1337         env.AddToPath(L"c:\\test\\");
1338         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1339         env.AddToPath(L"c:\\test\\");
1340         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1341         env.AddToPath(L"c:\\test");
1342         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1343         path = L"c:\\windows;c:\\windows\\system32;";
1344         env.SetEnv(L"PATH", path);
1345         env.AddToPath(L"");
1346         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1347         env.AddToPath(L"c:\\test");
1348         path += L"c:\\test";
1349         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1350
1351         // also test copy constructor
1352         CEnvironment env2(env);
1353         EXPECT_EQ(static_cast<wchar_t*>(env2), *static_cast<wchar_t**>(env2));
1354         EXPECT_NE(static_cast<wchar_t*>(env2), *basePtr);
1355
1356         // also test assignment operation
1357         CEnvironment env3a;
1358         basePtr = env3a;
1359         env3a.SetEnv(L"something", L"else");
1360         CEnvironment env3b;
1361         env3b = env3a;
1362         EXPECT_FALSE(env3b.empty());
1363         EXPECT_EQ(static_cast<wchar_t**>(env3a), basePtr);
1364         EXPECT_EQ(static_cast<wchar_t*>(env3a), *basePtr);
1365         EXPECT_NE(static_cast<wchar_t*>(env3b), *basePtr);
1366 }
1367
1368 static void GetOneFile(CGit& m_Git)
1369 {
1370         CString tmpFile = GetTempFile();
1371         EXPECT_EQ(0, m_Git.GetOneFile(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", CTGitPath(L"utf8-nobom.txt"), tmpFile));
1372         CString fileContents;
1373         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1374         struct _stat32 stat_buf = { 0 };
1375         EXPECT_EQ(0, _wstat32(tmpFile, &stat_buf));
1376         EXPECT_EQ(139, stat_buf.st_size);
1377         EXPECT_EQ(108, fileContents.GetLength());
1378         EXPECT_STREQ(L"ä#äf34ööcöäß€9875oe\r\nfgdjkglsfdg\r\nöäöü45g\r\nfdgi&§$%&hfdsgä\r\nä#äf34öööäß€9875oe\r\nöäcüpfgmfdg\r\n€fgfdsg\r\n45\r\näü", fileContents);
1379         ::DeleteFile(tmpFile);
1380 }
1381
1382 TEST_P(CBasicGitWithTestRepoFixture, GetOneFile)
1383 {
1384         GetOneFile(m_Git);
1385
1386         // clean&smudge filters are not available for GetOneFile without libigt2
1387         if (GetParam() == GIT_CLI || GetParam() == LIBGIT)
1388                 return;
1389
1390         CString cleanFilterFilename = m_Git.m_CurrentDir + L"\\clean_filter_openssl";
1391         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(cleanFilterFilename, L"#!/bin/bash\nopenssl enc -base64 -aes-256-ecb -S FEEDDEADBEEF -k PASS_FIXED"));
1392         CString smudgeFilterFilename = m_Git.m_CurrentDir + L"\\smudge_filter_openssl";
1393         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(smudgeFilterFilename, L"#!/bin/bash\nopenssl enc -d -base64 -aes-256-ecb -k PASS_FIXED"));
1394
1395         CAutoRepository repo(m_Git.GetGitRepository());
1396         ASSERT_TRUE(repo.IsValid());
1397         CAutoConfig config(repo);
1398         ASSERT_TRUE(config.IsValid());
1399         CStringA path = CUnicodeUtils::GetUTF8(m_Git.m_CurrentDir);
1400         path.Replace('\\', '/');
1401         EXPECT_EQ(0, git_config_set_string(config, "filter.openssl.clean", path + "/clean_filter_openssl"));
1402         EXPECT_EQ(0, git_config_set_string(config, "filter.openssl.smudge", path + "/smudge_filter_openssl"));
1403         EXPECT_EQ(0, git_config_set_bool(config, "filter.openssl.required", 1));
1404
1405         CString attributesFile = m_Git.m_CurrentDir + L"\\.gitattributes";
1406         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(attributesFile, L"*.enc filter=openssl\n"));
1407
1408         CString encryptedFileOne = m_Git.m_CurrentDir + L"\\1.enc";
1409         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(encryptedFileOne, L"This should be encrypted...\nAnd decrypted on the fly\n"));
1410
1411         CString encryptedFileTwo = m_Git.m_CurrentDir + L"\\2.enc";
1412         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(encryptedFileTwo, L"This should also be encrypted...\nAnd also decrypted on the fly\n"));
1413
1414         CString output;
1415         EXPECT_EQ(0, m_Git.Run(L"git.exe add 1.enc", &output, CP_UTF8));
1416         if (!g_Git.ms_bCygwinGit) // on AppVeyor with the VS2017 image we get a warning: "WARNING: can't open config file: /usr/local/ssl/openssl.cnf"
1417                 EXPECT_STREQ(L"", output);
1418
1419         CAutoIndex index;
1420         ASSERT_EQ(0, git_repository_index(index.GetPointer(), repo));
1421         EXPECT_EQ(0, git_index_add_bypath(index, "2.enc"));
1422         EXPECT_EQ(0, git_index_write(index));
1423
1424         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Message\"", &output, CP_UTF8));
1425         EXPECT_STRNE(L"", output);
1426
1427         CString fileContents;
1428         CString tmpFile = GetTempFile();
1429         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"1.enc"), tmpFile));
1430         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1431         EXPECT_STREQ(L"This should be encrypted...\nAnd decrypted on the fly\n", fileContents);
1432         ::DeleteFile(tmpFile);
1433
1434         fileContents.Empty();
1435         tmpFile = GetTempFile();
1436         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"2.enc"), tmpFile));
1437         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1438         EXPECT_STREQ(L"This should also be encrypted...\nAnd also decrypted on the fly\n", fileContents);
1439         ::DeleteFile(tmpFile);
1440
1441         EXPECT_TRUE(::DeleteFile(attributesFile));
1442
1443         fileContents.Empty();
1444         tmpFile = GetTempFile();
1445         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"1.enc"), tmpFile));
1446         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1447         EXPECT_STREQ(L"U2FsdGVkX1/+7d6tvu8AABwbE+Xy7U4l5boTKjIgUkYHONqmYHD+0e6k35MgtUGx\ns11nq1QuKeFCW5wFWNSj1WcHg2n4W59xfnB7RkSSIDQ=\n", fileContents);
1448         ::DeleteFile(tmpFile);
1449
1450         fileContents.Empty();
1451         tmpFile = GetTempFile();
1452         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"2.enc"), tmpFile));
1453         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1454         EXPECT_STREQ(L"U2FsdGVkX1/+7d6tvu8AAIDDx8qi/l0qzkSMsS2YLt8tYK1oWzj8+o78fXH0/tlO\nCRVrKqTvh9eUFklY8QFYfZfj01zBkFat+4zrW+1rV4Q=\n", fileContents);
1455         ::DeleteFile(tmpFile);
1456 }
1457
1458 TEST_P(CBasicGitWithTestRepoBareFixture, GetOneFile)
1459 {
1460         GetOneFile(m_Git);
1461 }
1462
1463 static void GetBranchDescriptions(CGit& m_Git)
1464 {
1465         MAP_STRING_STRING descriptions;
1466         EXPECT_EQ(0, m_Git.GetBranchDescriptions(descriptions));
1467         EXPECT_EQ(0U, descriptions.size());
1468
1469         g_Git.SetConfigValue(L"branch.master.description", L"test");
1470         g_Git.SetConfigValue(L"branch.subdir/branch.description", L"multi\nline");
1471
1472         EXPECT_EQ(0, m_Git.GetBranchDescriptions(descriptions));
1473         ASSERT_EQ(2U, descriptions.size());
1474         EXPECT_STREQ(L"test", descriptions[L"master"]);
1475         EXPECT_STREQ(L"multi\nline", descriptions[L"subdir/branch"]);
1476 }
1477
1478 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetBranchDescriptions)
1479 {
1480         GetBranchDescriptions(m_Git);
1481 }
1482
1483 TEST_P(CBasicGitWithEmptyBareRepositoryFixture, GetBranchDescriptions)
1484 {
1485         GetBranchDescriptions(m_Git);
1486 }
1487
1488 TEST_P(CBasicGitWithTestRepoFixture, Config)
1489 {
1490         EXPECT_STREQ(L"", m_Git.GetConfigValue(L"not-found"));
1491         EXPECT_STREQ(L"default", m_Git.GetConfigValue(L"not-found", L"default"));
1492
1493         EXPECT_STREQ(L"false", m_Git.GetConfigValue(L"core.bare"));
1494         EXPECT_STREQ(L"false", m_Git.GetConfigValue(L"core.bare", L"default-value")); // value exist, so default does not match
1495         EXPECT_STREQ(L"true", m_Git.GetConfigValue(L"core.ignorecase"));
1496         EXPECT_STREQ(L"0", m_Git.GetConfigValue(L"core.repositoryformatversion"));
1497         EXPECT_STREQ(L"https://example.com/git/testing", m_Git.GetConfigValue(L"remote.origin.url"));
1498
1499         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"not-found"));
1500         EXPECT_EQ(true, m_Git.GetConfigValueBool(L"not-found", true));
1501         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"core.bare"));
1502         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"core.bare", true)); // value exist, so default does not match
1503         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"core.repositoryformatversion"));
1504         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"remote.origin.url"));
1505         EXPECT_EQ(true, m_Git.GetConfigValueBool(L"core.ignorecase"));
1506
1507         CString values[] = { L"", L" ", L"ending-with-space ", L" starting with-space", L"test1", L"some\\backslashes\\in\\it", L"with \" doublequote", L"with backslash before \\\" doublequote", L"with'quote", L"multi\nline", L"no-multi\\nline", L"new line at end\n" };
1508         for (int i = 0; i < _countof(values); ++i)
1509         {
1510                 CString key;
1511                 key.Format(L"re-read.test%d", i);
1512                 EXPECT_EQ(0, m_Git.SetConfigValue(key, values[i]));
1513                 EXPECT_STREQ(values[i], m_Git.GetConfigValue(key));
1514         }
1515
1516         m_Git.SetConfigValue(L"booltest.true1", L"1");
1517         m_Git.SetConfigValue(L"booltest.true2", L"100");
1518         m_Git.SetConfigValue(L"booltest.true3", L"-2");
1519         m_Git.SetConfigValue(L"booltest.true4", L"yes");
1520         m_Git.SetConfigValue(L"booltest.true5", L"yEs");
1521         m_Git.SetConfigValue(L"booltest.true6", L"true");
1522         m_Git.SetConfigValue(L"booltest.true7", L"on");
1523         for (int i = 1; i <= 7; ++i)
1524         {
1525                 CString key;
1526                 key.Format(L"booltest.true%d", i);
1527                 EXPECT_EQ(true, m_Git.GetConfigValueBool(key));
1528         }
1529         m_Git.SetConfigValue(L"booltest.false1", L"0");
1530         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"booltest.false1"));
1531         m_Git.SetConfigValue(L"booltest.false2", L"");
1532         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"booltest.false2"));
1533
1534         EXPECT_EQ(0, m_Git.GetConfigValueInt32(L"does-not-exist"));
1535         EXPECT_EQ(15, m_Git.GetConfigValueInt32(L"does-not-exist", 15));
1536         EXPECT_EQ(0, m_Git.GetConfigValueInt32(L"core.repositoryformatversion"));
1537         EXPECT_EQ(0, m_Git.GetConfigValueInt32(L"core.repositoryformatversion", 42)); // value exist, so default should not be returned
1538         EXPECT_EQ(1, m_Git.GetConfigValueInt32(L"booltest.true1"));
1539         EXPECT_EQ(100, m_Git.GetConfigValueInt32(L"booltest.true2"));
1540         EXPECT_EQ(-2, m_Git.GetConfigValueInt32(L"booltest.true3"));
1541         EXPECT_EQ(0, m_Git.GetConfigValueInt32(L"booltest.true4"));
1542         EXPECT_EQ(42, m_Git.GetConfigValueInt32(L"booltest.true4", 42));
1543         EXPECT_EQ(0, m_Git.GetConfigValueInt32(L"booltest.true8"));
1544         EXPECT_EQ(42, m_Git.GetConfigValueInt32(L"booltest.true8", 42));
1545
1546         EXPECT_NE(0, m_Git.UnsetConfigValue(L"does-not-exist"));
1547         EXPECT_STREQ(L"false", m_Git.GetConfigValue(L"core.bare"));
1548         EXPECT_STREQ(L"true", m_Git.GetConfigValue(L"core.ignorecase"));
1549         EXPECT_EQ(0, m_Git.UnsetConfigValue(L"core.bare"));
1550         EXPECT_STREQ(L"default", m_Git.GetConfigValue(L"core.bare", L"default"));
1551         EXPECT_STREQ(L"true", m_Git.GetConfigValue(L"core.ignorecase"));
1552
1553         CString gitConfig = m_Git.m_CurrentDir + L"\\.git\\config";
1554         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(gitConfig, L"[booltest]\nistrue"));
1555         EXPECT_EQ(true, m_Git.GetConfigValueBool(L"booltest.istrue"));
1556
1557         // test includes from %HOME% specified as ~/
1558         EXPECT_STREQ(L"not-found", g_Git.GetConfigValue(L"test.fromincluded", L"not-found"));
1559         EXPECT_EQ(0, m_Git.SetConfigValue(L"include.path", L"~/a-path-that-should-not-exist.gconfig"));
1560         EXPECT_STREQ(L"~/a-path-that-should-not-exist.gconfig", g_Git.GetConfigValue(L"include.path", L"not-found"));
1561         CString testFile = g_Git.GetHomeDirectory() + L"\\a-path-that-should-not-exist.gconfig";
1562         ASSERT_FALSE(PathFileExists(testFile)); // make sure we don't override a file by mistake ;)
1563         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"[test]\nfromincluded=yeah-this-is-included\n"));
1564         EXPECT_STREQ(L"yeah-this-is-included", g_Git.GetConfigValue(L"test.fromincluded", L"not-found"));
1565         EXPECT_TRUE(::DeleteFile(testFile));
1566 }
1567
1568 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges)
1569 {
1570         if (GetParam() != 0)
1571                 return;
1572
1573         // adding ansi2.txt (as a copy of ansi.txt) produces a warning
1574         m_Git.SetConfigValue(L"core.autocrlf", L"false");
1575
1576         CString output;
1577         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1578         EXPECT_STRNE(L"", output);
1579
1580         CTGitPathList filter(CTGitPath(L"copy"));
1581
1582         // no changes
1583         CTGitPathList list;
1584         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1585         EXPECT_TRUE(list.IsEmpty());
1586         list.Clear();
1587         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1588         ASSERT_EQ(1, list.GetCount());
1589         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1590         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1591         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1592         EXPECT_FALSE(list[0].IsDirectory());
1593         list.Clear();
1594         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1595         EXPECT_TRUE(list.IsEmpty());
1596         list.Clear();
1597         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1598         ASSERT_EQ(0, list.GetCount());
1599         list.Clear();
1600         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1601         ASSERT_EQ(1, list.GetCount());
1602         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1603         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1604         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1605         EXPECT_FALSE(list[0].IsDirectory());
1606
1607         // untracked file
1608         CString testFile = m_Git.m_CurrentDir + L"\\untracked-file.txt";
1609         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1610         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1611         EXPECT_TRUE(list.IsEmpty());
1612         list.Clear();
1613         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1614         ASSERT_EQ(1, list.GetCount());
1615         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1616         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1617         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1618         EXPECT_FALSE(list[0].IsDirectory());
1619         list.Clear();
1620         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1621         EXPECT_TRUE(list.IsEmpty());
1622         list.Clear();
1623         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1624         ASSERT_EQ(0, list.GetCount());
1625         list.Clear();
1626         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1627         ASSERT_EQ(1, list.GetCount());
1628         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1629         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1630         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1631         EXPECT_FALSE(list[0].IsDirectory());
1632
1633         // untracked file in sub-directory
1634         testFile = m_Git.m_CurrentDir + L"\\copy\\untracked-file.txt";
1635         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1636         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1637         EXPECT_TRUE(list.IsEmpty());
1638         list.Clear();
1639         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1640         ASSERT_EQ(1, list.GetCount());
1641         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1642         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1643         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1644         EXPECT_FALSE(list[0].IsDirectory());
1645         list.Clear();
1646         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1647         EXPECT_TRUE(list.IsEmpty());
1648         list.Clear();
1649         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1650         EXPECT_TRUE(list.IsEmpty());
1651         list.Clear();
1652         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1653         ASSERT_EQ(1, list.GetCount());
1654         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1655         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1656         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1657         EXPECT_FALSE(list[0].IsDirectory());
1658
1659         // modified file in sub-directory
1660         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
1661         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1662         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1663         ASSERT_EQ(1, list.GetCount());
1664         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1665         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1666         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1667         EXPECT_FALSE(list[0].IsDirectory());
1668         list.Clear();
1669         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1670         ASSERT_EQ(2, list.GetCount());
1671         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1672         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1673         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1674         EXPECT_FALSE(list[0].IsDirectory());
1675         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1676         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1677         EXPECT_FALSE(list[1].IsDirectory());
1678         list.Clear();
1679         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1680         ASSERT_EQ(1, list.GetCount());
1681         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1682         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1683         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1684         EXPECT_FALSE(list[0].IsDirectory());
1685         list.Clear();
1686         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1687         ASSERT_EQ(1, list.GetCount());
1688         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1689         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1690         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1691         EXPECT_FALSE(list[0].IsDirectory());
1692         list.Clear();
1693         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1694         ASSERT_EQ(2, list.GetCount());
1695         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1696         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1697         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1698         EXPECT_FALSE(list[0].IsDirectory());
1699         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1700         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1701         EXPECT_FALSE(list[1].IsDirectory());
1702
1703         // two modified files, one in root and one in sub-directory
1704         output.Empty();
1705         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1706         EXPECT_STRNE(L"", output);
1707         testFile = m_Git.m_CurrentDir + L"\\utf8-bom.txt";
1708         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1709         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
1710         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1711         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1712         ASSERT_EQ(2, list.GetCount());
1713         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1714         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1715         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1716         EXPECT_FALSE(list[0].IsDirectory());
1717         EXPECT_STREQ(L"utf8-bom.txt", list[1].GetGitPathString());
1718         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1719         EXPECT_FALSE(list[1].IsDirectory());
1720         list.Clear();
1721         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1722         ASSERT_EQ(3, list.GetCount());
1723         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1724         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1725         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1726         EXPECT_FALSE(list[0].IsDirectory());
1727         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1728         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1729         EXPECT_FALSE(list[1].IsDirectory());
1730         EXPECT_STREQ(L"utf8-bom.txt", list[2].GetGitPathString());
1731         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
1732         EXPECT_FALSE(list[2].IsDirectory());
1733         list.Clear();
1734         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1735         ASSERT_EQ(1, list.GetCount());
1736         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1737         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1738         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1739         EXPECT_FALSE(list[0].IsDirectory());
1740         list.Clear();
1741         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1742         ASSERT_EQ(1, list.GetCount());
1743         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1744         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1745         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1746         EXPECT_FALSE(list[0].IsDirectory());
1747         list.Clear();
1748         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1749         ASSERT_EQ(2, list.GetCount());
1750         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1751         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1752         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1753         EXPECT_FALSE(list[0].IsDirectory());
1754         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1755         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1756         EXPECT_FALSE(list[1].IsDirectory());
1757
1758         // Staged modified file
1759         output.Empty();
1760         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1761         EXPECT_STRNE(L"", output);
1762         testFile = m_Git.m_CurrentDir + L"\\utf8-nobom.txt";
1763         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1764         output.Empty();
1765         EXPECT_EQ(0, m_Git.Run(L"git.exe add utf8-nobom.txt", &output, CP_UTF8));
1766         EXPECT_STREQ(L"", output);
1767         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1768         ASSERT_EQ(1, list.GetCount());
1769         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1770         EXPECT_STREQ(L"utf8-nobom.txt", list[0].GetGitPathString());
1771         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1772         EXPECT_FALSE(list[0].IsDirectory());
1773         list.Clear();
1774         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1775         ASSERT_EQ(2, list.GetCount());
1776         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1777         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1778         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1779         EXPECT_FALSE(list[0].IsDirectory());
1780         EXPECT_STREQ(L"utf8-nobom.txt", list[1].GetGitPathString());
1781         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1782         EXPECT_FALSE(list[1].IsDirectory());
1783         list.Clear();
1784         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
1785         ASSERT_EQ(0, list.GetCount());
1786         list.Clear();
1787         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
1788         ASSERT_EQ(1, list.GetCount());
1789         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1790         EXPECT_STREQ(L"utf8-nobom.txt", list[0].GetGitPathString());
1791         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1792         EXPECT_FALSE(list[0].IsDirectory());
1793         list.Clear();
1794         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1795         ASSERT_EQ(0, list.GetCount());
1796         list.Clear();
1797         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1798         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1799         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1800         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1801         EXPECT_FALSE(list[0].IsDirectory());
1802         EXPECT_STREQ(L"utf8-nobom.txt", list[1].GetGitPathString());
1803         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1804         EXPECT_FALSE(list[1].IsDirectory());
1805
1806         // Staged modified file in subfolder
1807         output.Empty();
1808         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1809         EXPECT_STRNE(L"", output);
1810         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
1811         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1812         output.Empty();
1813         EXPECT_EQ(0, m_Git.Run(L"git.exe add copy/utf8-nobom.txt", &output, CP_UTF8));
1814         EXPECT_STREQ(L"", output);
1815         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1816         ASSERT_EQ(1, list.GetCount());
1817         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1818         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1819         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1820         EXPECT_FALSE(list[0].IsDirectory());
1821         list.Clear();
1822         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1823         ASSERT_EQ(2, list.GetCount());
1824         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1825         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1826         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1827         EXPECT_FALSE(list[0].IsDirectory());
1828         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1829         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1830         EXPECT_FALSE(list[1].IsDirectory());
1831         list.Clear();
1832         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1833         ASSERT_EQ(1, list.GetCount());
1834         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1835         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1836         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1837         EXPECT_FALSE(list[0].IsDirectory());
1838         list.Clear();
1839         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1840         ASSERT_EQ(1, list.GetCount());
1841         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1842         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1843         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1844         EXPECT_FALSE(list[0].IsDirectory());
1845         list.Clear();
1846         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1847         ASSERT_EQ(2, list.GetCount());
1848         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1849         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1850         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1851         EXPECT_FALSE(list[0].IsDirectory());
1852         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1853         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1854         EXPECT_FALSE(list[1].IsDirectory());
1855
1856         // Modified file modified after staging
1857         output.Empty();
1858         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1859         EXPECT_STRNE(L"", output);
1860         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
1861         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1862         output.Empty();
1863         EXPECT_EQ(0, m_Git.Run(L"git.exe add copy/utf8-nobom.txt", &output, CP_UTF8));
1864         EXPECT_STREQ(L"", output);
1865         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"now with different content after staging"));
1866         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1867         ASSERT_EQ(1, list.GetCount());
1868         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1869         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1870         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1871         EXPECT_FALSE(list[0].IsDirectory());
1872         list.Clear();
1873         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1874         ASSERT_EQ(2, list.GetCount());
1875         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1876         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1877         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1878         EXPECT_FALSE(list[0].IsDirectory());
1879         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1880         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1881         EXPECT_FALSE(list[1].IsDirectory());
1882         list.Clear();
1883         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1884         ASSERT_EQ(1, list.GetCount());
1885         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1886         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1887         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1888         EXPECT_FALSE(list[0].IsDirectory());
1889         list.Clear();
1890         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1891         ASSERT_EQ(1, list.GetCount());
1892         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1893         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1894         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1895         EXPECT_FALSE(list[0].IsDirectory());
1896         list.Clear();
1897         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1898         ASSERT_EQ(2, list.GetCount());
1899         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1900         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1901         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1902         EXPECT_FALSE(list[0].IsDirectory());
1903         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1904         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1905         EXPECT_FALSE(list[1].IsDirectory());
1906
1907         // Missing file
1908         output.Empty();
1909         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1910         EXPECT_STRNE(L"", output);
1911         EXPECT_TRUE(::DeleteFile(m_Dir.GetTempDir()+L"\\copy\\ansi.txt"));
1912         list.Clear();
1913         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1914         ASSERT_EQ(1, list.GetCount());
1915         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1916         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
1917         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
1918         list.Clear();
1919         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1920         ASSERT_EQ(2, list.GetCount());
1921         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1922         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1923         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1924         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
1925         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[1].m_Action);
1926         list.Clear();
1927         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1928         ASSERT_EQ(1, list.GetCount());
1929         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1930         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
1931         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
1932         list.Clear();
1933         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1934         ASSERT_EQ(1, list.GetCount());
1935         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1936         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
1937         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
1938         list.Clear();
1939         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1940         ASSERT_EQ(2, list.GetCount());
1941         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1942         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1943         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1944         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
1945         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[1].m_Action);
1946
1947         // deleted file, also deleted in index
1948         output.Empty();
1949         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1950         EXPECT_STRNE(L"", output);
1951         output.Empty();
1952         EXPECT_EQ(0, m_Git.Run(L"git.exe rm copy/ansi.txt", &output, CP_UTF8));
1953         EXPECT_STRNE(L"", output);
1954         list.Clear();
1955         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1956         ASSERT_EQ(1, list.GetCount());
1957         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1958         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
1959         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
1960         list.Clear();
1961         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1962         ASSERT_EQ(2, list.GetCount());
1963         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1964         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1965         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1966         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
1967         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
1968         list.Clear();
1969         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1970         ASSERT_EQ(1, list.GetCount());
1971         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1972         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
1973         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
1974         list.Clear();
1975         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1976         ASSERT_EQ(1, list.GetCount());
1977         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1978         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
1979         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
1980         list.Clear();
1981         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1982         ASSERT_EQ(2, list.GetCount());
1983         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1984         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1985         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1986         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
1987         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
1988
1989         // file deleted in index, but still on disk
1990         output.Empty();
1991         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1992         EXPECT_STRNE(L"", output);
1993         output.Empty();
1994         EXPECT_EQ(0, m_Git.Run(L"git.exe rm --cached copy/ansi.txt", &output, CP_UTF8));
1995         EXPECT_STRNE(L"", output);
1996         list.Clear();
1997         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1998         ASSERT_EQ(1, list.GetCount());
1999         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2000         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2001         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2002         EXPECT_FALSE(list[0].IsDirectory());
2003         list.Clear();
2004         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2005         ASSERT_EQ(2, list.GetCount());
2006         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2007         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2008         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2009         EXPECT_FALSE(list[0].IsDirectory());
2010         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2011         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2012         EXPECT_FALSE(list[1].IsDirectory());
2013         list.Clear();
2014         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2015         ASSERT_EQ(1, list.GetCount());
2016         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2017         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2018         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2019         EXPECT_FALSE(list[0].IsDirectory());
2020         list.Clear();
2021         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2022         ASSERT_EQ(1, list.GetCount());
2023         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2024         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2025         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2026         EXPECT_FALSE(list[0].IsDirectory());
2027         list.Clear();
2028         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2029         ASSERT_EQ(2, list.GetCount());
2030         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2031         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2032         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2033         EXPECT_FALSE(list[0].IsDirectory());
2034         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2035         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2036         EXPECT_FALSE(list[1].IsDirectory());
2037
2038         // file deleted in index, but still on disk, but modified
2039         output.Empty();
2040         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2041         EXPECT_STRNE(L"", output);
2042         output.Empty();
2043         EXPECT_EQ(0, m_Git.Run(L"git.exe rm --cached copy/ansi.txt", &output, CP_UTF8));
2044         EXPECT_STRNE(L"", output);
2045         testFile = m_Git.m_CurrentDir + L"\\copy\\ansi.txt";
2046         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
2047         list.Clear();
2048         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2049         ASSERT_EQ(1, list.GetCount());
2050         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2051         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2052         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2053         EXPECT_FALSE(list[0].IsDirectory());
2054         list.Clear();
2055         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2056         ASSERT_EQ(2, list.GetCount());
2057         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2058         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2059         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2060         EXPECT_FALSE(list[0].IsDirectory());
2061         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2062         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2063         EXPECT_FALSE(list[1].IsDirectory());
2064         list.Clear();
2065         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2066         ASSERT_EQ(1, list.GetCount());
2067         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2068         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2069         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2070         EXPECT_FALSE(list[0].IsDirectory());
2071         list.Clear();
2072         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2073         ASSERT_EQ(1, list.GetCount());
2074         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2075         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2076         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2077         EXPECT_FALSE(list[0].IsDirectory());
2078         list.Clear();
2079         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2080         ASSERT_EQ(2, list.GetCount());
2081         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2082         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2083         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2084         EXPECT_FALSE(list[0].IsDirectory());
2085         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2086         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2087         EXPECT_FALSE(list[1].IsDirectory());
2088
2089         // renamed file in same folder (root)
2090         output.Empty();
2091         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2092         EXPECT_STRNE(L"", output);
2093         output.Empty();
2094         EXPECT_EQ(0, m_Git.Run(L"git.exe mv ansi.txt ansi2.txt", &output, CP_UTF8));
2095         EXPECT_STREQ(L"", output);
2096         list.Clear();
2097         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2098         ASSERT_EQ(1, list.GetCount());
2099         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2100         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
2101         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2102         EXPECT_FALSE(list[0].IsDirectory());
2103         list.Clear();
2104         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2105         ASSERT_EQ(2, list.GetCount());
2106         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2107         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
2108         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2109         EXPECT_FALSE(list[0].IsDirectory());
2110         EXPECT_STREQ(L"ascii.txt", list[1].GetGitPathString());
2111         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2112         EXPECT_FALSE(list[1].IsDirectory());
2113         list.Clear();
2114         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2115         ASSERT_EQ(0, list.GetCount());
2116         list.Clear();
2117         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2118         ASSERT_EQ(1, list.GetCount());
2119         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2120         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
2121         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2122         EXPECT_FALSE(list[0].IsDirectory());
2123         list.Clear();
2124         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2125         ASSERT_EQ(0, list.GetCount());
2126         list.Clear();
2127         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2128         ASSERT_EQ(2, list.GetCount());
2129         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2130         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
2131         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2132         EXPECT_FALSE(list[0].IsDirectory());
2133         EXPECT_STREQ(L"ascii.txt", list[1].GetGitPathString());
2134         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2135         EXPECT_FALSE(list[1].IsDirectory());
2136
2137         // renamed file in same folder (subfolder)
2138         output.Empty();
2139         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2140         EXPECT_STRNE(L"", output);
2141         output.Empty();
2142         EXPECT_EQ(0, m_Git.Run(L"git.exe mv copy/ansi.txt copy/ansi2.txt", &output, CP_UTF8));
2143         EXPECT_STREQ(L"", output);
2144         list.Clear();
2145         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2146         ASSERT_EQ(1, list.GetCount());
2147         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2148         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2149         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2150         EXPECT_FALSE(list[0].IsDirectory());
2151         list.Clear();
2152         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2153         ASSERT_EQ(2, list.GetCount());
2154         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2155         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2156         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2157         EXPECT_FALSE(list[0].IsDirectory());
2158         EXPECT_STREQ(L"copy/ansi2.txt", list[1].GetGitPathString());
2159         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2160         EXPECT_FALSE(list[1].IsDirectory());
2161         list.Clear();
2162         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2163         ASSERT_EQ(1, list.GetCount());
2164         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2165         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2166         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2167         EXPECT_FALSE(list[0].IsDirectory());
2168         list.Clear();
2169         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2170         ASSERT_EQ(1, list.GetCount());
2171         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2172         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2173         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2174         EXPECT_FALSE(list[0].IsDirectory());
2175         list.Clear();
2176         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2177         ASSERT_EQ(1, list.GetCount());
2178         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2179         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2180         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2181         EXPECT_FALSE(list[0].IsDirectory());
2182         list.Clear();
2183         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2184         ASSERT_EQ(2, list.GetCount());
2185         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2186         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2187         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2188         EXPECT_FALSE(list[0].IsDirectory());
2189         EXPECT_STREQ(L"copy/ansi2.txt", list[1].GetGitPathString());
2190         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2191         EXPECT_FALSE(list[1].IsDirectory());
2192
2193         // added and staged new file
2194         output.Empty();
2195         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2196         EXPECT_STRNE(L"", output);
2197         testFile = m_Git.m_CurrentDir + L"\\copy\\test-file.txt";
2198         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
2199         output.Empty();
2200         EXPECT_EQ(0, m_Git.Run(L"git.exe add copy/test-file.txt", &output, CP_UTF8));
2201         EXPECT_STREQ(L"", output);
2202         list.Clear();
2203         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2204         ASSERT_EQ(1, list.GetCount());
2205         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2206         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
2207         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2208         EXPECT_FALSE(list[0].IsDirectory());
2209         list.Clear();
2210         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2211         ASSERT_EQ(2, list.GetCount());
2212         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2213         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2214         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2215         EXPECT_FALSE(list[0].IsDirectory());
2216         EXPECT_STREQ(L"copy/test-file.txt", list[1].GetGitPathString());
2217         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
2218         EXPECT_FALSE(list[1].IsDirectory());
2219         list.Clear();
2220         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2221         ASSERT_EQ(1, list.GetCount());
2222         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2223         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
2224         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2225         EXPECT_FALSE(list[0].IsDirectory());
2226         list.Clear();
2227         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2228         ASSERT_EQ(1, list.GetCount());
2229         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2230         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
2231         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2232         EXPECT_FALSE(list[0].IsDirectory());
2233         list.Clear();
2234         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2235         ASSERT_EQ(2, list.GetCount());
2236         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2237         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2238         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2239         EXPECT_FALSE(list[0].IsDirectory());
2240         EXPECT_STREQ(L"copy/test-file.txt", list[1].GetGitPathString());
2241         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
2242         EXPECT_FALSE(list[1].IsDirectory());
2243
2244         // file copied and staged
2245         output.Empty();
2246         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2247         EXPECT_STRNE(L"", output);
2248         testFile = m_Git.m_CurrentDir + L"\\ansi.txt";
2249         EXPECT_TRUE(CopyFile(m_Git.m_CurrentDir + L"\\ansi.txt", m_Git.m_CurrentDir + L"\\ansi2.txt", TRUE));
2250         output.Empty();
2251         EXPECT_EQ(0, m_Git.Run(L"git.exe add ansi2.txt", &output, CP_UTF8));
2252         EXPECT_STREQ(L"", output);
2253         list.Clear();
2254         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2255         ASSERT_EQ(1, list.GetCount());
2256         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2257         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
2258         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2259         EXPECT_FALSE(list[0].IsDirectory());
2260         list.Clear();
2261         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2262         ASSERT_EQ(2, list.GetCount());
2263         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2264         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
2265         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2266         EXPECT_FALSE(list[0].IsDirectory());
2267         EXPECT_STREQ(L"ascii.txt", list[1].GetGitPathString());
2268         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2269         EXPECT_FALSE(list[1].IsDirectory());
2270         list.Clear();
2271         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2272         ASSERT_EQ(0, list.GetCount());
2273         list.Clear();
2274         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2275         ASSERT_EQ(1, list.GetCount());
2276         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2277         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
2278         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2279         EXPECT_FALSE(list[0].IsDirectory());
2280         list.Clear();
2281         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2282         ASSERT_EQ(0, list.GetCount());
2283         list.Clear();
2284         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2285         ASSERT_EQ(2, list.GetCount());
2286         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2287         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
2288         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2289         EXPECT_FALSE(list[0].IsDirectory());
2290         EXPECT_STREQ(L"ascii.txt", list[1].GetGitPathString());
2291         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2292         EXPECT_FALSE(list[1].IsDirectory());
2293
2294         // file renamed + moved to sub-folder
2295         output.Empty();
2296         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2297         EXPECT_STRNE(L"", output);
2298         output.Empty();
2299         EXPECT_EQ(0, m_Git.Run(L"git.exe mv ansi.txt copy/ansi2.txt", &output, CP_UTF8));
2300         EXPECT_STREQ(L"", output);
2301         list.Clear();
2302         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2303         ASSERT_EQ(1, list.GetCount());
2304         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2305         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2306         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2307         EXPECT_FALSE(list[0].IsDirectory());
2308         list.Clear();
2309         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2310         ASSERT_EQ(2, list.GetCount());
2311         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2312         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2313         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2314         EXPECT_FALSE(list[0].IsDirectory());
2315         EXPECT_STREQ(L"copy/ansi2.txt", list[1].GetGitPathString());
2316         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2317         EXPECT_FALSE(list[1].IsDirectory());
2318         list.Clear();
2319         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false)); // TODO: due to filter restrictions we cannot detect the rename here
2320         ASSERT_EQ(1, list.GetCount());
2321         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2322         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2323         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action); // TODO
2324         EXPECT_FALSE(list[0].IsDirectory());
2325         list.Clear();
2326         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2327         ASSERT_EQ(1, list.GetCount());
2328         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2329         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2330         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2331         EXPECT_FALSE(list[0].IsDirectory());
2332         list.Clear();
2333         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false)); // TODO: due to filter restrictions we cannot detect the rename here
2334         ASSERT_EQ(1, list.GetCount());
2335         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2336         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2337         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action); // TODO
2338         EXPECT_FALSE(list[0].IsDirectory());
2339         list.Clear();
2340         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2341         ASSERT_EQ(2, list.GetCount());
2342         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2343         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2344         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2345         EXPECT_FALSE(list[0].IsDirectory());
2346         EXPECT_STREQ(L"copy/ansi2.txt", list[1].GetGitPathString());
2347         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_ADDED, list[1].m_Action); // TODO
2348         EXPECT_FALSE(list[1].IsDirectory());
2349
2350         // conflicting files
2351         output.Empty();
2352         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2353         EXPECT_STRNE(L"", output);
2354         output.Empty();
2355         EXPECT_EQ(0, m_Git.Run(L"git.exe merge forconflict", &output, CP_UTF8));
2356         EXPECT_STRNE(L"", output);
2357         output.Empty();
2358         EXPECT_EQ(1, m_Git.Run(L"git.exe merge simple-conflict", &output, CP_UTF8));
2359         EXPECT_STRNE(L"", output);
2360         list.Clear();
2361         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2362         ASSERT_EQ(1, list.GetCount());
2363         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2364         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2365         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2366         EXPECT_FALSE(list[0].IsDirectory());
2367         list.Clear();
2368         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2369         ASSERT_EQ(7, list.GetCount());
2370         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2371         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2372         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2373         EXPECT_FALSE(list[0].IsDirectory());
2374         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
2375         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2376         EXPECT_FALSE(list[1].IsDirectory());
2377         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
2378         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
2379         EXPECT_FALSE(list[2].IsDirectory());
2380         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
2381         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
2382         EXPECT_FALSE(list[3].IsDirectory());
2383         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
2384         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
2385         EXPECT_FALSE(list[4].IsDirectory());
2386         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
2387         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
2388         EXPECT_FALSE(list[5].IsDirectory());
2389         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
2390         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
2391         EXPECT_FALSE(list[6].IsDirectory());
2392         list.Clear();
2393         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2394         ASSERT_EQ(0, list.GetCount());
2395         list.Clear();
2396         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2397         ASSERT_EQ(1, list.GetCount());
2398         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list.GetAction());
2399         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2400         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
2401         EXPECT_FALSE(list[0].IsDirectory());
2402         list.Clear();
2403         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2404         ASSERT_EQ(0, list.GetCount());
2405         list.Clear();
2406         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2407         ASSERT_EQ(7, list.GetCount());
2408         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2409         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2410         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
2411         EXPECT_FALSE(list[0].IsDirectory());
2412         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
2413         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2414         EXPECT_FALSE(list[1].IsDirectory());
2415         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
2416         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
2417         EXPECT_FALSE(list[2].IsDirectory());
2418         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
2419         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
2420         EXPECT_FALSE(list[3].IsDirectory());
2421         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
2422         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
2423         EXPECT_FALSE(list[4].IsDirectory());
2424         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
2425         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
2426         EXPECT_FALSE(list[5].IsDirectory());
2427         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
2428         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
2429         EXPECT_FALSE(list[6].IsDirectory());
2430 }
2431
2432 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges_DeleteModifyConflict_DeletedRemotely)
2433 {
2434         if (GetParam() != 0)
2435                 return;
2436
2437         CString output;
2438         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2439         EXPECT_STRNE(L"", output);
2440
2441         output.Empty();
2442         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout forconflict", &output, CP_UTF8));
2443         EXPECT_STRNE(L"", output);
2444         output.Empty();
2445         EXPECT_EQ(0, m_Git.Run(L"git.exe rm ansi.txt", &output, CP_UTF8));
2446         EXPECT_STRNE(L"", output);
2447         output.Empty();
2448         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Prepare conflict case\"", &output, CP_UTF8));
2449         EXPECT_STRNE(L"", output);
2450         output.Empty();
2451         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout simple-conflict", &output, CP_UTF8));
2452         EXPECT_STRNE(L"", output);
2453         output.Empty();
2454         EXPECT_EQ(1, m_Git.Run(L"git.exe merge forconflict", &output, CP_UTF8));
2455         EXPECT_STRNE(L"", output);
2456
2457         CTGitPathList filter(CTGitPath(L"copy"));
2458
2459         CTGitPathList list;
2460         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2461         ASSERT_EQ(7, list.GetCount());
2462         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2463         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2464         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2465         EXPECT_FALSE(list[0].IsDirectory());
2466         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
2467         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2468         EXPECT_FALSE(list[1].IsDirectory());
2469         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
2470         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
2471         EXPECT_FALSE(list[2].IsDirectory());
2472         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
2473         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
2474         EXPECT_FALSE(list[3].IsDirectory());
2475         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
2476         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
2477         EXPECT_FALSE(list[4].IsDirectory());
2478         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
2479         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
2480         EXPECT_FALSE(list[5].IsDirectory());
2481         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
2482         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
2483         EXPECT_FALSE(list[6].IsDirectory());
2484         list.Clear();
2485         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2486         ASSERT_EQ(7, list.GetCount());
2487         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2488         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2489         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2490         EXPECT_FALSE(list[0].IsDirectory());
2491         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
2492         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2493         EXPECT_FALSE(list[1].IsDirectory());
2494         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
2495         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
2496         EXPECT_FALSE(list[2].IsDirectory());
2497         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
2498         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
2499         EXPECT_FALSE(list[3].IsDirectory());
2500         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
2501         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
2502         EXPECT_FALSE(list[4].IsDirectory());
2503         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
2504         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
2505         EXPECT_FALSE(list[5].IsDirectory());
2506         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
2507         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
2508         EXPECT_FALSE(list[6].IsDirectory());
2509         list.Clear();
2510         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2511         ASSERT_EQ(0, list.GetCount());
2512         list.Clear();
2513         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2514         ASSERT_EQ(7, list.GetCount());
2515         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2516         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2517         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
2518         EXPECT_FALSE(list[0].IsDirectory());
2519         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
2520         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2521         EXPECT_FALSE(list[1].IsDirectory());
2522         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
2523         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
2524         EXPECT_FALSE(list[2].IsDirectory());
2525         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
2526         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
2527         EXPECT_FALSE(list[3].IsDirectory());
2528         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
2529         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
2530         EXPECT_FALSE(list[4].IsDirectory());
2531         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
2532         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
2533         EXPECT_FALSE(list[5].IsDirectory());
2534         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
2535         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
2536         EXPECT_FALSE(list[6].IsDirectory());
2537 }
2538
2539 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges_DeleteModifyConflict_DeletedLocally)
2540 {
2541         if (GetParam() != 0)
2542                 return;
2543
2544         CString output;
2545         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2546         EXPECT_STRNE(L"", output);
2547
2548         output.Empty();
2549         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout forconflict", &output, CP_UTF8));
2550         EXPECT_STRNE(L"", output);
2551         output.Empty();
2552         EXPECT_EQ(0, m_Git.Run(L"git.exe rm ansi.txt", &output, CP_UTF8));
2553         EXPECT_STRNE(L"", output);
2554         output.Empty();
2555         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Prepare conflict case\"", &output, CP_UTF8));
2556         EXPECT_STRNE(L"", output);
2557         output.Empty();
2558         EXPECT_EQ(1, m_Git.Run(L"git.exe merge simple-conflict", &output, CP_UTF8));
2559         EXPECT_STRNE(L"", output);
2560
2561         CTGitPathList filter(CTGitPath(L"copy"));
2562
2563         CTGitPathList list;
2564         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2565         ASSERT_EQ(1, list.GetCount());
2566         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2567         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2568         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2569         EXPECT_FALSE(list[0].IsDirectory());
2570         list.Clear();
2571         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2572         ASSERT_EQ(1, list.GetCount());
2573         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2574         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2575         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2576         EXPECT_FALSE(list[0].IsDirectory());
2577         list.Clear();
2578         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2579         ASSERT_EQ(0, list.GetCount());
2580         list.Clear();
2581         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2582         ASSERT_EQ(1, list.GetCount());
2583         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list.GetAction());
2584         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2585         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
2586         EXPECT_FALSE(list[0].IsDirectory());
2587 }
2588
2589 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetWorkingTreeChanges)
2590 {
2591         if (GetParam() != 0)
2592                 return;
2593
2594         CTGitPathList list;
2595         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2596         EXPECT_TRUE(list.IsEmpty());
2597
2598         CString testFile = m_Dir.GetTempDir() + L"\\test.txt";
2599         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing file."));
2600         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2601         EXPECT_TRUE(list.IsEmpty());
2602         CString output;
2603         EXPECT_EQ(0, m_Git.Run(L"git.exe add test.txt", &output, CP_UTF8));
2604         EXPECT_STREQ(L"", output);
2605         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2606         ASSERT_EQ(1, list.GetCount());
2607         // EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction()); // we do not care here for the list action, as its only used in GitLogListBase and there we re-calculate it in AsyncDiffThread
2608         EXPECT_STREQ(L"test.txt", list[0].GetGitPathString());
2609         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2610         EXPECT_FALSE(list[0].IsDirectory());
2611
2612         CTGitPathList filter(CTGitPath(L"copy"));
2613         list.Clear();
2614         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2615         ASSERT_EQ(1, list.GetCount());
2616         // EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction()); // we do not care here for the list action, as its only used in GitLogListBase and there we re-calculate it in AsyncDiffThread
2617         EXPECT_STREQ(L"test.txt", list[0].GetGitPathString());
2618         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2619         EXPECT_FALSE(list[0].IsDirectory());
2620
2621         list.Clear();
2622         EXPECT_TRUE(::CreateDirectory(m_Dir.GetTempDir() + L"\\copy", nullptr));
2623         testFile = m_Dir.GetTempDir() + L"\\copy\\test2.txt";
2624         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is another testing file."));
2625         EXPECT_EQ(0, m_Git.Run(L"git.exe add copy/test2.txt", &output, CP_UTF8));
2626         EXPECT_STREQ(L"", output);
2627         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2628         ASSERT_EQ(2, list.GetCount());
2629         // EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction()); // we do not care here for the list action, as its only used in GitLogListBase and there we re-calculate it in AsyncDiffThread
2630         EXPECT_STREQ(L"copy/test2.txt", list[0].GetGitPathString());
2631         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2632         EXPECT_FALSE(list[0].IsDirectory());
2633         EXPECT_STREQ(L"test.txt", list[1].GetGitPathString());
2634         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
2635         EXPECT_FALSE(list[1].IsDirectory());
2636 }
2637
2638 static int DoSubmodule(const CString& cmd, CGit& git, const CString& submoduleDir, CString& output)
2639 {
2640         output.Empty();
2641         CString old = git.m_CurrentDir;
2642         SCOPE_EXIT { git.m_CurrentDir = old; };
2643         git.m_CurrentDir = submoduleDir;
2644         return git.Run(cmd, &output, CP_UTF8);
2645 }
2646
2647 TEST_P(CBasicGitWithSubmoduleRepositoryFixture, GetWorkingTreeChanges_Submodules)
2648 {
2649         if (GetParam() != 0)
2650                 return;
2651
2652         CTGitPathList list;
2653
2654         CString resourcesDir;
2655         ASSERT_TRUE(GetResourcesDir(resourcesDir));
2656         CString submoduleDir = m_Dir.GetTempDir() + L"\\submodule";
2657         ASSERT_TRUE(CreateDirectory(submoduleDir, nullptr));
2658         ASSERT_TRUE(CreateDirectory(submoduleDir + L"\\.git", nullptr));
2659         CString repoDir = resourcesDir + L"\\git-repo1";
2660         CopyRecursively(repoDir, submoduleDir + L"\\.git");
2661
2662         CString output;
2663         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2664         EXPECT_STRNE(L"", output);
2665
2666         // test for clean repo which contains an unrelated git submodule
2667         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2668         EXPECT_TRUE(list.IsEmpty());
2669
2670         // test for added, uncommitted submodule
2671         output.Empty();
2672         EXPECT_EQ(0, m_Git.Run(L"git.exe add submodule", &output, CP_UTF8));
2673         //EXPECT_STREQ(L"", output); // Git 2.14 starts to print a warning here
2674         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2675         ASSERT_EQ(1, list.GetCount());
2676         // EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction()); // we do not care here for the list action, as its only used in GitLogListBase and there we re-calculate it in AsyncDiffThread
2677         EXPECT_STREQ(L"submodule", list[0].GetGitPathString());
2678         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2679         EXPECT_TRUE(list[0].IsDirectory());
2680
2681         // cleanup
2682         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
2683         submoduleDir = m_Dir.GetTempDir() + L"\\something";
2684
2685         // test for unchanged submodule
2686         output.Empty();
2687         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard branch1", &output, CP_UTF8));
2688         EXPECT_STRNE(L"", output);
2689         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2690         ASSERT_EQ(0, list.GetCount());
2691
2692         // test for unchanged submodule with checkout out files
2693         output.Empty();
2694         ASSERT_TRUE(CreateDirectory(submoduleDir + L"\\.git", nullptr));
2695         CopyRecursively(repoDir, submoduleDir + L"\\.git");
2696         EXPECT_EQ(0, DoSubmodule(L"git.exe reset --hard 49ecdfff36bfe2b9b499b33e5034f427e2fa54dd", m_Git, submoduleDir, output));
2697         EXPECT_STRNE(L"", output);
2698         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2699         ASSERT_EQ(0, list.GetCount());
2700
2701         // test for changed submodule
2702         EXPECT_EQ(0, DoSubmodule(L"git.exe reset --hard HEAD~1", m_Git, submoduleDir, output));
2703         EXPECT_STRNE(L"", output);
2704         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2705         ASSERT_EQ(1, list.GetCount());
2706         EXPECT_STREQ(L"something", list[0].GetGitPathString());
2707         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2708         EXPECT_TRUE(list[0].IsDirectory());
2709
2710         // test for modify-delete conflict (deleted remote)
2711         output.Empty();
2712         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force branch1", &output, CP_UTF8));
2713         EXPECT_STRNE(L"", output);
2714         output.Empty();
2715         EXPECT_EQ(1, m_Git.Run(L"git.exe merge deleted", &output, CP_UTF8));
2716         EXPECT_STRNE(L"", output);
2717         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2718         ASSERT_EQ(1, list.GetCount());
2719         EXPECT_STREQ(L"something", list[0].GetGitPathString());
2720         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2721         EXPECT_TRUE(list[0].IsDirectory());
2722
2723         // test for modify-delete conflict (deleted locally)
2724         output.Empty();
2725         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
2726         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force deleted", &output, CP_UTF8));
2727         EXPECT_STRNE(L"", output);
2728         output.Empty();
2729         EXPECT_EQ(1, m_Git.Run(L"git.exe merge branch1", &output, CP_UTF8));
2730         EXPECT_STRNE(L"", output);
2731         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2732         ASSERT_EQ(1, list.GetCount());
2733         EXPECT_STREQ(L"something", list[0].GetGitPathString());
2734         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
2735         EXPECT_FALSE(list[0].IsDirectory()); // neither file nor directory is in filesystem
2736
2737         // test for merge conflict submodule/file (local submodule, remote file)
2738         output.Empty();
2739         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
2740         DeleteFile(submoduleDir);
2741         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force branch1", &output, CP_UTF8));
2742         EXPECT_STRNE(L"", output);
2743         output.Empty();
2744         EXPECT_EQ(1, m_Git.Run(L"git.exe merge file", &output, CP_UTF8));
2745         EXPECT_STRNE(L"", output);
2746         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2747         ASSERT_EQ(1, list.GetCount());
2748         EXPECT_STREQ(L"something", list[0].GetGitPathString());
2749         if (m_Git.ms_bCygwinGit)
2750         {
2751                 EXPECT_TRUE(output.Find(L"error: failed to create path") > 0);
2752                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
2753                 EXPECT_TRUE(list[0].IsDirectory()); // folder is in filesystem
2754         }
2755         else
2756         {
2757                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2758                 EXPECT_FALSE(list[0].IsDirectory()); // file is in filesystem
2759         }
2760
2761         // test for merge conflict submodule/file (remote submodule, local file)
2762         output.Empty();
2763         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
2764         DeleteFile(submoduleDir);
2765         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force file", &output, CP_UTF8));
2766         EXPECT_STRNE(L"", output);
2767         output.Empty();
2768         EXPECT_EQ(1, m_Git.Run(L"git.exe merge branch1", &output, CP_UTF8));
2769         EXPECT_STRNE(L"", output);
2770         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2771         ASSERT_EQ(1, list.GetCount());
2772         EXPECT_STREQ(L"something", list[0].GetGitPathString());
2773         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2774         EXPECT_FALSE(list[0].IsDirectory()); // file is in filesystem
2775
2776         // test for simple merge conflict
2777         DeleteFile(submoduleDir);
2778         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir); // delete .git folder so that we get a simple merge conflict!
2779         output.Empty();
2780         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force branch1", &output, CP_UTF8));
2781         EXPECT_STRNE(L"", output);
2782         output.Empty();
2783         EXPECT_EQ(1, m_Git.Run(L"git.exe merge branch2", &output, CP_UTF8));
2784         EXPECT_STRNE(L"", output);
2785         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2786         ASSERT_EQ(1, list.GetCount());
2787         EXPECT_STREQ(L"something", list[0].GetGitPathString());
2788         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2789         EXPECT_TRUE(list[0].IsDirectory());
2790
2791         // test for submodule to file
2792         DeleteFile(submoduleDir);
2793         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
2794         output.Empty();
2795         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force branch1", &output, CP_UTF8));
2796         EXPECT_STRNE(L"", output);
2797         output.Empty();
2798         EXPECT_EQ(0, m_Git.Run(L"git.exe rm -rf something", &output, CP_UTF8));
2799         EXPECT_STRNE(L"", output);
2800         ASSERT_TRUE(CStringUtils::WriteStringToTextFile(submoduleDir, L"something"));
2801         output.Empty();
2802         EXPECT_EQ(0, m_Git.Run(L"git.exe add something", &output, CP_UTF8));
2803         EXPECT_STREQ(L"", output);
2804         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2805         ASSERT_EQ(1, list.GetCount());
2806         EXPECT_STREQ(L"something", list[0].GetGitPathString());
2807         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2808         EXPECT_FALSE(list[0].IsDirectory());
2809
2810         // test for file to submodule
2811         DeleteFile(submoduleDir);
2812         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
2813         output.Empty();
2814         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force file", &output, CP_UTF8));
2815         EXPECT_STRNE(L"", output);
2816         output.Empty();
2817         EXPECT_EQ(0, m_Git.Run(L"git.exe rm something", &output, CP_UTF8));
2818         EXPECT_STRNE(L"", output);
2819         ASSERT_TRUE(CreateDirectory(submoduleDir, nullptr));
2820         ASSERT_TRUE(CreateDirectory(submoduleDir + L"\\.git", nullptr));
2821         CopyRecursively(repoDir, submoduleDir + L"\\.git");
2822         EXPECT_EQ(0, DoSubmodule(L"git.exe reset --hard 49ecdfff36bfe2b9b499b33e5034f427e2fa54dd", m_Git, submoduleDir, output));
2823         EXPECT_STRNE(L"", output);
2824         output.Empty();
2825         EXPECT_EQ(0, m_Git.Run(L"git.exe add something", &output, CP_UTF8));
2826         //EXPECT_STREQ(L"", output); // Git 2.14 starts to print a warning here
2827         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2828         ASSERT_EQ(1, list.GetCount());
2829         EXPECT_STREQ(L"something", list[0].GetGitPathString());
2830         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2831         EXPECT_FALSE(list[0].IsDirectory());
2832 }
2833
2834 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges_RefreshGitIndex)
2835 {
2836         if (GetParam() != 0)
2837                 return;
2838
2839         // adding ansi2.txt (as a copy of ansi.txt) produces a warning
2840         m_Git.SetConfigValue(L"core.autocrlf", L"false");
2841
2842         CString output;
2843         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2844         EXPECT_STRNE(L"", output);
2845
2846         CTGitPathList list;
2847         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2848         EXPECT_TRUE(list.IsEmpty());
2849
2850         // touch file
2851         HANDLE handle = CreateFile(m_Git.m_CurrentDir + L"\\ascii.txt", GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
2852         ASSERT_NE(handle, INVALID_HANDLE_VALUE);
2853         FILETIME ft;
2854         EXPECT_EQ(TRUE, GetFileTime(handle, nullptr, nullptr, &ft));
2855         ft.dwLowDateTime -= 1000 * 60 * 1000;
2856         EXPECT_NE(0, SetFileTime(handle, nullptr, nullptr, &ft));
2857         CloseHandle(handle);
2858
2859         // START: this is the undesired behavior
2860         // this test is just there so we notice when this change somehow
2861         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2862         if (m_Git.ms_bCygwinGit || m_Git.ms_bMsys2Git)
2863                 EXPECT_EQ(0, list.GetCount());
2864         else
2865                 EXPECT_EQ(1, list.GetCount());
2866         list.Clear();
2867         // END: this is the undesired behavior
2868
2869         m_Git.RefreshGitIndex(); // without this GetWorkingTreeChanges might report this file as modified (if no msys or cygwin hack is on)
2870         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2871         EXPECT_EQ(0, list.GetCount());
2872 }
2873
2874 TEST_P(CBasicGitWithTestRepoFixture, GetBisectTerms)
2875 {
2876         if (m_Git.ms_bCygwinGit)
2877                 return;
2878
2879         CString good, bad;
2880         CString output;
2881
2882         EXPECT_EQ(0, m_Git.Run(L"git.exe bisect start", &output, CP_UTF8));
2883         m_Git.GetBisectTerms(&good, &bad);
2884         EXPECT_STREQ(L"good", good);
2885         EXPECT_STREQ(L"bad", bad);
2886
2887         good.Empty();
2888         bad.Empty();
2889         m_Git.GetBisectTerms(&good, &bad);
2890         EXPECT_STREQ(L"good", good);
2891         EXPECT_STREQ(L"bad", bad);
2892
2893         EXPECT_EQ(0, m_Git.Run(L"git.exe bisect reset", &output, CP_UTF8));
2894
2895         if (m_Git.GetGitVersion(nullptr, nullptr) < 0x02070000)
2896                 return;
2897
2898         EXPECT_EQ(0, m_Git.Run(L"git.exe bisect start --term-good=original --term-bad=changed", &output, CP_UTF8));
2899         m_Git.GetBisectTerms(&good, &bad);
2900         EXPECT_STREQ(L"original", good);
2901         EXPECT_STREQ(L"changed", bad);
2902
2903         EXPECT_EQ(0, m_Git.Run(L"git.exe bisect reset", &output, CP_UTF8));
2904 }
2905
2906 TEST_P(CBasicGitWithTestRepoFixture, GetRefsCommitIsOn)
2907 {
2908         STRING_VECTOR list;
2909         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6"), false, false));
2910         EXPECT_TRUE(list.empty());
2911
2912         list.clear();
2913         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6"), true, true));
2914         ASSERT_EQ(1U, list.size());
2915         EXPECT_STREQ(L"refs/heads/master", list[0]);
2916
2917         list.clear();
2918         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), true, true));
2919         ASSERT_EQ(1U, list.size());
2920         EXPECT_STREQ(L"refs/heads/master", list[0]);
2921
2922         list.clear();
2923         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), false, true));
2924         ASSERT_EQ(1U, list.size());
2925         EXPECT_STREQ(L"refs/heads/master", list[0]);
2926
2927         list.clear();
2928         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), true, true, CGit::BRANCH_REMOTE));
2929         EXPECT_TRUE(list.empty());
2930
2931         list.clear();
2932         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), false, true, CGit::BRANCH_ALL));
2933         ASSERT_EQ(1U, list.size());
2934         EXPECT_STREQ(L"refs/heads/master", list[0]);
2935
2936         list.clear();
2937         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), true, false));
2938         EXPECT_TRUE(list.empty());
2939
2940         list.clear();
2941         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), true, false));
2942         ASSERT_EQ(2U, list.size());
2943         EXPECT_STREQ(L"refs/tags/also-signed", list[0]);
2944         EXPECT_STREQ(L"refs/tags/normal-tag", list[1]);
2945
2946         list.clear();
2947         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"35c91b4ae2f77f4f21a7aba56d3c473c705d89e6"), true, true));
2948         ASSERT_EQ(3U, list.size());
2949         EXPECT_STREQ(L"refs/heads/master", list[0]);
2950         EXPECT_STREQ(L"refs/heads/master2", list[1]);
2951         EXPECT_STREQ(L"refs/tags/also-signed", list[2]);
2952
2953         list.clear();
2954         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"313a41bc88a527289c87d7531802ab484715974f"), false, true));
2955         ASSERT_EQ(6U, list.size());
2956         EXPECT_STREQ(L"refs/heads/forconflict", list[0]);
2957         EXPECT_STREQ(L"refs/heads/master", list[1]);
2958         EXPECT_STREQ(L"refs/heads/master2", list[2]);
2959         EXPECT_STREQ(L"refs/heads/signed-commit", list[3]);
2960         EXPECT_STREQ(L"refs/heads/simple-conflict", list[4]);
2961         EXPECT_STREQ(L"refs/heads/subdir/branch", list[5]);
2962
2963         list.clear();
2964         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"313a41bc88a527289c87d7531802ab484715974f"), false, true, CGit::BRANCH_REMOTE));
2965         ASSERT_EQ(1U, list.size());
2966         EXPECT_STREQ(L"refs/remotes/origin/master", list[0]);
2967
2968         list.clear();
2969         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"313a41bc88a527289c87d7531802ab484715974f"), false, true, CGit::BRANCH_LOCAL));
2970         ASSERT_EQ(6U, list.size());
2971         EXPECT_STREQ(L"refs/heads/forconflict", list[0]);
2972         EXPECT_STREQ(L"refs/heads/master", list[1]);
2973         EXPECT_STREQ(L"refs/heads/master2", list[2]);
2974         EXPECT_STREQ(L"refs/heads/signed-commit", list[3]);
2975         EXPECT_STREQ(L"refs/heads/simple-conflict", list[4]);
2976         EXPECT_STREQ(L"refs/heads/subdir/branch", list[5]);
2977
2978         list.clear();
2979         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"313a41bc88a527289c87d7531802ab484715974f"), false, true, CGit::BRANCH_ALL));
2980         ASSERT_EQ(7U, list.size());
2981         EXPECT_STREQ(L"refs/heads/forconflict", list[0]);
2982         EXPECT_STREQ(L"refs/remotes/origin/master", list[6]);
2983
2984         // test for symbolic refs
2985         CString adminDir;
2986         ASSERT_TRUE(GitAdminDir::GetAdminDirPath(g_Git.m_CurrentDir, adminDir));
2987         adminDir += L"refs\\remotes\\origin\\HEAD";
2988         ASSERT_TRUE(CStringUtils::WriteStringToTextFile(adminDir, L"ref: refs/remotes/origin/master"));
2989         list.clear();
2990         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash(L"313a41bc88a527289c87d7531802ab484715974f"), false, true, CGit::BRANCH_ALL));
2991         ASSERT_EQ(8U, list.size());
2992         EXPECT_STREQ(L"refs/heads/forconflict", list[0]);
2993         EXPECT_STREQ(L"refs/remotes/origin/HEAD", list[6]);
2994         EXPECT_STREQ(L"refs/remotes/origin/master", list[7]);
2995 }
2996
2997 TEST_P(CBasicGitWithTestRepoFixture, GetUnifiedDiff)
2998 {
2999         CString tmpfile = m_Dir.GetTempDir() + L"\\output.txt";
3000         EXPECT_EQ(0, m_Git.GetUnifiedDiff(CTGitPath(L""), L"b02add66f48814a73aa2f0876d6bbc8662d6a9a8", L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", tmpfile, false, false, -1, false));
3001         CString fileContents;
3002         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpfile, fileContents));
3003         EXPECT_STREQ(L" utf8-nobom.txt | 4 ++--\n 1 file changed, 2 insertions(+), 2 deletions(-)\n\ndiff --git a/utf8-nobom.txt b/utf8-nobom.txt\nindex ffa0d50..c225b3f 100644\n--- a/utf8-nobom.txt\n+++ b/utf8-nobom.txt\n@@ -1,9 +1,9 @@\n-ä#äf34öööäß€9875oe\r\n+ä#äf34ööcöäß€9875oe\r\n fgdjkglsfdg\r\n öäöü45g\r\n fdgi&§$%&hfdsgä\r\n ä#äf34öööäß€9875oe\r\n-öäüpfgmfdg\r\n+öäcüpfgmfdg\r\n €fgfdsg\r\n 45\r\n äü\n\\ No newline at end of file\n", fileContents);
3004 }
3005
3006 static void GetGitNotes(CGit& m_Git, config testConfig)
3007 {
3008         if (testConfig != LIBGIT2_ALL)
3009                 return;
3010
3011         CString notes;
3012         EXPECT_EQ(0, m_Git.GetGitNotes(CGitHash(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), notes));
3013         EXPECT_STREQ(L"A note here!\n", notes);
3014
3015         EXPECT_EQ(0, m_Git.GetGitNotes(CGitHash(L"1ce788330fd3a306c8ad37654063ceee13a7f172"), notes));
3016         EXPECT_STREQ(L"", notes);
3017 }
3018
3019 TEST_P(CBasicGitWithTestRepoFixture, GetGitNotes)
3020 {
3021         GetGitNotes(m_Git, GetParam());
3022 }
3023
3024 TEST_P(CBasicGitWithTestRepoBareFixture, GetGitNotes)
3025 {
3026         GetGitNotes(m_Git, GetParam());
3027 }
3028
3029 TEST_P(CBasicGitWithTestRepoFixture, GuessRefForHash)
3030 {
3031         CString ref;
3032         // HEAD
3033         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6")));
3034         EXPECT_STREQ(L"master", ref);
3035
3036         // local branch
3037         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash(L"10385764a4d42d7428bbeb245015f8f338fc1e40")));
3038         EXPECT_STREQ(L"forconflict", ref);
3039
3040         // stash
3041         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb")));
3042         EXPECT_STREQ(CString(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb").Left(m_Git.GetShortHASHLength()), ref);
3043
3044         // tag only
3045         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb")));
3046         EXPECT_STREQ(L"normal-tag", ref);
3047
3048         // local branch & tag
3049         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")));
3050         EXPECT_STREQ(L"master2", ref);
3051
3052         // remote branch
3053         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash(L"a9d53b535cb49640a6099860ac4999f5a0857b91")));
3054         EXPECT_STREQ(L"origin/master", ref);
3055
3056         // no ref
3057         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash(L"1ce788330fd3a306c8ad37654063ceee13a7f172")));
3058         EXPECT_STREQ(CString(L"1ce788330fd3a306c8ad37654063ceee13a7f172").Left(m_Git.GetShortHASHLength()), ref);
3059 }