test/UnitTests/GitTest.cpp

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