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