test/UnitTests/GitTest.cpp

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