test/UnitTests/GitTest.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2015-2021, 2023 - 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_SUITE_P(CGit, CBasicGitWithEmptyRepositoryFixture, testing::Values(GIT_CLI, /*LIBGIT,*/ LIBGIT2, LIBGIT2_ALL));
  27 INSTANTIATE_TEST_SUITE_P(CGit, CBasicGitWithEmptyBareRepositoryFixture, testing::Values(GIT_CLI, /*LIBGIT,*/ LIBGIT2, LIBGIT2_ALL));
  28 INSTANTIATE_TEST_SUITE_P(CGit, CBasicGitWithTestRepoFixture, testing::Values(GIT_CLI, LIBGIT, LIBGIT2, LIBGIT2_ALL));
  29 INSTANTIATE_TEST_SUITE_P(CGit, CBasicGitWithTestRepoBareFixture, testing::Values(GIT_CLI, LIBGIT, LIBGIT2, LIBGIT2_ALL));
  30 INSTANTIATE_TEST_SUITE_P(CGit, CBasicGitWithSubmoduleRepositoryFixture, testing::Values(GIT_CLI, /*LIBGIT,*/ LIBGIT2, LIBGIT2_ALL));
  31
  32 TEST(CGit, RunSet)
  33 {
  34         CString output;
  35         CGit cgit;
  36         ASSERT_EQ(0, cgit.Run(L"cmd /c set", &output, CP_UTF8));
  37         ASSERT_FALSE(output.IsEmpty());
  38         ASSERT_TRUE(output.Find(L"windir")); // should be there on any MS OS ;)
  39 }
  40
  41 TEST(CGit, RunGit)
  42 {
  43         CString output;
  44         CGit cgit;
  45         ASSERT_EQ(0, cgit.Run(L"git --version", &output, CP_UTF8));
  46         ASSERT_FALSE(output.IsEmpty());
  47 }
  48
  49 TEST(CGit, RunGit_BashPipe)
  50 {
  51         CString tmpfile = GetTempFile();
  52         ASSERT_STRNE(L"", tmpfile);
  53         tmpfile.Replace(L'\\', L'/');
  54         ASSERT_TRUE(CStringUtils::WriteStringToTextFile(tmpfile, L"testing piping..."));
  55         SCOPE_EXIT{ ::DeleteFile(tmpfile); };
  56         CString pipefile = GetTempFile();
  57         ASSERT_STRNE(L"", tmpfile);
  58         pipefile.Replace(L'\\', L'/');
  59         CString pipecmd;
  60         pipecmd.Format(L"cat < %s", static_cast<LPCTSTR>(tmpfile));
  61         ASSERT_TRUE(CStringUtils::WriteStringToTextFile(pipefile, pipecmd));
  62         SCOPE_EXIT{ ::DeleteFile(pipefile); };
  63         CString output;
  64         CGit cgit;
  65         ASSERT_EQ(0, cgit.Run(L"bash.exe " + pipefile, &output, CP_UTF8));
  66         ASSERT_STREQ(L"testing piping...", output);
  67 }
  68
  69 TEST(CGit, RunGit_Error)
  70 {
  71         CAutoTempDir tempdir;
  72         CGit cgit;
  73         cgit.m_CurrentDir = tempdir.GetTempDir();
  74
  75         CString output;
  76         EXPECT_NE(0, cgit.Run(L"git-not-found.exe", &output, CP_UTF8)); // Git for Windows returns 2, cygwin-hack returns 127
  77         //EXPECT_STREQ(L"", output); with cygwin-hack we get an error message from sh.exe
  78
  79         output.Empty();
  80         EXPECT_EQ(128, cgit.Run(L"git.exe add file.txt", &output, CP_UTF8));
  81         EXPECT_TRUE(CStringUtils::StartsWithI(output, L"fatal: not a git repository (or any"));
  82 }
  83
  84 TEST_P(CBasicGitWithTestRepoBareFixture, RunGit_AbsolutePath)
  85 {
  86         CAutoTempDir tempdir;
  87
  88         CString output;
  89         EXPECT_EQ(0, m_Git.Run(L"git archive -o " + tempdir.GetTempDir() + L"\\export.zip HEAD", &output, CP_UTF8));
  90         EXPECT_STREQ(L"", output);
  91
  92         EXPECT_TRUE(PathFileExists(tempdir.GetTempDir() + L"\\export.zip"));
  93 }
  94
  95 TEST(CGit, RunLogFile)
  96 {
  97         CAutoTempDir tempdir;
  98         CString tmpfile = tempdir.GetTempDir() + L"\\output.txt";
  99         CString error;
 100         CGit cgit;
 101         ASSERT_EQ(0, cgit.RunLogFile(L"git --version", tmpfile, &error));
 102         EXPECT_STREQ(L"", error);
 103         CString fileContents;
 104         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpfile, fileContents));
 105         EXPECT_TRUE(CStringUtils::StartsWith(fileContents, L"git version "));
 106 }
 107
 108 TEST(CGit, RunLogFile_Set)
 109 {
 110         CAutoTempDir tempdir;
 111         CString tmpfile = tempdir.GetTempDir() + L"\\output.txt";
 112         CString error;
 113         CGit cgit;
 114         ASSERT_EQ(0, cgit.RunLogFile(L"cmd /c set", tmpfile, &error));
 115         EXPECT_STREQ(L"", error);
 116         CString fileContents;
 117         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpfile, fileContents));
 118         EXPECT_TRUE(fileContents.Find(L"windir")); // should be there on any MS OS ;)
 119 }
 120
 121 TEST(CGit, RunLogFile_Error)
 122 {
 123         CAutoTempDir tempdir;
 124         CString tmpfile = tempdir.GetTempDir() + L"\\output.txt";
 125         CString error;
 126         CGit cgit;
 127         cgit.m_CurrentDir = tempdir.GetTempDir();
 128
 129         EXPECT_EQ(128, cgit.RunLogFile(L"git.exe add file.txt", tmpfile, &error));
 130         EXPECT_TRUE(CStringUtils::StartsWithI(error, L"fatal: not a git repository (or any"));
 131         __int64 size = -1;
 132         EXPECT_EQ(0, CGit::GetFileModifyTime(tmpfile, nullptr, nullptr, &size));
 133         EXPECT_EQ(0, size);
 134 }
 135
 136 TEST(CGit, StringAppend)
 137 {
 138         CString string = L"something";
 139         CGit::StringAppend(string, nullptr, CP_UTF8, 0);
 140         EXPECT_STREQ(L"something", string);
 141         constexpr char 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         constexpr char moreBytesUTFEight[] = { 0x68, 0x65, 0x6C, 0x6C, '\xC3', '\xB6', 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         EXPECT_EQ(0, CGit::GetFileModifyTime(testFile, &time2, &isDir, &size));
 190         EXPECT_EQ(time, time2);
 191         EXPECT_FALSE(isDir);
 192         EXPECT_EQ(27, size);
 193
 194         Sleep(250);
 195         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing fileöü."));
 196         __int64 time3 = -1;
 197         isDir = false;
 198         size = -1;
 199         EXPECT_EQ(0, CGit::GetFileModifyTime(testFile, &time3, &isDir, &size));
 200         EXPECT_NE(-1, time3);
 201         EXPECT_FALSE(isDir);
 202         EXPECT_EQ(25, size);
 203         EXPECT_GE(time3, time);
 204 }
 205
 206 TEST(CGit, LoadTextFile)
 207 {
 208         CAutoTempDir tempdir;
 209
 210         CString msg = L"something--";
 211         EXPECT_FALSE(CGit::LoadTextFile(L"does-not-exist.txt", msg));
 212         EXPECT_STREQ(L"something--", msg);
 213
 214         CString testFile = tempdir.GetTempDir() + L"\\test.txt";
 215         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing fileöäü."));
 216         EXPECT_TRUE(CGit::LoadTextFile(testFile, msg));
 217         EXPECT_STREQ(L"something--this is testing fileöäü.\n", msg);
 218
 219         msg.Empty();
 220         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing\nfileöäü."));
 221         EXPECT_TRUE(CGit::LoadTextFile(testFile, msg));
 222         EXPECT_STREQ(L"this is testing\nfileöäü.\n", msg);
 223
 224         msg.Empty();
 225         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is\r\ntesting\nfileöäü.\r\n\r\n"));
 226         EXPECT_TRUE(CGit::LoadTextFile(testFile, msg));
 227         EXPECT_STREQ(L"this is\ntesting\nfileöäü.\n", msg);
 228 }
 229
 230 TEST(CGit, IsBranchNameValid)
 231 {
 232         CGit cgit;
 233         EXPECT_TRUE(cgit.IsBranchNameValid(L"master"));
 234         EXPECT_TRUE(cgit.IsBranchNameValid(L"def/master"));
 235         EXPECT_TRUE(cgit.IsBranchNameValid(L"mäin"));
 236         EXPECT_TRUE(cgit.IsBranchNameValid(L"branch_\u570B\u7ACB1d\u043A"));
 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         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout -b mäin 560deea87853158b22d0c0fd73f60a458d47838a", &output, CP_UTF8));
 463         EXPECT_STREQ(L"mäin", m_Git.GetCurrentBranch());
 464
 465         output.Empty();
 466         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
 467         EXPECT_STRNE(L"", output);
 468
 469         EXPECT_STREQ(L"orphanic", m_Git.GetCurrentBranch());
 470         EXPECT_STREQ(L"orphanic", m_Git.GetCurrentBranch(true));
 471 }
 472
 473 TEST_P(CBasicGitWithTestRepoBareFixture, GetCurrentBranch)
 474 {
 475         EXPECT_STREQ(L"master", m_Git.GetCurrentBranch());
 476         EXPECT_STREQ(L"master", m_Git.GetCurrentBranch(true));
 477 }
 478
 479 static void IsLocalBranch(CGit& m_Git)
 480 {
 481         EXPECT_TRUE(m_Git.IsLocalBranch(L"master"));
 482         EXPECT_TRUE(m_Git.IsLocalBranch(L"subdir/branch"));
 483
 484         EXPECT_FALSE(m_Git.IsLocalBranch(L"no_branch_in_repo"));
 485
 486         EXPECT_FALSE(m_Git.IsLocalBranch(L"commits")); // notes/commits
 487
 488         EXPECT_FALSE(m_Git.IsLocalBranch(L"stash"));
 489
 490         EXPECT_FALSE(m_Git.IsLocalBranch(L"3686b9cf74f1a4ef96d6bfe736595ef9abf0fb8d"));
 491
 492         // exist tags
 493         EXPECT_FALSE(m_Git.IsLocalBranch(L"normal-tag"));
 494         EXPECT_FALSE(m_Git.IsLocalBranch(L"also-signed"));
 495 }
 496
 497 TEST_P(CBasicGitWithTestRepoFixture, IsLocalBranch)
 498 {
 499         IsLocalBranch(m_Git);
 500 }
 501
 502 TEST_P(CBasicGitWithTestRepoBareFixture, IsLocalBranch)
 503 {
 504         IsLocalBranch(m_Git);
 505 }
 506
 507 static void BranchTagExists_IsBranchTagNameUnique(CGit& m_Git)
 508 {
 509         EXPECT_TRUE(m_Git.BranchTagExists(L"master", true));
 510         EXPECT_FALSE(m_Git.BranchTagExists(L"origin/master", true));
 511         EXPECT_FALSE(m_Git.BranchTagExists(L"normal-tag", true));
 512         EXPECT_FALSE(m_Git.BranchTagExists(L"also-signed", true));
 513         EXPECT_FALSE(m_Git.BranchTagExists(L"wuseldusel", true));
 514
 515         EXPECT_FALSE(m_Git.BranchTagExists(L"master", false));
 516         EXPECT_TRUE(m_Git.BranchTagExists(L"normal-tag", false));
 517         EXPECT_TRUE(m_Git.BranchTagExists(L"also-signed", false));
 518         EXPECT_FALSE(m_Git.BranchTagExists(L"wuseldusel", false));
 519
 520         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"master"));
 521         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"simpleconflict"));
 522         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"normal-tag"));
 523         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"also-signed"));
 524         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"origin/master"));
 525
 526         CString output;
 527         EXPECT_EQ(0, m_Git.Run(L"git.exe tag master HEAD~2", &output, CP_UTF8));
 528         EXPECT_STREQ(L"", output);
 529
 530         EXPECT_EQ(0, m_Git.Run(L"git.exe branch normal-tag HEAD~2", &output, CP_UTF8));
 531         EXPECT_STREQ(L"", output);
 532
 533         EXPECT_FALSE(m_Git.IsBranchTagNameUnique(L"master"));
 534         EXPECT_FALSE(m_Git.IsBranchTagNameUnique(L"normal-tag"));
 535         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(L"also-signed"));
 536 }
 537
 538 TEST_P(CBasicGitWithTestRepoFixture, BranchTagExists_IsBranchTagNameUnique)
 539 {
 540         BranchTagExists_IsBranchTagNameUnique(m_Git);
 541 }
 542
 543 TEST_P(CBasicGitWithTestRepoBareFixture, BranchTagExists_IsBranchTagNameUnique)
 544 {
 545         BranchTagExists_IsBranchTagNameUnique(m_Git);
 546 }
 547
 548 static void GetFullRefName(CGit& m_Git)
 549 {
 550         EXPECT_STREQ(L"", m_Git.GetFullRefName(L"does_not_exist"));
 551         EXPECT_STREQ(L"refs/heads/master", m_Git.GetFullRefName(L"master"));
 552         EXPECT_STREQ(L"refs/remotes/origin/master", m_Git.GetFullRefName(L"origin/master"));
 553         EXPECT_STREQ(L"refs/tags/normal-tag", m_Git.GetFullRefName(L"normal-tag"));
 554         EXPECT_STREQ(L"refs/tags/also-signed", m_Git.GetFullRefName(L"also-signed"));
 555
 556         CString output;
 557         EXPECT_EQ(0, m_Git.Run(L"git.exe tag master HEAD~2", &output, CP_UTF8));
 558         EXPECT_STREQ(L"", output);
 559         EXPECT_STREQ(L"", m_Git.GetFullRefName(L"master"));
 560         EXPECT_STREQ(L"refs/remotes/origin/master", m_Git.GetFullRefName(L"origin/master"));
 561
 562         EXPECT_EQ(0, m_Git.Run(L"git.exe branch normal-tag HEAD~2", &output, CP_UTF8));
 563         EXPECT_STREQ(L"", output);
 564         EXPECT_STREQ(L"", m_Git.GetFullRefName(L"normal-tag"));
 565
 566         EXPECT_EQ(0, m_Git.Run(L"git.exe branch origin/master HEAD~2", &output, CP_UTF8));
 567         EXPECT_STREQ(L"", output);
 568         EXPECT_STREQ(L"", m_Git.GetFullRefName(L"origin/master"));
 569 }
 570
 571 TEST_P(CBasicGitWithTestRepoFixture, GetFullRefName)
 572 {
 573         GetFullRefName(m_Git);
 574
 575         CString output;
 576         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
 577         EXPECT_STRNE(L"", output);
 578         EXPECT_STREQ(L"", m_Git.GetFullRefName(L"orphanic"));
 579 }
 580
 581 TEST_P(CBasicGitWithTestRepoBareFixture, GetFullRefName)
 582 {
 583         GetFullRefName(m_Git);
 584 }
 585
 586 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetRemoteTrackedBranch)
 587 {
 588         CString remote, branch;
 589         m_Git.GetRemoteTrackedBranchForHEAD(remote, branch);
 590         EXPECT_STREQ(L"", remote);
 591         EXPECT_STREQ(L"", branch);
 592
 593         m_Git.GetRemoteTrackedBranch(L"master", remote, branch);
 594         EXPECT_STREQ(L"", remote);
 595         EXPECT_STREQ(L"", branch);
 596
 597         m_Git.GetRemoteTrackedBranch(L"non-existing", remote, branch);
 598         EXPECT_STREQ(L"", remote);
 599         EXPECT_STREQ(L"", branch);
 600 }
 601
 602 static void GetRemoteTrackedBranch(CGit& m_Git)
 603 {
 604         CString remote, branch;
 605         m_Git.GetRemoteTrackedBranchForHEAD(remote, branch);
 606         EXPECT_STREQ(L"origin", remote);
 607         EXPECT_STREQ(L"master", branch);
 608
 609         remote.Empty();
 610         branch.Empty();
 611         m_Git.GetRemoteTrackedBranch(L"master", remote, branch);
 612         EXPECT_STREQ(L"origin", remote);
 613         EXPECT_STREQ(L"master", branch);
 614
 615         remote.Empty();
 616         branch.Empty();
 617         m_Git.GetRemoteTrackedBranch(L"non-existing", remote, branch);
 618         EXPECT_STREQ(L"", remote);
 619         EXPECT_STREQ(L"", branch);
 620 }
 621
 622 TEST_P(CBasicGitWithTestRepoFixture, GetRemoteTrackedBranch)
 623 {
 624         GetRemoteTrackedBranch(m_Git);
 625 }
 626
 627 TEST_P(CBasicGitWithTestRepoBareFixture, GetRemoteTrackedBranch)
 628 {
 629         GetRemoteTrackedBranch(m_Git);
 630 }
 631
 632 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetRemotePushBranch)
 633 {
 634         CString remote, branch;
 635         m_Git.GetRemotePushBranch(L"master", remote, branch);
 636         EXPECT_STREQ(L"", remote);
 637         EXPECT_STREQ(L"", branch);
 638
 639         m_Git.GetRemotePushBranch(L"non-existing", remote, branch);
 640         EXPECT_STREQ(L"", remote);
 641         EXPECT_STREQ(L"", branch);
 642 }
 643
 644 static void GetRemotePushBranch(CGit& m_Git)
 645 {
 646         CString remote, branch;
 647         m_Git.GetRemotePushBranch(L"master", remote, branch);
 648         EXPECT_STREQ(L"origin", remote);
 649         EXPECT_STREQ(L"master", branch);
 650
 651         remote.Empty();
 652         branch.Empty();
 653         m_Git.GetRemotePushBranch(L"non-existing", remote, branch);
 654         EXPECT_STREQ(L"", remote);
 655         EXPECT_STREQ(L"", branch);
 656
 657         CAutoRepository repo(m_Git.GetGitRepository());
 658         ASSERT_TRUE(repo.IsValid());
 659         CAutoConfig config(repo);
 660         ASSERT_TRUE(config.IsValid());
 661
 662         remote.Empty();
 663         branch.Empty();
 664         EXPECT_EQ(0, git_config_set_string(config, "remote.pushDefault", "originpush2"));
 665         m_Git.GetRemotePushBranch(L"master", remote, branch);
 666         EXPECT_STREQ(L"originpush2", remote);
 667         EXPECT_STREQ(L"master", branch);
 668
 669         remote.Empty();
 670         branch.Empty();
 671         EXPECT_EQ(0, git_config_set_string(config, "branch.master.pushremote", "originpush3"));
 672         m_Git.GetRemotePushBranch(L"master", remote, branch);
 673         EXPECT_STREQ(L"originpush3", remote);
 674         EXPECT_STREQ(L"master", branch);
 675
 676         remote.Empty();
 677         branch.Empty();
 678         EXPECT_EQ(0, git_config_set_string(config, "branch.master.pushbranch", "masterbranch2"));
 679         m_Git.GetRemotePushBranch(L"master", remote, branch);
 680         EXPECT_STREQ(L"originpush3", remote);
 681         EXPECT_STREQ(L"masterbranch2", branch);
 682
 683         remote.Empty();
 684         branch.Empty();
 685         m_Git.GetRemotePushBranch(L"non-existing", remote, branch);
 686         EXPECT_STREQ(L"originpush2", remote);
 687         EXPECT_STREQ(L"", branch);
 688 }
 689
 690 TEST_P(CBasicGitWithTestRepoFixture, GetRemotePushBranch)
 691 {
 692         GetRemotePushBranch(m_Git);
 693 }
 694
 695 TEST_P(CBasicGitWithTestRepoBareFixture, GetRemotePushBranch)
 696 {
 697         GetRemotePushBranch(m_Git);
 698 }
 699
 700 static void CanParseRev(CGit& m_Git)
 701 {
 702         EXPECT_TRUE(m_Git.CanParseRev(L""));
 703         EXPECT_TRUE(m_Git.CanParseRev(L"HEAD"));
 704         EXPECT_TRUE(m_Git.CanParseRev(L"master"));
 705         EXPECT_TRUE(m_Git.CanParseRev(L"heads/master"));
 706         EXPECT_TRUE(m_Git.CanParseRev(L"refs/heads/master"));
 707         EXPECT_TRUE(m_Git.CanParseRev(L"master~1"));
 708         EXPECT_TRUE(m_Git.CanParseRev(L"master forconflict"));
 709         EXPECT_TRUE(m_Git.CanParseRev(L"origin/master..master"));
 710         EXPECT_TRUE(m_Git.CanParseRev(L"origin/master...master"));
 711         EXPECT_TRUE(m_Git.CanParseRev(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd"));
 712         EXPECT_FALSE(m_Git.CanParseRev(L"non-existing"));
 713         EXPECT_TRUE(m_Git.CanParseRev(L"normal-tag"));
 714         EXPECT_TRUE(m_Git.CanParseRev(L"tags/normal-tag"));
 715         EXPECT_TRUE(m_Git.CanParseRev(L"refs/tags/normal-tag"));
 716         EXPECT_TRUE(m_Git.CanParseRev(L"all-files-signed"));
 717         EXPECT_TRUE(m_Git.CanParseRev(L"all-files-signed^{}"));
 718
 719         EXPECT_FALSE(m_Git.CanParseRev(L"orphanic"));
 720 }
 721
 722 TEST_P(CBasicGitWithTestRepoFixture, CanParseRev)
 723 {
 724         CanParseRev(m_Git);
 725
 726         CString output;
 727         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
 728         EXPECT_STRNE(L"", output);
 729         EXPECT_FALSE(m_Git.CanParseRev(L""));
 730         EXPECT_FALSE(m_Git.CanParseRev(L"HEAD"));
 731         EXPECT_FALSE(m_Git.CanParseRev(L"orphanic"));
 732         EXPECT_TRUE(m_Git.CanParseRev(L"master"));
 733 }
 734
 735 TEST_P(CBasicGitWithTestRepoBareFixture, CanParseRev)
 736 {
 737         CanParseRev(m_Git);
 738 }
 739
 740 static void FETCHHEAD(CGit& m_Git, bool isBare)
 741 {
 742         CString repoDir = m_Git.m_CurrentDir;
 743         if (!isBare)
 744                 repoDir += L"\\.git";
 745
 746         STRING_VECTOR list;
 747         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 748         EXPECT_EQ(6U, list.size());
 749         list.clear();
 750         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 751         EXPECT_EQ(6U, list.size());
 752
 753         EXPECT_STREQ(L"HEAD", m_Git.FixBranchName(L"HEAD"));
 754         EXPECT_STREQ(L"master", m_Git.FixBranchName(L"master"));
 755         EXPECT_STREQ(L"non-existing", m_Git.FixBranchName(L"non-existing"));
 756         CString branch = L"master";
 757         EXPECT_STREQ(L"master", m_Git.FixBranchName_Mod(branch));
 758         EXPECT_STREQ(L"master", branch);
 759         branch = L"non-existing";
 760         EXPECT_STREQ(L"non-existing", m_Git.FixBranchName_Mod(branch));
 761         EXPECT_STREQ(L"non-existing", branch);
 762         CGitHash hash;
 763         EXPECT_NE(0, m_Git.GetHash(hash, L"FETCH_HEAD"));
 764
 765         CString testFile = repoDir + L"\\FETCH_HEAD";
 766         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"));
 767
 768         list.clear();
 769         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 770         EXPECT_EQ(6U, list.size());
 771         list.clear();
 772         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 773         EXPECT_EQ(7U, list.size());
 774
 775         EXPECT_STREQ(L"master", m_Git.FixBranchName(L"master"));
 776         EXPECT_STREQ(L"non-existing", m_Git.FixBranchName(L"non-existing"));
 777         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", m_Git.FixBranchName(L"FETCH_HEAD"));
 778         branch = L"HEAD";
 779         EXPECT_STREQ(L"HEAD", m_Git.FixBranchName_Mod(branch));
 780         EXPECT_STREQ(L"HEAD", branch);
 781         branch = L"master";
 782         EXPECT_STREQ(L"master", m_Git.FixBranchName_Mod(branch));
 783         EXPECT_STREQ(L"master", branch);
 784         branch = L"non-existing";
 785         EXPECT_STREQ(L"non-existing", m_Git.FixBranchName_Mod(branch));
 786         EXPECT_STREQ(L"non-existing", branch);
 787         branch = L"FETCH_HEAD";
 788         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", m_Git.FixBranchName_Mod(branch));
 789         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", branch);
 790         EXPECT_EQ(0, m_Git.GetHash(hash, L"FETCH_HEAD"));
 791         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", hash.ToString());
 792
 793         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"));
 794
 795         list.clear();
 796         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 797         EXPECT_EQ(6U, list.size());
 798         list.clear();
 799         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 800         EXPECT_EQ(7U, list.size());
 801
 802         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", m_Git.FixBranchName(L"FETCH_HEAD"));
 803         branch = L"FETCH_HEAD";
 804         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", m_Git.FixBranchName_Mod(branch));
 805         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", branch);
 806         // libgit2 fails here
 807         //EXPECT_EQ(0, m_Git.GetHash(hash, L"FETCH_HEAD"));
 808         //EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", hash.ToString());
 809 }
 810
 811 TEST_P(CBasicGitWithTestRepoFixture, FETCHHEAD)
 812 {
 813         FETCHHEAD(m_Git, false);
 814 }
 815
 816 TEST_P(CBasicGitWithTestRepoBareFixture, FETCHHEAD)
 817 {
 818         FETCHHEAD(m_Git, true);
 819 }
 820
 821 TEST_P(CBasicGitWithTestRepoFixture, IsFastForward)
 822 {
 823         CGitHash commonAncestor;
 824         EXPECT_TRUE(m_Git.IsFastForward(L"origin/master", L"master", &commonAncestor));
 825         EXPECT_STREQ(L"a9d53b535cb49640a6099860ac4999f5a0857b91", commonAncestor.ToString());
 826
 827         EXPECT_FALSE(m_Git.IsFastForward(L"simple-conflict", L"master", &commonAncestor));
 828         EXPECT_STREQ(L"b02add66f48814a73aa2f0876d6bbc8662d6a9a8", commonAncestor.ToString());
 829 }
 830
 831 static void GetHash(CGit& m_Git, bool orphanedBranch)
 832 {
 833         CGitHash hash;
 834         if (!orphanedBranch)
 835         {
 836                 EXPECT_EQ(0, m_Git.GetHash(hash, L"HEAD"));
 837                 EXPECT_STREQ(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6", hash.ToString());
 838                 EXPECT_EQ(0, m_Git.GetHash(hash, L"HEAD~1"));
 839                 EXPECT_STREQ(L"1fc3c9688e27596d8717b54f2939dc951568f6cb", hash.ToString());
 840         }
 841         else
 842         {
 843                 EXPECT_EQ(0, m_Git.GetHash(hash, L"HEAD"));
 844                 EXPECT_TRUE(hash.IsEmpty());
 845                 EXPECT_NE(0, m_Git.GetHash(hash, L"HEAD~1"));
 846         }
 847         EXPECT_EQ(0, m_Git.GetHash(hash, L"ff1fbef1a54a9849afd4a5e94d2ca4d80d5b96c2"));
 848         EXPECT_STREQ(L"ff1fbef1a54a9849afd4a5e94d2ca4d80d5b96c2", hash.ToString());
 849         EXPECT_EQ(0, m_Git.GetHash(hash, L"master"));
 850         EXPECT_STREQ(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6", hash.ToString());
 851         EXPECT_EQ(0, m_Git.GetHash(hash, L"origin/master"));
 852         EXPECT_STREQ(L"a9d53b535cb49640a6099860ac4999f5a0857b91", hash.ToString());
 853         EXPECT_EQ(0, m_Git.GetHash(hash, L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd"));
 854         EXPECT_STREQ(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd", hash.ToString());
 855         EXPECT_EQ(0, m_Git.GetHash(hash, L"normal-tag"));
 856         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", hash.ToString());
 857         EXPECT_EQ(0, m_Git.GetHash(hash, L"all-files-signed"));
 858         EXPECT_STREQ(L"ab555b2776c6b700ad93848d0dd050e7d08be779", hash.ToString()); // maybe we need automatically to dereference it
 859         EXPECT_EQ(0, m_Git.GetHash(hash, L"all-files-signed^{}"));
 860         EXPECT_STREQ(L"313a41bc88a527289c87d7531802ab484715974f", hash.ToString());
 861
 862         EXPECT_EQ(0, m_Git.GetHash(hash, L"fab555b2776c6b700fffffffffcccccaaaafe779")); // a hash that does not exist, we don't check for it's existance
 863         EXPECT_STREQ(L"fab555b2776c6b700fffffffffcccccaaaafe779", hash.ToString());
 864
 865         EXPECT_NE(0, m_Git.GetHash(hash, L""));
 866         EXPECT_NE(0, m_Git.GetHash(hash, L"non-existing"));
 867         EXPECT_NE(0, m_Git.GetHash(hash, L"orphanic"));
 868 }
 869
 870 TEST_P(CBasicGitWithTestRepoFixture, GetHash)
 871 {
 872         GetHash(m_Git, false);
 873 }
 874
 875 TEST_P(CBasicGitWithTestRepoBareFixture, GetHash)
 876 {
 877         GetHash(m_Git, false);
 878 }
 879
 880 TEST_P(CBasicGitWithTestRepoFixture, GetHash_OrphanBranch)
 881 {
 882         CString output;
 883         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
 884         EXPECT_STRNE(L"", output);
 885
 886         GetHash(m_Git, true);
 887 }
 888
 889 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetHash_EmptyRepo)
 890 {
 891         CGitHash hash;
 892         EXPECT_EQ(0, m_Git.GetHash(hash, L"HEAD"));
 893         EXPECT_TRUE(hash.IsEmpty());
 894 }
 895
 896 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetEmptyBranchesTagsRefs)
 897 {
 898         STRING_VECTOR branches;
 899         int current = -2;
 900         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
 901         EXPECT_TRUE(branches.empty());
 902         EXPECT_EQ(-2, current); // not touched
 903
 904         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
 905         EXPECT_TRUE(branches.empty());
 906         EXPECT_EQ(-2, current); // not touched
 907
 908         STRING_VECTOR tags;
 909         EXPECT_EQ(0, m_Git.GetTagList(tags));
 910         EXPECT_TRUE(tags.empty());
 911
 912         STRING_VECTOR refs;
 913         EXPECT_EQ(0, m_Git.GetRefList(refs));
 914         EXPECT_TRUE(refs.empty());
 915
 916         MAP_HASH_NAME map;
 917         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
 918         EXPECT_TRUE(map.empty());
 919
 920         STRING_VECTOR remotes;
 921         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
 922         EXPECT_TRUE(remotes.empty());
 923 }
 924
 925 static void GetBranchesTagsRefs(CGit& m_Git, config testConfig)
 926 {
 927         STRING_VECTOR branches;
 928         int current = -2;
 929         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
 930         ASSERT_EQ(6U, branches.size());
 931         EXPECT_EQ(1, current);
 932         EXPECT_STREQ(L"forconflict", branches[0]);
 933         EXPECT_STREQ(L"master", branches[1]);
 934         EXPECT_STREQ(L"master2", branches[2]);
 935         EXPECT_STREQ(L"signed-commit", branches[3]);
 936         EXPECT_STREQ(L"simple-conflict", branches[4]);
 937         EXPECT_STREQ(L"subdir/branch", branches[5]);
 938
 939         branches.clear();
 940         current = -2;
 941         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
 942         ASSERT_EQ(7U, branches.size());
 943         EXPECT_EQ(1, current);
 944         EXPECT_STREQ(L"forconflict", branches[0]);
 945         EXPECT_STREQ(L"master", branches[1]);
 946         EXPECT_STREQ(L"master2", branches[2]);
 947         EXPECT_STREQ(L"signed-commit", branches[3]);
 948         EXPECT_STREQ(L"simple-conflict", branches[4]);
 949         EXPECT_STREQ(L"subdir/branch", branches[5]);
 950         EXPECT_STREQ(L"remotes/origin/master", branches[6]);
 951
 952         branches.clear();
 953         current = -2;
 954         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL, true));
 955         ASSERT_EQ(6U, branches.size());
 956         EXPECT_EQ(-2, current); // not touched
 957         EXPECT_STREQ(L"forconflict", branches[0]);
 958         EXPECT_STREQ(L"master2", branches[1]);
 959         EXPECT_STREQ(L"signed-commit", branches[2]);
 960         EXPECT_STREQ(L"simple-conflict", branches[3]);
 961         EXPECT_STREQ(L"subdir/branch", branches[4]);
 962         EXPECT_STREQ(L"remotes/origin/master", branches[5]);
 963
 964         branches.clear();
 965         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL, true));
 966         ASSERT_EQ(6U, branches.size());
 967         EXPECT_STREQ(L"forconflict", branches[0]);
 968         EXPECT_STREQ(L"master2", branches[1]);
 969         EXPECT_STREQ(L"signed-commit", branches[2]);
 970         EXPECT_STREQ(L"simple-conflict", branches[3]);
 971         EXPECT_STREQ(L"subdir/branch", branches[4]);
 972         EXPECT_STREQ(L"remotes/origin/master", branches[5]);
 973
 974         branches.clear();
 975         current = -2;
 976         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_REMOTE));
 977         ASSERT_EQ(1U, branches.size());
 978         EXPECT_EQ(-2, current); // not touched
 979         EXPECT_STREQ(L"remotes/origin/master", branches[0]);
 980
 981         STRING_VECTOR tags;
 982         EXPECT_EQ(0, m_Git.GetTagList(tags));
 983         ASSERT_EQ(3U, tags.size());
 984         EXPECT_STREQ(L"all-files-signed", tags[0]);
 985         EXPECT_STREQ(L"also-signed", tags[1]);
 986         EXPECT_STREQ(L"normal-tag", tags[2]);
 987
 988         STRING_VECTOR refs;
 989         EXPECT_EQ(0, m_Git.GetRefList(refs));
 990         ASSERT_EQ(12U, refs.size());
 991         EXPECT_STREQ(L"refs/heads/forconflict", refs[0]);
 992         EXPECT_STREQ(L"refs/heads/master", refs[1]);
 993         EXPECT_STREQ(L"refs/heads/master2", refs[2]);
 994         EXPECT_STREQ(L"refs/heads/signed-commit", refs[3]);
 995         EXPECT_STREQ(L"refs/heads/simple-conflict", refs[4]);
 996         EXPECT_STREQ(L"refs/heads/subdir/branch", refs[5]);
 997         EXPECT_STREQ(L"refs/notes/commits", refs[6]);
 998         EXPECT_STREQ(L"refs/remotes/origin/master", refs[7]);
 999         EXPECT_STREQ(L"refs/stash", refs[8]);
1000         EXPECT_STREQ(L"refs/tags/all-files-signed", refs[9]);
1001         EXPECT_STREQ(L"refs/tags/also-signed", refs[10]);
1002         EXPECT_STREQ(L"refs/tags/normal-tag", refs[11]);
1003
1004         MAP_HASH_NAME map;
1005         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
1006         if (testConfig == GIT_CLI || testConfig == LIBGIT)
1007                 ASSERT_EQ(13U, map.size()); // also contains the undereferenced tags with hashes
1008         else
1009                 ASSERT_EQ(11U, map.size());
1010
1011         ASSERT_EQ(1U, map[CGitHash::FromHexStr(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6")].size());
1012         EXPECT_STREQ(L"refs/heads/master", map[CGitHash::FromHexStr(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6")][0]);
1013         ASSERT_EQ(1U, map[CGitHash::FromHexStr(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44")].size());
1014         EXPECT_STREQ(L"refs/heads/signed-commit", map[CGitHash::FromHexStr(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44")][0]);
1015         ASSERT_EQ(1U, map[CGitHash::FromHexStr(L"31ff87c86e9f6d3853e438cb151043f30f09029a")].size());
1016         EXPECT_STREQ(L"refs/heads/subdir/branch", map[CGitHash::FromHexStr(L"31ff87c86e9f6d3853e438cb151043f30f09029a")][0]);
1017         ASSERT_EQ(1U, map[CGitHash::FromHexStr(L"5e702e1712aa6f8cd8e0328a87be006f3a923710")].size());
1018         EXPECT_STREQ(L"refs/notes/commits", map[CGitHash::FromHexStr(L"5e702e1712aa6f8cd8e0328a87be006f3a923710")][0]);
1019         ASSERT_EQ(1U, map[CGitHash::FromHexStr(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb")].size());
1020         EXPECT_STREQ(L"refs/stash", map[CGitHash::FromHexStr(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb")][0]);
1021         ASSERT_EQ(1U, map[CGitHash::FromHexStr(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")].size());
1022         EXPECT_STREQ(L"refs/heads/simple-conflict", map[CGitHash::FromHexStr(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")][0]);
1023         ASSERT_EQ(1U, map[CGitHash::FromHexStr(L"10385764a4d42d7428bbeb245015f8f338fc1e40")].size());
1024         EXPECT_STREQ(L"refs/heads/forconflict", map[CGitHash::FromHexStr(L"10385764a4d42d7428bbeb245015f8f338fc1e40")][0]);
1025         ASSERT_EQ(2U, map[CGitHash::FromHexStr(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")].size());
1026         EXPECT_STREQ(L"refs/heads/master2", map[CGitHash::FromHexStr(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")][0]);
1027         EXPECT_STREQ(L"refs/tags/also-signed^{}", map[CGitHash::FromHexStr(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")][1]);
1028         ASSERT_EQ(1U, map[CGitHash::FromHexStr(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb")].size());//
1029         EXPECT_STREQ(L"refs/tags/normal-tag", map[CGitHash::FromHexStr(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb")][0]);
1030         ASSERT_EQ(1U, map[CGitHash::FromHexStr(L"a9d53b535cb49640a6099860ac4999f5a0857b91")].size());
1031         EXPECT_STREQ(L"refs/remotes/origin/master", map[CGitHash::FromHexStr(L"a9d53b535cb49640a6099860ac4999f5a0857b91")][0]);
1032         ASSERT_EQ(1U, map[CGitHash::FromHexStr(L"313a41bc88a527289c87d7531802ab484715974f")].size());
1033         EXPECT_STREQ(L"refs/tags/all-files-signed^{}", map[CGitHash::FromHexStr(L"313a41bc88a527289c87d7531802ab484715974f")][0]);
1034
1035         STRING_VECTOR remotes;
1036         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
1037         ASSERT_EQ(1U, remotes.size());
1038         EXPECT_STREQ(L"origin", remotes[0]);
1039
1040         EXPECT_EQ(-1, m_Git.DeleteRef(L"refs/tags/gibbednet"));
1041         branches.clear();
1042         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1043         EXPECT_EQ(7U, branches.size());
1044         tags.clear();
1045         EXPECT_EQ(0, m_Git.GetTagList(tags));
1046         EXPECT_EQ(3U, tags.size());
1047         refs.clear();
1048         EXPECT_EQ(0, m_Git.GetRefList(refs));
1049         EXPECT_EQ(12U, refs.size());
1050
1051         EXPECT_EQ(-1, m_Git.DeleteRef(L"refs/heads/gibbednet"));
1052         branches.clear();
1053         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1054         EXPECT_EQ(7U, branches.size());
1055         tags.clear();
1056         EXPECT_EQ(0, m_Git.GetTagList(tags));
1057         EXPECT_EQ(3U, tags.size());
1058         refs.clear();
1059         EXPECT_EQ(0, m_Git.GetRefList(refs));
1060         EXPECT_EQ(12U, refs.size());
1061
1062         EXPECT_EQ(-1, m_Git.DeleteRef(L"refs/remotes/origin/gibbednet"));
1063         branches.clear();
1064         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1065         EXPECT_EQ(7U, branches.size());
1066         tags.clear();
1067         EXPECT_EQ(0, m_Git.GetTagList(tags));
1068         EXPECT_EQ(3U, tags.size());
1069         refs.clear();
1070         EXPECT_EQ(0, m_Git.GetRefList(refs));
1071         EXPECT_EQ(12U, refs.size());
1072
1073         EXPECT_EQ(0, m_Git.DeleteRef(L"refs/tags/normal-tag"));
1074         branches.clear();
1075         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1076         EXPECT_EQ(7U, branches.size());
1077         tags.clear();
1078         EXPECT_EQ(0, m_Git.GetTagList(tags));
1079         EXPECT_EQ(2U, tags.size());
1080         refs.clear();
1081         EXPECT_EQ(0, m_Git.GetRefList(refs));
1082         EXPECT_EQ(11U, refs.size());
1083
1084         EXPECT_EQ(0, m_Git.DeleteRef(L"refs/tags/all-files-signed^{}"));
1085         branches.clear();
1086         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1087         EXPECT_EQ(7U, branches.size());
1088         tags.clear();
1089         EXPECT_EQ(0, m_Git.GetTagList(tags));
1090         EXPECT_EQ(1U, tags.size());
1091         refs.clear();
1092         EXPECT_EQ(0, m_Git.GetRefList(refs));
1093         EXPECT_EQ(10U, refs.size());
1094
1095         EXPECT_EQ(0, m_Git.DeleteRef(L"refs/heads/subdir/branch"));
1096         branches.clear();
1097         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1098         EXPECT_EQ(6U, branches.size());
1099         tags.clear();
1100         EXPECT_EQ(0, m_Git.GetTagList(tags));
1101         EXPECT_EQ(1U, tags.size());
1102         refs.clear();
1103         EXPECT_EQ(0, m_Git.GetRefList(refs));
1104         EXPECT_EQ(9U, refs.size());
1105
1106         EXPECT_EQ(0, m_Git.DeleteRef(L"refs/remotes/origin/master"));
1107         branches.clear();
1108         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
1109         EXPECT_EQ(5U, branches.size());
1110         tags.clear();
1111         EXPECT_EQ(0, m_Git.GetTagList(tags));
1112         EXPECT_EQ(1U, tags.size());
1113         refs.clear();
1114         EXPECT_EQ(0, m_Git.GetRefList(refs));
1115         EXPECT_EQ(8U, refs.size());
1116 }
1117
1118 TEST_P(CBasicGitWithTestRepoFixture, GetBranchesTagsRefs)
1119 {
1120         GetBranchesTagsRefs(m_Git, GetParam());
1121 }
1122
1123 TEST_P(CBasicGitWithTestRepoBareFixture, GetBranchesTagsRefs)
1124 {
1125         GetBranchesTagsRefs(m_Git, GetParam());
1126 }
1127
1128 TEST_P(CBasicGitWithTestRepoFixture, GetBranchList_orphan)
1129 {
1130         CString output;
1131         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
1132         EXPECT_STRNE(L"", output);
1133
1134         STRING_VECTOR branches;
1135         int current = -2;
1136         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1137         ASSERT_EQ(6U, branches.size());
1138         EXPECT_EQ(-2, current);
1139         EXPECT_STREQ(L"forconflict", branches[0]);
1140         EXPECT_STREQ(L"master", branches[1]);
1141         EXPECT_STREQ(L"master2", branches[2]);
1142         EXPECT_STREQ(L"signed-commit", branches[3]);
1143         EXPECT_STREQ(L"simple-conflict", branches[4]);
1144         EXPECT_STREQ(L"subdir/branch", branches[5]);
1145 }
1146
1147 TEST_P(CBasicGitWithTestRepoFixture, GetBranchList_utf8)
1148 {
1149         CString output;
1150         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout -b branch_\u570B\u7ACB1d\u043A", &output, CP_UTF8));
1151         EXPECT_STRNE(L"", output);
1152
1153         STRING_VECTOR branches;
1154         int current = -2;
1155         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1156         ASSERT_EQ(7U, branches.size());
1157         EXPECT_EQ(0, current);
1158         EXPECT_STREQ(L"branch_\u570B\u7ACB1d\u043A", branches[0]);
1159         EXPECT_STREQ(L"forconflict", branches[1]);
1160         EXPECT_STREQ(L"master", branches[2]);
1161         EXPECT_STREQ(L"master2", branches[3]);
1162         EXPECT_STREQ(L"signed-commit", branches[4]);
1163         EXPECT_STREQ(L"simple-conflict", branches[5]);
1164         EXPECT_STREQ(L"subdir/branch", branches[6]);
1165 }
1166
1167 TEST_P(CBasicGitWithTestRepoFixture, GetBranchList_detachedhead)
1168 {
1169         CString output;
1170         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout a9d53b535cb49640a6099860ac4999f5a0857b91", &output, CP_UTF8));
1171         EXPECT_STRNE(L"", output);
1172
1173         STRING_VECTOR branches;
1174         int current = -2;
1175         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1176         ASSERT_EQ(6U, branches.size());
1177         EXPECT_EQ(-2, current);
1178         EXPECT_STREQ(L"forconflict", branches[0]);
1179         EXPECT_STREQ(L"master", branches[1]);
1180         EXPECT_STREQ(L"master2", branches[2]);
1181         EXPECT_STREQ(L"signed-commit", branches[3]);
1182         EXPECT_STREQ(L"simple-conflict", branches[4]);
1183         EXPECT_STREQ(L"subdir/branch", branches[5]);
1184
1185         branches.clear();
1186         current = -2;
1187         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_LOCAL, true));
1188         ASSERT_EQ(6U, branches.size());
1189         EXPECT_EQ(-2, current);
1190         EXPECT_STREQ(L"forconflict", branches[0]);
1191         EXPECT_STREQ(L"master", branches[1]);
1192         EXPECT_STREQ(L"master2", branches[2]);
1193         EXPECT_STREQ(L"signed-commit", branches[3]);
1194         EXPECT_STREQ(L"simple-conflict", branches[4]);
1195         EXPECT_STREQ(L"subdir/branch", branches[5]);
1196
1197         // cygwin and msys git fail here
1198         if (CGit::ms_bCygwinGit || CGit::ms_bMsys2Git)
1199                 return;
1200
1201         output.Empty();
1202         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout -b (HEAD a9d53b535cb49640a6099860ac4999f5a0857b91", &output, CP_UTF8));
1203         EXPECT_STRNE(L"", output);
1204
1205         branches.clear();
1206         current = -2;
1207         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1208         ASSERT_EQ(7U, branches.size());
1209         EXPECT_EQ(0, current);
1210         EXPECT_STREQ(L"(HEAD", branches[0]);
1211         EXPECT_STREQ(L"forconflict", branches[1]);
1212         EXPECT_STREQ(L"master", branches[2]);
1213         EXPECT_STREQ(L"master2", branches[3]);
1214         EXPECT_STREQ(L"signed-commit", branches[4]);
1215         EXPECT_STREQ(L"simple-conflict", branches[5]);
1216         EXPECT_STREQ(L"subdir/branch", branches[6]);
1217 }
1218
1219 TEST_P(CBasicGitWithEmptyBareRepositoryFixture, GetEmptyBranchesTagsRefs)
1220 {
1221         EXPECT_STREQ(L"master", m_Git.GetCurrentBranch());
1222
1223         STRING_VECTOR branches;
1224         int current = -2;
1225         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1226         EXPECT_TRUE(branches.empty());
1227         EXPECT_EQ(-2, current); // not touched
1228
1229         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
1230         EXPECT_TRUE(branches.empty());
1231         EXPECT_EQ(-2, current); // not touched
1232
1233         STRING_VECTOR tags;
1234         EXPECT_EQ(0, m_Git.GetTagList(tags));
1235         EXPECT_TRUE(tags.empty());
1236
1237         STRING_VECTOR refs;
1238         EXPECT_EQ(0, m_Git.GetRefList(refs));
1239         EXPECT_TRUE(refs.empty());
1240
1241         MAP_HASH_NAME map;
1242         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
1243         EXPECT_TRUE(map.empty());
1244
1245         STRING_VECTOR remotes;
1246         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
1247         EXPECT_TRUE(remotes.empty());
1248 }
1249
1250 TEST_P(CBasicGitWithEmptyRepositoryFixture, CheckCleanWorkTree)
1251 {
1252         // this test is known to fail with cygwin and also not enabled by default
1253         if (GetParam() == LIBGIT2_ALL && CGit::ms_bCygwinGit)
1254                 return;
1255
1256         CString output;
1257         CString testFile = m_Dir.GetTempDir() + L"\\test.txt";
1258         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing file."));
1259         EXPECT_EQ(0, m_Git.Run(L"git.exe add test.txt", &output, CP_UTF8));
1260         output.Empty();
1261         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Add test.txt\"", &output, CP_UTF8));
1262         // repo with 1 versioned file
1263         EXPECT_STRNE(L"", output);
1264         EXPECT_TRUE(m_Git.CheckCleanWorkTree());
1265         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
1266
1267         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"Overwriting this testing file."));
1268         // repo with 1 modified versioned file
1269         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
1270         EXPECT_FALSE(m_Git.CheckCleanWorkTree(true));
1271
1272         output.Empty();
1273         EXPECT_EQ(0, m_Git.Run(L"git.exe add test.txt", &output, CP_UTF8));
1274         // repo with 1 modified versioned and staged file
1275         EXPECT_STREQ(L"", output);
1276         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
1277         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
1278
1279         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Modified test.txt\"", &output, CP_UTF8));
1280         testFile = m_Dir.GetTempDir() + L"\\test2.txt";
1281         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is ANOTHER testing file."));
1282         EXPECT_TRUE(m_Git.CheckCleanWorkTree());
1283         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
1284
1285         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --orphan orphanic", &output, CP_UTF8));
1286         EXPECT_STRNE(L"", output);
1287         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
1288         EXPECT_FALSE(m_Git.CheckCleanWorkTree(true));
1289 }
1290
1291 TEST(CGit, CEnvironment)
1292 {
1293         CEnvironment env;
1294         const LPWSTR* basePtr = env;
1295         ASSERT_TRUE(basePtr);
1296         EXPECT_FALSE(*basePtr);
1297         EXPECT_TRUE(env.empty());
1298         env.SetEnv(L"not-found", nullptr);
1299         EXPECT_FALSE(static_cast<wchar_t*>(env));
1300         EXPECT_STREQ(L"", env.GetEnv(L"test"));
1301         env.SetEnv(L"key1", L"value1");
1302         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1303         EXPECT_STREQ(L"value1", env.GetEnv(L"kEy1")); // check case insensitivity
1304         EXPECT_TRUE(*basePtr);
1305         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1306         EXPECT_FALSE(env.empty());
1307         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1308         env.SetEnv(L"key1", nullptr); // delete first
1309         EXPECT_FALSE(*basePtr);
1310         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1311         EXPECT_TRUE(env.empty());
1312         env.SetEnv(L"key1", L"value1");
1313         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1314         EXPECT_TRUE(*basePtr);
1315         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1316         EXPECT_FALSE(env.empty());
1317         env.SetEnv(L"key2", L"value2");
1318         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1319         EXPECT_STREQ(L"value2", env.GetEnv(L"key2"));
1320         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1321         env.SetEnv(L"not-found", nullptr);
1322         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1323         EXPECT_STREQ(L"value2", env.GetEnv(L"key2"));
1324         env.SetEnv(L"key2", nullptr); // delete last
1325         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1326         EXPECT_STREQ(L"", env.GetEnv(L"key2"));
1327         env.SetEnv(L"key3", L"value3");
1328         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1329         EXPECT_STREQ(L"value3", env.GetEnv(L"key3"));
1330         env.SetEnv(L"key4", L"value4");
1331         env.SetEnv(L"value3", nullptr); // delete middle
1332         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1333         EXPECT_STREQ(L"value4", env.GetEnv(L"key4"));
1334         env.SetEnv(L"key5", L"value5");
1335         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1336         EXPECT_STREQ(L"value4", env.GetEnv(L"key4"));
1337         EXPECT_STREQ(L"value5", env.GetEnv(L"key5"));
1338         env.SetEnv(L"key4", L"value4a");
1339         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1340         EXPECT_STREQ(L"value4a", env.GetEnv(L"key4"));
1341         EXPECT_STREQ(L"value5", env.GetEnv(L"key5"));
1342         env.SetEnv(L"key5", L"value5a");
1343         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1344         EXPECT_STREQ(L"value4a", env.GetEnv(L"key4"));
1345         EXPECT_STREQ(L"value5a", env.GetEnv(L"key5"));
1346 #pragma warning(push)
1347 #pragma warning(disable: 4996)
1348         CString windir = _wgetenv(L"windir");
1349 #pragma warning(pop)
1350         env.CopyProcessEnvironment();
1351         EXPECT_STREQ(windir, env.GetEnv(L"windir"));
1352         EXPECT_STREQ(L"value1", env.GetEnv(L"key1"));
1353         EXPECT_STREQ(L"value4a", env.GetEnv(L"key4"));
1354         EXPECT_STREQ(L"value5a", env.GetEnv(L"key5"));
1355         env.clear();
1356         EXPECT_FALSE(*basePtr);
1357         EXPECT_TRUE(env.empty());
1358         EXPECT_STREQ(L"", env.GetEnv(L"key4"));
1359         env.CopyProcessEnvironment();
1360         EXPECT_STREQ(windir, env.GetEnv(L"windir"));
1361         EXPECT_TRUE(*basePtr);
1362
1363         // make sure baseptr always points to current values
1364         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1365
1366         env.clear();
1367         CString path = L"c:\\windows;c:\\windows\\system32";
1368         env.SetEnv(L"PATH", path);
1369         env.AddToPath(L"");
1370         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1371         env.AddToPath(L"c:\\windows");
1372         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1373         env.AddToPath(L"c:\\windows\\");
1374         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1375         env.AddToPath(L"c:\\windows\\system32");
1376         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1377         env.AddToPath(L"c:\\windows\\system32\\");
1378         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1379         path += L";c:\\windows\\system";
1380         env.AddToPath(L"c:\\windows\\system");
1381         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1382         path += L";c:\\test";
1383         env.AddToPath(L"c:\\test\\");
1384         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1385         env.AddToPath(L"c:\\test\\");
1386         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1387         env.AddToPath(L"c:\\test");
1388         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1389         path = L"c:\\windows;c:\\windows\\system32;";
1390         env.SetEnv(L"PATH", path);
1391         env.AddToPath(L"");
1392         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1393         env.AddToPath(L"c:\\test");
1394         path += L"c:\\test";
1395         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1396
1397         // also test copy constructor
1398         CEnvironment env2(env);
1399         EXPECT_EQ(static_cast<wchar_t*>(env2), *static_cast<const LPWSTR*>(env2));
1400         EXPECT_NE(static_cast<wchar_t*>(env2), *basePtr);
1401
1402         // also test assignment operation
1403         CEnvironment env3a;
1404         basePtr = env3a;
1405         env3a.SetEnv(L"something", L"else");
1406         CEnvironment env3b;
1407         env3b = env3a;
1408         EXPECT_FALSE(env3b.empty());
1409         EXPECT_EQ(static_cast<const LPWSTR*>(env3a), basePtr);
1410         EXPECT_EQ(static_cast<wchar_t*>(env3a), *basePtr);
1411         EXPECT_NE(static_cast<wchar_t*>(env3b), *basePtr);
1412 }
1413
1414 static void GetOneFile(CGit& m_Git)
1415 {
1416         CString tmpFile = GetTempFile();
1417         ASSERT_STRNE(L"", tmpFile);
1418         EXPECT_EQ(0, m_Git.GetOneFile(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", CTGitPath(L"utf8-nobom.txt"), tmpFile));
1419         CString fileContents;
1420         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1421         struct _stat32 stat_buf = { 0 };
1422         EXPECT_EQ(0, _wstat32(tmpFile, &stat_buf));
1423         EXPECT_EQ(139, stat_buf.st_size);
1424         EXPECT_EQ(108, fileContents.GetLength());
1425         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);
1426         ::DeleteFile(tmpFile);
1427 }
1428
1429 static void GetOneFile_utf8(CGit& m_Git)
1430 {
1431         CString tmpFile = GetTempFile();
1432         ASSERT_STRNE(L"", tmpFile);
1433         EXPECT_EQ(0, m_Git.GetOneFile(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44", CTGitPath(L"newfiles2 - Cöpy.txt"), tmpFile));
1434         CString fileContents;
1435         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1436         struct _stat32 stat_buf {};
1437         EXPECT_EQ(0, _wstat32(tmpFile, &stat_buf));
1438         EXPECT_EQ(14, stat_buf.st_size);
1439         EXPECT_EQ(14, fileContents.GetLength());
1440         EXPECT_STREQ(L"more new stuff", fileContents);
1441         ::DeleteFile(tmpFile);
1442 }
1443
1444 TEST_P(CBasicGitWithTestRepoFixture, GetOneFile)
1445 {
1446         GetOneFile(m_Git);
1447         GetOneFile_utf8(m_Git);
1448
1449         // clean&smudge filters are not available for GetOneFile without libigt2
1450         if (GetParam() == GIT_CLI || GetParam() == LIBGIT)
1451                 return;
1452
1453         CString cleanFilterFilename = m_Git.m_CurrentDir + L"\\clean_filter_openssl";
1454         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(cleanFilterFilename, L"#!/bin/bash\nopenssl version | grep -q \" 1\\\\.0\\\\.\"\nif [[ $? = 0 ]]; then\n\topenssl enc -base64 -aes-256-ecb -S FEEDDEADBEEF -k PASS_FIXED\n\techo 1.0>openssl10\nelse\n\topenssl enc -base64 -pbkdf2 -aes-256-ecb -nosalt -k PASS_FIXED\nfi\n"));
1455         CString smudgeFilterFilename = m_Git.m_CurrentDir + L"\\smudge_filter_openssl";
1456         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(smudgeFilterFilename, L"#!/bin/bash\nopenssl version | grep -q \" 1\\\\.0\\\\.\"\nif [[ $? = 0 ]]; then\n\topenssl enc -d -base64 -aes-256-ecb -k PASS_FIXED\nelse\n\topenssl enc -d -base64 -pbkdf2 -aes-256-ecb -nosalt -k PASS_FIXED\nfi\n"));
1457
1458         CAutoRepository repo(m_Git.GetGitRepository());
1459         ASSERT_TRUE(repo.IsValid());
1460         CAutoConfig config(repo);
1461         ASSERT_TRUE(config.IsValid());
1462         CStringA path = CUnicodeUtils::GetUTF8(m_Git.m_CurrentDir);
1463         path.Replace('\\', '/');
1464         EXPECT_EQ(0, git_config_set_string(config, "filter.openssl.clean", path + "/clean_filter_openssl"));
1465         EXPECT_EQ(0, git_config_set_string(config, "filter.openssl.smudge", path + "/smudge_filter_openssl"));
1466         EXPECT_EQ(0, git_config_set_bool(config, "filter.openssl.required", 1));
1467
1468         CString attributesFile = m_Git.m_CurrentDir + L"\\.gitattributes";
1469         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(attributesFile, L"*.enc filter=openssl\n"));
1470
1471         CString encryptedFileOne = m_Git.m_CurrentDir + L"\\1.enc";
1472         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(encryptedFileOne, L"This should be encrypted...\nAnd decrypted on the fly\n"));
1473
1474         CString encryptedFileTwo = m_Git.m_CurrentDir + L"\\2.enc";
1475         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(encryptedFileTwo, L"This should also be encrypted...\nAnd also decrypted on the fly\n"));
1476
1477         CString output;
1478         EXPECT_EQ(0, m_Git.Run(L"git.exe add 1.enc", &output, CP_UTF8));
1479         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"
1480                 EXPECT_STREQ(L"", output);
1481
1482         CAutoIndex index;
1483         ASSERT_EQ(0, git_repository_index(index.GetPointer(), repo));
1484         EXPECT_EQ(0, git_index_add_bypath(index, "2.enc"));
1485         EXPECT_EQ(0, git_index_write(index));
1486
1487         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Message\"", &output, CP_UTF8));
1488         EXPECT_STRNE(L"", output);
1489
1490         CString fileContents;
1491         CString tmpFile = GetTempFile();
1492         ASSERT_STRNE(L"", tmpFile);
1493         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"1.enc"), tmpFile));
1494         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1495         EXPECT_STREQ(L"This should be encrypted...\nAnd decrypted on the fly\n", fileContents);
1496         ::DeleteFile(tmpFile);
1497
1498         fileContents.Empty();
1499         tmpFile = GetTempFile();
1500         ASSERT_STRNE(L"", tmpFile);
1501         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"2.enc"), tmpFile));
1502         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1503         EXPECT_STREQ(L"This should also be encrypted...\nAnd also decrypted on the fly\n", fileContents);
1504         ::DeleteFile(tmpFile);
1505
1506         EXPECT_TRUE(::DeleteFile(attributesFile));
1507
1508         bool openssl10 = PathFileExists(L"openssl10");
1509
1510         fileContents.Empty();
1511         tmpFile = GetTempFile();
1512         ASSERT_STRNE(L"", tmpFile);
1513         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"1.enc"), tmpFile));
1514         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1515         fileContents.Replace(L"\r\n", L"\n");
1516         if (openssl10)
1517                 EXPECT_STREQ(L"U2FsdGVkX1/+7d6tvu8AABwbE+Xy7U4l5boTKjIgUkYHONqmYHD+0e6k35MgtUGx\ns11nq1QuKeFCW5wFWNSj1WcHg2n4W59xfnB7RkSSIDQ=\n", fileContents);
1518         else
1519                 EXPECT_STREQ(L"JlEiSB71Z3+fM2/Y2lAvxck187c4O1aE7epFJHVoDYJmKNBVvHB2zIPEoTAwW2pJ\nYxWZFBoqGROkX+koseasng==\n", fileContents);
1520         ::DeleteFile(tmpFile);
1521
1522         fileContents.Empty();
1523         tmpFile = GetTempFile();
1524         ASSERT_STRNE(L"", tmpFile);
1525         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"2.enc"), tmpFile));
1526         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1527         fileContents.Replace(L"\r\n", L"\n");
1528         if (openssl10)
1529                 EXPECT_STREQ(L"U2FsdGVkX1/+7d6tvu8AAIDDx8qi/l0qzkSMsS2YLt8tYK1oWzj8+o78fXH0/tlO\nCRVrKqTvh9eUFklY8QFYfZfj01zBkFat+4zrW+1rV4Q=\n", fileContents);
1530         else
1531                 EXPECT_STREQ(L"iU6jZ5d/5XBR9BvT1s+oqF7vIxabgYETQftI27P6jWQky308ukprRuOVZNr3NSH6\nlgXwDTo+mez3JB31HVSMCA==\n", fileContents);
1532         ::DeleteFile(tmpFile);
1533 }
1534
1535 TEST_P(CBasicGitWithTestRepoBareFixture, GetOneFile)
1536 {
1537         GetOneFile(m_Git);
1538 }
1539
1540 static void GetBranchDescriptions(CGit& m_Git)
1541 {
1542         MAP_STRING_STRING descriptions;
1543         EXPECT_EQ(0, m_Git.GetBranchDescriptions(descriptions));
1544         EXPECT_EQ(0U, descriptions.size());
1545
1546         g_Git.SetConfigValue(L"branch.master.description", L"test");
1547         g_Git.SetConfigValue(L"branch.subdir/branch.description", L"multi\nline");
1548
1549         EXPECT_EQ(0, m_Git.GetBranchDescriptions(descriptions));
1550         ASSERT_EQ(2U, descriptions.size());
1551         EXPECT_STREQ(L"test", descriptions[L"master"]);
1552         EXPECT_STREQ(L"multi\nline", descriptions[L"subdir/branch"]);
1553 }
1554
1555 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetBranchDescriptions)
1556 {
1557         GetBranchDescriptions(m_Git);
1558 }
1559
1560 TEST_P(CBasicGitWithEmptyBareRepositoryFixture, GetBranchDescriptions)
1561 {
1562         GetBranchDescriptions(m_Git);
1563 }
1564
1565 TEST_P(CBasicGitWithTestRepoFixture, Config)
1566 {
1567         EXPECT_STREQ(L"", m_Git.GetConfigValue(L"not-found"));
1568         EXPECT_STREQ(L"default", m_Git.GetConfigValue(L"not-found", L"default"));
1569
1570         EXPECT_STREQ(L"false", m_Git.GetConfigValue(L"core.bare"));
1571         EXPECT_STREQ(L"false", m_Git.GetConfigValue(L"core.bare", L"default-value")); // value exist, so default does not match
1572         EXPECT_STREQ(L"true", m_Git.GetConfigValue(L"core.ignorecase"));
1573         EXPECT_STREQ(L"0", m_Git.GetConfigValue(L"core.repositoryformatversion"));
1574         EXPECT_STREQ(L"https://example.com/git/testing", m_Git.GetConfigValue(L"remote.origin.url"));
1575
1576         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"not-found"));
1577         EXPECT_EQ(true, m_Git.GetConfigValueBool(L"not-found", true));
1578         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"core.bare"));
1579         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"core.bare", true)); // value exist, so default does not match
1580         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"core.repositoryformatversion"));
1581         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"remote.origin.url"));
1582         EXPECT_EQ(true, m_Git.GetConfigValueBool(L"core.ignorecase"));
1583
1584         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", L"with ümlaut"};
1585         for (int i = 0; i < _countof(values); ++i)
1586         {
1587                 CString key;
1588                 key.Format(L"re-read.test%d", i);
1589                 EXPECT_EQ(0, m_Git.SetConfigValue(key, values[i]));
1590                 EXPECT_STREQ(values[i], m_Git.GetConfigValue(key));
1591         }
1592
1593         m_Git.SetConfigValue(L"booltest.true1", L"1");
1594         m_Git.SetConfigValue(L"booltest.true2", L"100");
1595         m_Git.SetConfigValue(L"booltest.true3", L"-2");
1596         m_Git.SetConfigValue(L"booltest.true4", L"yes");
1597         m_Git.SetConfigValue(L"booltest.true5", L"yEs");
1598         m_Git.SetConfigValue(L"booltest.true6", L"true");
1599         m_Git.SetConfigValue(L"booltest.true7", L"on");
1600         for (int i = 1; i <= 7; ++i)
1601         {
1602                 CString key;
1603                 key.Format(L"booltest.true%d", i);
1604                 EXPECT_EQ(true, m_Git.GetConfigValueBool(key));
1605         }
1606         m_Git.SetConfigValue(L"booltest.false1", L"0");
1607         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"booltest.false1"));
1608         m_Git.SetConfigValue(L"booltest.false2", L"");
1609         EXPECT_EQ(false, m_Git.GetConfigValueBool(L"booltest.false2"));
1610
1611         EXPECT_EQ(0, m_Git.GetConfigValueInt32(L"does-not-exist"));
1612         EXPECT_EQ(15, m_Git.GetConfigValueInt32(L"does-not-exist", 15));
1613         EXPECT_EQ(0, m_Git.GetConfigValueInt32(L"core.repositoryformatversion"));
1614         EXPECT_EQ(0, m_Git.GetConfigValueInt32(L"core.repositoryformatversion", 42)); // value exist, so default should not be returned
1615         EXPECT_EQ(1, m_Git.GetConfigValueInt32(L"booltest.true1"));
1616         EXPECT_EQ(100, m_Git.GetConfigValueInt32(L"booltest.true2"));
1617         EXPECT_EQ(-2, m_Git.GetConfigValueInt32(L"booltest.true3"));
1618         EXPECT_EQ(0, m_Git.GetConfigValueInt32(L"booltest.true4"));
1619         EXPECT_EQ(42, m_Git.GetConfigValueInt32(L"booltest.true4", 42));
1620         EXPECT_EQ(0, m_Git.GetConfigValueInt32(L"booltest.true8"));
1621         EXPECT_EQ(42, m_Git.GetConfigValueInt32(L"booltest.true8", 42));
1622
1623         EXPECT_NE(0, m_Git.UnsetConfigValue(L"does-not-exist"));
1624         EXPECT_STREQ(L"false", m_Git.GetConfigValue(L"core.bare"));
1625         EXPECT_STREQ(L"true", m_Git.GetConfigValue(L"core.ignorecase"));
1626         EXPECT_EQ(0, m_Git.UnsetConfigValue(L"core.bare"));
1627         EXPECT_STREQ(L"default", m_Git.GetConfigValue(L"core.bare", L"default"));
1628         EXPECT_STREQ(L"true", m_Git.GetConfigValue(L"core.ignorecase"));
1629
1630         CString gitConfig = m_Git.m_CurrentDir + L"\\.git\\config";
1631         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(gitConfig, L"[booltest]\nistrue"));
1632         EXPECT_EQ(true, m_Git.GetConfigValueBool(L"booltest.istrue"));
1633
1634         // test includes from %HOME% specified as ~/
1635         EXPECT_STREQ(L"not-found", g_Git.GetConfigValue(L"test.fromincluded", L"not-found"));
1636         EXPECT_EQ(0, m_Git.SetConfigValue(L"include.path", L"~/a-path-that-should-not-exist.gconfig"));
1637         EXPECT_STREQ(L"~/a-path-that-should-not-exist.gconfig", g_Git.GetConfigValue(L"include.path", L"not-found"));
1638         CString testFile = g_Git.GetHomeDirectory() + L"\\a-path-that-should-not-exist.gconfig";
1639         ASSERT_FALSE(PathFileExists(testFile)); // make sure we don't override a file by mistake ;)
1640         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"[test]\nfromincluded=yeah-this-is-included\n"));
1641         EXPECT_STREQ(L"yeah-this-is-included", g_Git.GetConfigValue(L"test.fromincluded", L"not-found"));
1642         EXPECT_TRUE(::DeleteFile(testFile));
1643 }
1644
1645 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges)
1646 {
1647         if (GetParam() != 0)
1648                 return;
1649
1650         // adding ansi2.txt (as a copy of ansi.txt) produces a warning
1651         m_Git.SetConfigValue(L"core.autocrlf", L"false");
1652
1653         CString output;
1654         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1655         EXPECT_STRNE(L"", output);
1656
1657         CTGitPathList filter(CTGitPath(L"copy"));
1658
1659         // no changes
1660         CTGitPathList list;
1661         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1662         EXPECT_TRUE(list.IsEmpty());
1663         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
1664         EXPECT_TRUE(list.IsEmpty());
1665         list.Clear();
1666         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1667         ASSERT_EQ(1, list.GetCount());
1668         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1669         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1670         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1671         EXPECT_FALSE(list[0].IsDirectory());
1672         list.Clear();
1673         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1674         EXPECT_TRUE(list.IsEmpty());
1675         list.Clear();
1676         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1677         ASSERT_EQ(0, list.GetCount());
1678         list.Clear();
1679         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
1680         ASSERT_EQ(0, list.GetCount());
1681         list.Clear();
1682         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1683         ASSERT_EQ(1, list.GetCount());
1684         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1685         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1686         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
1687         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1688         EXPECT_STREQ(L"2", list[0].m_StatAdd);
1689         EXPECT_STREQ(L"2", list[0].m_StatDel);
1690         EXPECT_FALSE(list[0].IsDirectory());
1691         list.Clear();
1692         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
1693         ASSERT_EQ(1, list.GetCount());
1694         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1695         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1696         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
1697         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1698         EXPECT_STREQ(L"2", list[0].m_StatAdd);
1699         EXPECT_STREQ(L"2", list[0].m_StatDel);
1700         EXPECT_FALSE(list[0].IsDirectory());
1701         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
1702
1703         // untracked file
1704         CString testFile = m_Git.m_CurrentDir + L"\\untracked-file.txt";
1705         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1706         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1707         EXPECT_TRUE(list.IsEmpty());
1708         list.Clear();
1709         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
1710         EXPECT_TRUE(list.IsEmpty());
1711         list.Clear();
1712         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1713         ASSERT_EQ(1, list.GetCount());
1714         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1715         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1716         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
1717         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1718         EXPECT_STREQ(L"2", list[0].m_StatAdd);
1719         EXPECT_STREQ(L"2", list[0].m_StatDel);
1720         EXPECT_FALSE(list[0].IsDirectory());
1721         list.Clear();
1722         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1723         EXPECT_TRUE(list.IsEmpty());
1724         list.Clear();
1725         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1726         ASSERT_EQ(0, list.GetCount());
1727         list.Clear();
1728         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
1729         ASSERT_EQ(0, list.GetCount());
1730         list.Clear();
1731         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1732         ASSERT_EQ(1, list.GetCount());
1733         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1734         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1735         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1736         EXPECT_STREQ(L"2", list[0].m_StatAdd);
1737         EXPECT_STREQ(L"2", list[0].m_StatDel);
1738         EXPECT_FALSE(list[0].IsDirectory());
1739         list.Clear();
1740         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
1741         ASSERT_EQ(1, list.GetCount());
1742         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1743         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1744         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1745         EXPECT_STREQ(L"2", list[0].m_StatAdd);
1746         EXPECT_STREQ(L"2", list[0].m_StatDel);
1747         EXPECT_FALSE(list[0].IsDirectory());
1748         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
1749
1750         // untracked file in sub-directory
1751         testFile = m_Git.m_CurrentDir + L"\\copy\\untracked-file.txt";
1752         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1753         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1754         EXPECT_TRUE(list.IsEmpty());
1755         list.Clear();
1756         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
1757         EXPECT_TRUE(list.IsEmpty());
1758         list.Clear();
1759         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1760         ASSERT_EQ(1, list.GetCount());
1761         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1762         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1763         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
1764         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1765         EXPECT_FALSE(list[0].IsDirectory());
1766         list.Clear();
1767         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1768         EXPECT_TRUE(list.IsEmpty());
1769         list.Clear();
1770         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1771         EXPECT_TRUE(list.IsEmpty());
1772         list.Clear();
1773         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
1774         EXPECT_TRUE(list.IsEmpty());
1775         list.Clear();
1776         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1777         ASSERT_EQ(1, list.GetCount());
1778         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1779         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1780         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1781         EXPECT_FALSE(list[0].IsDirectory());
1782         list.Clear();
1783         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
1784         ASSERT_EQ(1, list.GetCount());
1785         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1786         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1787         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1788         EXPECT_FALSE(list[0].IsDirectory());
1789         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
1790
1791         // modified file in sub-directory
1792         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
1793         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1794         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1795         ASSERT_EQ(1, list.GetCount());
1796         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1797         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1798         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
1799         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1800         EXPECT_STREQ(L"1", list[0].m_StatAdd);
1801         EXPECT_STREQ(L"9", list[0].m_StatDel);
1802         EXPECT_FALSE(list[0].IsDirectory());
1803         list.Clear();
1804         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
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         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
1811         list.Clear();
1812         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1813         ASSERT_EQ(2, list.GetCount());
1814         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1815         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1816         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1817         EXPECT_FALSE(list[0].IsDirectory());
1818         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1819         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1820         EXPECT_FALSE(list[1].IsDirectory());
1821         list.Clear();
1822         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1823         ASSERT_EQ(1, list.GetCount());
1824         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1825         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1826         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1827         EXPECT_FALSE(list[0].IsDirectory());
1828         list.Clear();
1829         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1830         ASSERT_EQ(1, list.GetCount());
1831         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1832         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1833         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1834         EXPECT_FALSE(list[0].IsDirectory());
1835         list.Clear();
1836         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
1837         ASSERT_EQ(1, list.GetCount());
1838         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1839         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1840         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1841         EXPECT_FALSE(list[0].IsDirectory());
1842         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
1843         list.Clear();
1844         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1845         ASSERT_EQ(2, list.GetCount());
1846         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1847         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1848         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1849         EXPECT_FALSE(list[0].IsDirectory());
1850         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1851         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1852         EXPECT_FALSE(list[1].IsDirectory());
1853         list.Clear();
1854         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
1855         ASSERT_EQ(2, list.GetCount());
1856         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1857         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1858         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1859         EXPECT_FALSE(list[0].IsDirectory());
1860         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
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         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[1].m_stagingStatus);
1865
1866         // two modified files, one in root and one in sub-directory
1867         output.Empty();
1868         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1869         EXPECT_STRNE(L"", output);
1870         testFile = m_Git.m_CurrentDir + L"\\utf8-bom.txt";
1871         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1872         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
1873         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1874         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1875         ASSERT_EQ(2, list.GetCount());
1876         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1877         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1878         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
1879         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1880         EXPECT_STREQ(L"1", list[0].m_StatAdd);
1881         EXPECT_STREQ(L"9", list[0].m_StatDel);
1882         EXPECT_FALSE(list[0].IsDirectory());
1883         EXPECT_STREQ(L"utf8-bom.txt", list[1].GetGitPathString());
1884         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1885         EXPECT_STREQ(L"1", list[1].m_StatAdd);
1886         EXPECT_STREQ(L"9", list[1].m_StatDel);
1887         EXPECT_FALSE(list[1].IsDirectory());
1888         list.Clear();
1889         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
1890         ASSERT_EQ(2, list.GetCount());
1891         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1892         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1893         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1894         EXPECT_FALSE(list[0].IsDirectory());
1895         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
1896         EXPECT_STREQ(L"utf8-bom.txt", list[1].GetGitPathString());
1897         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1898         EXPECT_FALSE(list[1].IsDirectory());
1899         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[1].m_stagingStatus);
1900         list.Clear();
1901         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1902         ASSERT_EQ(3, list.GetCount());
1903         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1904         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1905         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1906         EXPECT_FALSE(list[0].IsDirectory());
1907         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1908         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1909         EXPECT_FALSE(list[1].IsDirectory());
1910         EXPECT_STREQ(L"utf8-bom.txt", list[2].GetGitPathString());
1911         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
1912         EXPECT_FALSE(list[2].IsDirectory());
1913         list.Clear();
1914         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1915         ASSERT_EQ(1, list.GetCount());
1916         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1917         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1918         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1919         EXPECT_FALSE(list[0].IsDirectory());
1920         list.Clear();
1921         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
1922         ASSERT_EQ(1, list.GetCount());
1923         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1924         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1925         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1926         EXPECT_FALSE(list[0].IsDirectory());
1927         list.Clear();
1928         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
1929         ASSERT_EQ(1, list.GetCount());
1930         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1931         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
1932         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1933         EXPECT_FALSE(list[0].IsDirectory());
1934         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
1935         list.Clear();
1936         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
1937         ASSERT_EQ(2, list.GetCount());
1938         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1939         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1940         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1941         EXPECT_FALSE(list[0].IsDirectory());
1942         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1943         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1944         EXPECT_FALSE(list[1].IsDirectory());
1945         list.Clear();
1946         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
1947         ASSERT_EQ(2, list.GetCount());
1948         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1949         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1950         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1951         EXPECT_STREQ(L"2", list[0].m_StatAdd);
1952         EXPECT_STREQ(L"2", list[0].m_StatDel);
1953         EXPECT_FALSE(list[0].IsDirectory());
1954         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
1955         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
1956         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1957         EXPECT_FALSE(list[1].IsDirectory());
1958         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[1].m_stagingStatus);
1959
1960         // Staged modified file
1961         output.Empty();
1962         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
1963         EXPECT_STRNE(L"", output);
1964         testFile = m_Git.m_CurrentDir + L"\\utf8-nobom.txt";
1965         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
1966         output.Empty();
1967         EXPECT_EQ(0, m_Git.Run(L"git.exe add utf8-nobom.txt", &output, CP_UTF8));
1968         EXPECT_STREQ(L"", output);
1969         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1970         ASSERT_EQ(1, list.GetCount());
1971         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1972         EXPECT_STREQ(L"utf8-nobom.txt", list[0].GetGitPathString());
1973         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
1974         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1975         EXPECT_STREQ(L"1", list[0].m_StatAdd);
1976         EXPECT_STREQ(L"9", list[0].m_StatDel);
1977         EXPECT_FALSE(list[0].IsDirectory());
1978         list.Clear();
1979         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
1980         ASSERT_EQ(1, list.GetCount());
1981         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1982         EXPECT_STREQ(L"utf8-nobom.txt", list[0].GetGitPathString());
1983         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1984         EXPECT_STREQ(L"1", list[0].m_StatAdd);
1985         EXPECT_STREQ(L"9", list[0].m_StatDel);
1986         EXPECT_FALSE(list[0].IsDirectory());
1987         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
1988         list.Clear();
1989         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1990         ASSERT_EQ(2, list.GetCount());
1991         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1992         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
1993         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1994         EXPECT_STREQ(L"2", list[0].m_StatAdd);
1995         EXPECT_STREQ(L"2", list[0].m_StatDel);
1996         EXPECT_FALSE(list[0].IsDirectory());
1997         EXPECT_STREQ(L"utf8-nobom.txt", list[1].GetGitPathString());
1998         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1999         EXPECT_STREQ(L"1", list[1].m_StatAdd);
2000         EXPECT_STREQ(L"9", list[1].m_StatDel);
2001         EXPECT_FALSE(list[1].IsDirectory());
2002         list.Clear();
2003         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2004         ASSERT_EQ(0, list.GetCount());
2005         list.Clear();
2006         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
2007         ASSERT_EQ(0, list.GetCount());
2008         list.Clear();
2009         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2010         ASSERT_EQ(1, list.GetCount());
2011         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2012         EXPECT_STREQ(L"utf8-nobom.txt", list[0].GetGitPathString());
2013         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2014         EXPECT_STREQ(L"1", list[0].m_StatAdd);
2015         EXPECT_STREQ(L"9", list[0].m_StatDel);
2016         EXPECT_FALSE(list[0].IsDirectory());
2017         list.Clear();
2018         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
2019         ASSERT_EQ(1, list.GetCount());
2020         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2021         EXPECT_STREQ(L"utf8-nobom.txt", list[0].GetGitPathString());
2022         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2023         EXPECT_STREQ(L"1", list[0].m_StatAdd);
2024         EXPECT_STREQ(L"9", list[0].m_StatDel);
2025         EXPECT_FALSE(list[0].IsDirectory());
2026         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2027         list.Clear();
2028         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2029         ASSERT_EQ(0, list.GetCount());
2030         list.Clear();
2031         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2032         ASSERT_EQ(0, list.GetCount());
2033         list.Clear();
2034         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2035         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2036         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2037         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2038         EXPECT_STREQ(L"2", list[0].m_StatAdd);
2039         EXPECT_STREQ(L"2", list[0].m_StatDel);
2040         EXPECT_FALSE(list[0].IsDirectory());
2041         EXPECT_STREQ(L"utf8-nobom.txt", list[1].GetGitPathString());
2042         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2043         EXPECT_STREQ(L"1", list[1].m_StatAdd);
2044         EXPECT_STREQ(L"9", list[1].m_StatDel);
2045         EXPECT_FALSE(list[1].IsDirectory());
2046         list.Clear();
2047         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2048         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2049         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2050         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2051         EXPECT_STREQ(L"2", list[0].m_StatAdd);
2052         EXPECT_STREQ(L"2", list[0].m_StatDel);
2053         EXPECT_FALSE(list[0].IsDirectory());
2054         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2055         EXPECT_STREQ(L"utf8-nobom.txt", list[1].GetGitPathString());
2056         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2057         EXPECT_STREQ(L"1", list[1].m_StatAdd);
2058         EXPECT_STREQ(L"9", list[1].m_StatDel);
2059         EXPECT_FALSE(list[1].IsDirectory());
2060         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2061
2062         // Staged modified file in subfolder
2063         output.Empty();
2064         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2065         EXPECT_STRNE(L"", output);
2066         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
2067         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
2068         output.Empty();
2069         EXPECT_EQ(0, m_Git.Run(L"git.exe add copy/utf8-nobom.txt", &output, CP_UTF8));
2070         EXPECT_STREQ(L"", output);
2071         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2072         ASSERT_EQ(1, list.GetCount());
2073         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2074         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
2075         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
2076         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2077         EXPECT_FALSE(list[0].IsDirectory());
2078         list.Clear();
2079         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
2080         ASSERT_EQ(1, list.GetCount());
2081         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2082         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
2083         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2084         EXPECT_FALSE(list[0].IsDirectory());
2085         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2086         list.Clear();
2087         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2088         ASSERT_EQ(2, list.GetCount());
2089         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2090         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2091         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2092         EXPECT_FALSE(list[0].IsDirectory());
2093         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
2094         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2095         EXPECT_FALSE(list[1].IsDirectory());
2096         list.Clear();
2097         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2098         ASSERT_EQ(1, list.GetCount());
2099         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2100         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
2101         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2102         EXPECT_FALSE(list[0].IsDirectory());
2103         list.Clear();
2104         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2105         ASSERT_EQ(1, list.GetCount());
2106         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2107         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
2108         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2109         EXPECT_FALSE(list[0].IsDirectory());
2110         list.Clear();
2111         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2112         ASSERT_EQ(1, list.GetCount());
2113         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2114         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
2115         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2116         EXPECT_FALSE(list[0].IsDirectory());
2117         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2118         list.Clear();
2119         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2120         ASSERT_EQ(2, list.GetCount());
2121         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2122         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2123         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2124         EXPECT_FALSE(list[0].IsDirectory());
2125         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
2126         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2127         EXPECT_FALSE(list[1].IsDirectory());
2128         list.Clear();
2129         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2130         ASSERT_EQ(2, list.GetCount());
2131         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2132         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2133         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2134         EXPECT_FALSE(list[0].IsDirectory());
2135         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2136         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
2137         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2138         EXPECT_FALSE(list[1].IsDirectory());
2139         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2140
2141         // Modified file modified after staging
2142         output.Empty();
2143         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2144         EXPECT_STRNE(L"", output);
2145         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
2146         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
2147         output.Empty();
2148         EXPECT_EQ(0, m_Git.Run(L"git.exe add copy/utf8-nobom.txt", &output, CP_UTF8));
2149         EXPECT_STREQ(L"", output);
2150         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"now with different content after staging"));
2151         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2152         ASSERT_EQ(1, list.GetCount());
2153         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2154         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
2155         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
2156         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2157         EXPECT_STREQ(L"1", list[0].m_StatAdd);
2158         EXPECT_STREQ(L"9", list[0].m_StatDel);
2159         EXPECT_FALSE(list[0].IsDirectory());
2160         list.Clear();
2161         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
2162         ASSERT_EQ(1, list.GetCount());
2163         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2164         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
2165         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2166         EXPECT_STREQ(L"1", list[0].m_StatAdd);
2167         EXPECT_STREQ(L"9", list[0].m_StatDel);
2168         EXPECT_FALSE(list[0].IsDirectory());
2169         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[0].m_stagingStatus);
2170         list.Clear();
2171         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2172         ASSERT_EQ(2, list.GetCount());
2173         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2174         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2175         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2176         EXPECT_STREQ(L"2", list[0].m_StatAdd);
2177         EXPECT_STREQ(L"2", list[0].m_StatDel);
2178         EXPECT_FALSE(list[0].IsDirectory());
2179         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
2180         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2181         EXPECT_STREQ(L"1", list[1].m_StatAdd);
2182         EXPECT_STREQ(L"9", list[1].m_StatDel);
2183         EXPECT_FALSE(list[1].IsDirectory());
2184         list.Clear();
2185         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2186         ASSERT_EQ(1, list.GetCount());
2187         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2188         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
2189         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2190         EXPECT_STREQ(L"1", list[0].m_StatAdd);
2191         EXPECT_STREQ(L"9", list[0].m_StatDel);
2192         EXPECT_FALSE(list[0].IsDirectory());
2193         list.Clear();
2194         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2195         ASSERT_EQ(1, list.GetCount());
2196         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2197         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
2198         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2199         EXPECT_STREQ(L"1", list[0].m_StatAdd);
2200         EXPECT_STREQ(L"9", list[0].m_StatDel);
2201         EXPECT_FALSE(list[0].IsDirectory());
2202         list.Clear();
2203         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2204         ASSERT_EQ(1, list.GetCount());
2205         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2206         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[0].GetGitPathString());
2207         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2208         EXPECT_STREQ(L"1", list[0].m_StatAdd);
2209         EXPECT_STREQ(L"9", list[0].m_StatDel);
2210         EXPECT_FALSE(list[0].IsDirectory());
2211         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[0].m_stagingStatus);
2212         list.Clear();
2213         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2214         ASSERT_EQ(2, list.GetCount());
2215         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2216         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2217         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2218         EXPECT_STREQ(L"2", list[0].m_StatAdd);
2219         EXPECT_STREQ(L"2", list[0].m_StatDel);
2220         EXPECT_FALSE(list[0].IsDirectory());
2221         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
2222         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2223         EXPECT_STREQ(L"1", list[1].m_StatAdd);
2224         EXPECT_STREQ(L"9", list[1].m_StatDel);
2225         EXPECT_FALSE(list[1].IsDirectory());
2226         list.Clear();
2227         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2228         ASSERT_EQ(2, list.GetCount());
2229         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2230         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2231         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2232         EXPECT_STREQ(L"2", list[0].m_StatAdd);
2233         EXPECT_STREQ(L"2", list[0].m_StatDel);
2234         EXPECT_FALSE(list[0].IsDirectory());
2235         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2236         EXPECT_STREQ(L"copy/utf8-nobom.txt", list[1].GetGitPathString());
2237         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2238         EXPECT_STREQ(L"1", list[1].m_StatAdd);
2239         EXPECT_STREQ(L"9", list[1].m_StatDel);
2240         EXPECT_FALSE(list[1].IsDirectory());
2241         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[1].m_stagingStatus);
2242
2243         // Missing file
2244         output.Empty();
2245         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2246         EXPECT_STRNE(L"", output);
2247         EXPECT_TRUE(::DeleteFile(m_Dir.GetTempDir()+L"\\copy\\ansi.txt"));
2248         list.Clear();
2249         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2250         ASSERT_EQ(1, list.GetCount());
2251         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list.GetAction());
2252         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2253         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
2254         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
2255         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2256         EXPECT_STREQ(L"9", list[0].m_StatDel);
2257         list.Clear();
2258         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
2259         ASSERT_EQ(1, list.GetCount());
2260         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list.GetAction());
2261         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2262         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
2263         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2264         EXPECT_STREQ(L"9", list[0].m_StatDel);
2265         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
2266         list.Clear();
2267         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2268         ASSERT_EQ(2, list.GetCount());
2269         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list.GetAction());
2270         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2271         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2272         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2273         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[1].m_Action);
2274         list.Clear();
2275         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2276         ASSERT_EQ(1, list.GetCount());
2277         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list.GetAction());
2278         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2279         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
2280         list.Clear();
2281         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2282         ASSERT_EQ(1, list.GetCount());
2283         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list.GetAction());
2284         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2285         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
2286         list.Clear();
2287         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2288         ASSERT_EQ(1, list.GetCount());
2289         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list.GetAction());
2290         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2291         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
2292         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
2293         list.Clear();
2294         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2295         ASSERT_EQ(2, list.GetCount());
2296         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list.GetAction());
2297         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2298         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2299         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2300         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[1].m_Action);
2301         list.Clear();
2302         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2303         ASSERT_EQ(2, list.GetCount());
2304         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list.GetAction());
2305         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2306         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2307         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2308         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2309         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[1].m_Action);
2310         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[1].m_stagingStatus);
2311
2312         // deleted file, also deleted in index
2313         output.Empty();
2314         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2315         EXPECT_STRNE(L"", output);
2316         output.Empty();
2317         EXPECT_EQ(0, m_Git.Run(L"git.exe rm copy/ansi.txt", &output, CP_UTF8));
2318         EXPECT_STRNE(L"", output);
2319         list.Clear();
2320         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2321         ASSERT_EQ(1, list.GetCount());
2322         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2323         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2324         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
2325         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2326         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2327         EXPECT_STREQ(L"9", list[0].m_StatDel);
2328         list.Clear();
2329         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
2330         ASSERT_EQ(1, list.GetCount());
2331         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2332         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2333         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2334         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2335         EXPECT_STREQ(L"9", list[0].m_StatDel);
2336         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2337         list.Clear();
2338         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2339         ASSERT_EQ(2, list.GetCount());
2340         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2341         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2342         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2343         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2344         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2345         list.Clear();
2346         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2347         ASSERT_EQ(1, list.GetCount());
2348         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2349         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2350         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2351         list.Clear();
2352         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2353         ASSERT_EQ(1, list.GetCount());
2354         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2355         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2356         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2357         list.Clear();
2358         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2359         ASSERT_EQ(1, list.GetCount());
2360         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2361         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2362         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2363         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2364         list.Clear();
2365         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2366         ASSERT_EQ(2, list.GetCount());
2367         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2368         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2369         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2370         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2371         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2372         list.Clear();
2373         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2374         ASSERT_EQ(2, list.GetCount());
2375         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2376         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2377         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2378         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2379         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2380         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2381         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2382
2383         // file deleted in index, but still on disk
2384         output.Empty();
2385         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2386         EXPECT_STRNE(L"", output);
2387         output.Empty();
2388         EXPECT_EQ(0, m_Git.Run(L"git.exe rm --cached copy/ansi.txt", &output, CP_UTF8));
2389         EXPECT_STRNE(L"", output);
2390         list.Clear();
2391         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2392         ASSERT_EQ(1, list.GetCount());
2393         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2394         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2395         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
2396         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2397         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2398         EXPECT_STREQ(L"9", list[0].m_StatDel);
2399         EXPECT_FALSE(list[0].IsDirectory());
2400         list.Clear();
2401         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
2402         ASSERT_EQ(1, list.GetCount());
2403         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2404         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2405         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2406         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2407         EXPECT_STREQ(L"9", list[0].m_StatDel);
2408         EXPECT_FALSE(list[0].IsDirectory());
2409         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2410         list.Clear();
2411         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2412         ASSERT_EQ(2, list.GetCount());
2413         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2414         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2415         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2416         EXPECT_STREQ(L"2", list[0].m_StatAdd);
2417         EXPECT_STREQ(L"2", list[0].m_StatDel);
2418         EXPECT_FALSE(list[0].IsDirectory());
2419         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2420         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2421         EXPECT_STREQ(L"0", list[1].m_StatAdd);
2422         EXPECT_STREQ(L"9", list[1].m_StatDel);
2423         EXPECT_FALSE(list[1].IsDirectory());
2424         list.Clear();
2425         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2426         ASSERT_EQ(1, list.GetCount());
2427         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2428         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2429         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2430         EXPECT_FALSE(list[0].IsDirectory());
2431         list.Clear();
2432         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2433         ASSERT_EQ(1, list.GetCount());
2434         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2435         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2436         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2437         EXPECT_FALSE(list[0].IsDirectory());
2438         list.Clear();
2439         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2440         ASSERT_EQ(1, list.GetCount());
2441         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2442         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2443         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2444         EXPECT_FALSE(list[0].IsDirectory());
2445         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2446         list.Clear();
2447         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2448         ASSERT_EQ(2, list.GetCount());
2449         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2450         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2451         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2452         EXPECT_FALSE(list[0].IsDirectory());
2453         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2454         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2455         EXPECT_FALSE(list[1].IsDirectory());
2456         list.Clear();
2457         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2458         ASSERT_EQ(2, list.GetCount());
2459         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2460         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2461         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2462         EXPECT_FALSE(list[0].IsDirectory());
2463         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2464         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2465         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2466         EXPECT_FALSE(list[1].IsDirectory());
2467         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2468
2469         // file deleted in index, but still on disk, but modified
2470         output.Empty();
2471         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2472         EXPECT_STRNE(L"", output);
2473         output.Empty();
2474         EXPECT_EQ(0, m_Git.Run(L"git.exe rm --cached copy/ansi.txt", &output, CP_UTF8));
2475         EXPECT_STRNE(L"", output);
2476         testFile = m_Git.m_CurrentDir + L"\\copy\\ansi.txt";
2477         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
2478         list.Clear();
2479         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2480         ASSERT_EQ(1, list.GetCount());
2481         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2482         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2483         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
2484         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2485         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2486         EXPECT_STREQ(L"9", list[0].m_StatDel);
2487         EXPECT_FALSE(list[0].IsDirectory());
2488         list.Clear();
2489         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
2490         ASSERT_EQ(1, list.GetCount());
2491         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2492         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2493         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2494         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2495         EXPECT_STREQ(L"9", list[0].m_StatDel);
2496         EXPECT_FALSE(list[0].IsDirectory());
2497         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2498         list.Clear();
2499         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2500         ASSERT_EQ(2, list.GetCount());
2501         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2502         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2503         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2504         EXPECT_STREQ(L"2", list[0].m_StatAdd);
2505         EXPECT_STREQ(L"2", list[0].m_StatDel);
2506         EXPECT_FALSE(list[0].IsDirectory());
2507         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2508         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2509         EXPECT_STREQ(L"0", list[1].m_StatAdd);
2510         EXPECT_STREQ(L"9", list[1].m_StatDel);
2511         EXPECT_FALSE(list[1].IsDirectory());
2512         list.Clear();
2513         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2514         ASSERT_EQ(1, list.GetCount());
2515         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2516         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2517         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2518         EXPECT_FALSE(list[0].IsDirectory());
2519         list.Clear();
2520         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2521         ASSERT_EQ(1, list.GetCount());
2522         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2523         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2524         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2525         EXPECT_FALSE(list[0].IsDirectory());
2526         list.Clear();
2527         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2528         ASSERT_EQ(1, list.GetCount());
2529         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2530         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitPathString());
2531         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2532         EXPECT_FALSE(list[0].IsDirectory());
2533         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2534         list.Clear();
2535         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2536         ASSERT_EQ(2, list.GetCount());
2537         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2538         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2539         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2540         EXPECT_FALSE(list[0].IsDirectory());
2541         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2542         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2543         EXPECT_FALSE(list[1].IsDirectory());
2544         list.Clear();
2545         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2546         ASSERT_EQ(2, list.GetCount());
2547         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
2548         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2549         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2550         EXPECT_FALSE(list[0].IsDirectory());
2551         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2552         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitPathString());
2553         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
2554         EXPECT_FALSE(list[1].IsDirectory());
2555         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2556
2557         // renamed file in same folder (root)
2558         output.Empty();
2559         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2560         EXPECT_STRNE(L"", output);
2561         output.Empty();
2562         EXPECT_EQ(0, m_Git.Run(L"git.exe mv ansi.txt änsi2.txt", &output, CP_UTF8));
2563         EXPECT_STREQ(L"", output);
2564         list.Clear();
2565         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2566         ASSERT_EQ(1, list.GetCount());
2567         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2568         EXPECT_STREQ(L"änsi2.txt", list[0].GetGitPathString());
2569         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
2570         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2571         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2572         EXPECT_STREQ(L"0", list[0].m_StatDel);
2573         EXPECT_FALSE(list[0].IsDirectory());
2574         list.Clear();
2575         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
2576         ASSERT_EQ(1, list.GetCount());
2577         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2578         EXPECT_STREQ(L"änsi2.txt", list[0].GetGitPathString());
2579         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
2580         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2581         EXPECT_FALSE(list[0].IsDirectory());
2582         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2583         list.Clear();
2584         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2585         ASSERT_EQ(2, list.GetCount());
2586         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2587         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2588         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2589         EXPECT_FALSE(list[0].IsDirectory());
2590         EXPECT_STREQ(L"änsi2.txt", list[1].GetGitPathString());
2591         EXPECT_STREQ(L"ansi.txt", list[1].GetGitOldPathString());
2592         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2593         EXPECT_STREQ(L"2", list[0].m_StatAdd);
2594         EXPECT_STREQ(L"2", list[0].m_StatDel);
2595         EXPECT_FALSE(list[1].IsDirectory());
2596         list.Clear();
2597         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2598         ASSERT_EQ(0, list.GetCount());
2599         list.Clear();
2600         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
2601         ASSERT_EQ(0, list.GetCount());
2602         list.Clear();
2603         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2604         ASSERT_EQ(1, list.GetCount());
2605         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2606         EXPECT_STREQ(L"änsi2.txt", list[0].GetGitPathString());
2607         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
2608         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2609         EXPECT_FALSE(list[0].IsDirectory());
2610         list.Clear();
2611         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
2612         ASSERT_EQ(1, list.GetCount());
2613         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2614         EXPECT_STREQ(L"änsi2.txt", list[0].GetGitPathString());
2615         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
2616         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2617         EXPECT_FALSE(list[0].IsDirectory());
2618         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2619         list.Clear();
2620         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2621         ASSERT_EQ(0, list.GetCount());
2622         list.Clear();
2623         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2624         ASSERT_EQ(0, list.GetCount());
2625         list.Clear();
2626         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2627         ASSERT_EQ(2, list.GetCount());
2628         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2629         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2630         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2631         EXPECT_FALSE(list[0].IsDirectory());
2632         EXPECT_STREQ(L"änsi2.txt", list[1].GetGitPathString());
2633         EXPECT_STREQ(L"ansi.txt", list[1].GetGitOldPathString());
2634         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2635         EXPECT_FALSE(list[1].IsDirectory());
2636         list.Clear();
2637         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2638         ASSERT_EQ(2, list.GetCount());
2639         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2640         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2641         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2642         EXPECT_FALSE(list[0].IsDirectory());
2643         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2644         EXPECT_STREQ(L"änsi2.txt", list[1].GetGitPathString());
2645         EXPECT_STREQ(L"ansi.txt", list[1].GetGitOldPathString());
2646         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2647         EXPECT_FALSE(list[1].IsDirectory());
2648         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2649
2650         // renamed file in same folder (subfolder)
2651         output.Empty();
2652         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2653         EXPECT_STRNE(L"", output);
2654         output.Empty();
2655         EXPECT_EQ(0, m_Git.Run(L"git.exe mv copy/ansi.txt copy/ansi2.txt", &output, CP_UTF8));
2656         EXPECT_STREQ(L"", output);
2657         list.Clear();
2658         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2659         ASSERT_EQ(1, list.GetCount());
2660         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2661         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2662         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitOldPathString());
2663         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2664         EXPECT_FALSE(list[0].IsDirectory());
2665         list.Clear();
2666         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
2667         ASSERT_EQ(1, list.GetCount());
2668         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2669         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2670         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitOldPathString());
2671         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2672         EXPECT_FALSE(list[0].IsDirectory());
2673         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2674         list.Clear();
2675         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2676         ASSERT_EQ(2, list.GetCount());
2677         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2678         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2679         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2680         EXPECT_FALSE(list[0].IsDirectory());
2681         EXPECT_STREQ(L"copy/ansi2.txt", list[1].GetGitPathString());
2682         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitOldPathString());
2683         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2684         EXPECT_FALSE(list[1].IsDirectory());
2685         list.Clear();
2686         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2687         ASSERT_EQ(1, list.GetCount());
2688         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2689         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2690         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitOldPathString());
2691         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2692         EXPECT_FALSE(list[0].IsDirectory());
2693         list.Clear();
2694         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
2695         ASSERT_EQ(1, list.GetCount());
2696         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2697         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2698         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitOldPathString());
2699         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2700         EXPECT_FALSE(list[0].IsDirectory());
2701         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2702         list.Clear();
2703         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2704         ASSERT_EQ(1, list.GetCount());
2705         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2706         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2707         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitOldPathString());
2708         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2709         EXPECT_FALSE(list[0].IsDirectory());
2710         list.Clear();
2711         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
2712         ASSERT_EQ(1, list.GetCount());
2713         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2714         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2715         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitOldPathString());
2716         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2717         EXPECT_FALSE(list[0].IsDirectory());
2718         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2719         list.Clear();
2720         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2721         ASSERT_EQ(1, list.GetCount());
2722         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2723         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2724         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitOldPathString());
2725         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2726         EXPECT_FALSE(list[0].IsDirectory());
2727         list.Clear();
2728         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2729         ASSERT_EQ(1, list.GetCount());
2730         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2731         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
2732         EXPECT_STREQ(L"copy/ansi.txt", list[0].GetGitOldPathString());
2733         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2734         EXPECT_FALSE(list[0].IsDirectory());
2735         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2736         list.Clear();
2737         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2738         ASSERT_EQ(2, list.GetCount());
2739         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2740         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2741         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2742         EXPECT_FALSE(list[0].IsDirectory());
2743         EXPECT_STREQ(L"copy/ansi2.txt", list[1].GetGitPathString());
2744         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitOldPathString());
2745         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2746         EXPECT_FALSE(list[1].IsDirectory());
2747         list.Clear();
2748         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2749         ASSERT_EQ(2, list.GetCount());
2750         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2751         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2752         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2753         EXPECT_FALSE(list[0].IsDirectory());
2754         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2755         EXPECT_STREQ(L"copy/ansi2.txt", list[1].GetGitPathString());
2756         EXPECT_STREQ(L"copy/ansi.txt", list[1].GetGitOldPathString());
2757         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2758         EXPECT_FALSE(list[1].IsDirectory());
2759         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2760
2761         // renamed file in same folder (root) and modified file (without staging)
2762         output.Empty();
2763         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2764         EXPECT_STRNE(L"", output);
2765         output.Empty();
2766         EXPECT_EQ(0, m_Git.Run(L"git.exe mv ansi.txt änsi2.txt", &output, CP_UTF8));
2767         EXPECT_STREQ(L"", output);
2768         testFile = m_Git.m_CurrentDir + L"\\änsi2.txt";
2769         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"lkjglkäöfdg\nfgdjsäkglsfdg\nöäöü45g\nfdgi & §$ % &hfdsgä\nä#äf34öööäß€9875oe\nöäSOMETHINGELSEmfdg\n€fgfdsg\n45\näü\n"));
2770         list.Clear();
2771         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2772         ASSERT_EQ(1, list.GetCount());
2773         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2774         EXPECT_STREQ(L"änsi2.txt", list[0].GetGitPathString());
2775         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
2776         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2777         //EXPECT_STREQ(L"9", list[0].m_StatAdd);
2778         //EXPECT_STREQ(L"0", list[0].m_StatDel);
2779         EXPECT_FALSE(list[0].IsDirectory());
2780         list.Clear();
2781         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
2782         ASSERT_EQ(1, list.GetCount());
2783         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2784         EXPECT_STREQ(L"änsi2.txt", list[0].GetGitPathString());
2785         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
2786         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2787         //EXPECT_STREQ(L"9", list[0].m_StatAdd);
2788         //EXPECT_STREQ(L"0", list[0].m_StatDel);
2789         EXPECT_FALSE(list[0].IsDirectory());
2790         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[0].m_stagingStatus);
2791         //EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2792         list.Clear();
2793         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2794         ASSERT_EQ(2, list.GetCount());
2795         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2796         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2797         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2798         EXPECT_STREQ(L"2", list[0].m_StatAdd);
2799         EXPECT_STREQ(L"2", list[0].m_StatDel);
2800         EXPECT_FALSE(list[0].IsDirectory());
2801         EXPECT_STREQ(L"änsi2.txt", list[1].GetGitPathString());
2802         EXPECT_STREQ(L"ansi.txt", list[1].GetGitOldPathString());
2803         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2804         //EXPECT_STREQ(L"9", list[1].m_StatAdd);
2805         //EXPECT_STREQ(L"0", list[1].m_StatDel);
2806         EXPECT_FALSE(list[1].IsDirectory());
2807         list.Clear();
2808         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2809         ASSERT_EQ(0, list.GetCount());
2810         list.Clear();
2811         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
2812         ASSERT_EQ(0, list.GetCount());
2813         list.Clear();
2814         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2815         ASSERT_EQ(1, list.GetCount());
2816         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2817         EXPECT_STREQ(L"änsi2.txt", list[0].GetGitPathString());
2818         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
2819         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2820         EXPECT_FALSE(list[0].IsDirectory());
2821         list.Clear();
2822         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
2823         ASSERT_EQ(1, list.GetCount());
2824         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
2825         EXPECT_STREQ(L"änsi2.txt", list[0].GetGitPathString());
2826         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
2827         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
2828         EXPECT_FALSE(list[0].IsDirectory());
2829         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[0].m_stagingStatus);
2830         list.Clear();
2831         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2832         ASSERT_EQ(0, list.GetCount());
2833         list.Clear();
2834         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2835         ASSERT_EQ(0, list.GetCount());
2836         list.Clear();
2837         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2838         ASSERT_EQ(2, list.GetCount());
2839         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2840         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2841         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2842         EXPECT_FALSE(list[0].IsDirectory());
2843         EXPECT_STREQ(L"änsi2.txt", list[1].GetGitPathString());
2844         EXPECT_STREQ(L"ansi.txt", list[1].GetGitOldPathString());
2845         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2846         EXPECT_FALSE(list[1].IsDirectory());
2847         list.Clear();
2848         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2849         ASSERT_EQ(2, list.GetCount());
2850         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2851         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
2852         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2853         EXPECT_FALSE(list[0].IsDirectory());
2854         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2855         EXPECT_STREQ(L"änsi2.txt", list[1].GetGitPathString());
2856         EXPECT_STREQ(L"ansi.txt", list[1].GetGitOldPathString());
2857         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
2858         EXPECT_FALSE(list[1].IsDirectory());
2859         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[1].m_stagingStatus);
2860
2861         // renamed file in same folder (root) and modified file (staged all changes)
2862         output.Empty();
2863         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2864         EXPECT_STRNE(L"", output);
2865         output.Empty();
2866         EXPECT_EQ(0, m_Git.Run(L"git.exe mv ansi.txt änsi2.txt", &output, CP_UTF8));
2867         EXPECT_STREQ(L"", output);
2868         testFile = m_Git.m_CurrentDir + L"\\änsi2.txt";
2869         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"lkjglkäöfdg\nfgdjsäkglsfdg\nöäöü45g\nfdgi & §$ % &hfdsgä\nä#äf34öööäß€9875oe\nöäSOMETHINGELSEmfdg\n€fgfdsg\n45\näü\n"));
2870         output.Empty();
2871         EXPECT_EQ(0, m_Git.Run(L"git.exe add änsi2.txt", &output, CP_UTF8));
2872         EXPECT_STREQ(L"", output);
2873         list.Clear();
2874         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2875         ASSERT_EQ(2, list.GetCount());
2876         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2877         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2878         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2879         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2880         EXPECT_STREQ(L"9", list[0].m_StatDel);
2881         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
2882         EXPECT_FALSE(list[0].IsDirectory());
2883         EXPECT_STREQ(L"änsi2.txt", list[1].GetGitPathString());
2884         EXPECT_STREQ(L"", list[1].GetGitOldPathString());
2885         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
2886         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2887         EXPECT_STREQ(L"9", list[0].m_StatDel);
2888         EXPECT_FALSE(list[1].IsDirectory());
2889         list.Clear();
2890         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
2891         ASSERT_EQ(2, list.GetCount());
2892         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2893         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2894         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2895         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2896         EXPECT_STREQ(L"9", list[0].m_StatDel);
2897         EXPECT_FALSE(list[0].IsDirectory());
2898         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2899         EXPECT_STREQ(L"änsi2.txt", list[1].GetGitPathString());
2900         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
2901         EXPECT_STREQ(L"9", list[1].m_StatAdd);
2902         EXPECT_STREQ(L"0", list[1].m_StatDel);
2903         EXPECT_FALSE(list[1].IsDirectory());
2904         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2905         list.Clear();
2906         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2907         ASSERT_EQ(3, list.GetCount());
2908         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2909         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2910         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2911         EXPECT_STREQ(L"0", list[0].m_StatAdd);
2912         EXPECT_STREQ(L"9", list[0].m_StatDel);
2913         EXPECT_FALSE(list[0].IsDirectory());
2914         EXPECT_STREQ(L"ascii.txt", list[1].GetGitPathString());
2915         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2916         EXPECT_STREQ(L"2", list[1].m_StatAdd);
2917         EXPECT_STREQ(L"2", list[1].m_StatDel);
2918         EXPECT_FALSE(list[1].IsDirectory());
2919         EXPECT_STREQ(L"änsi2.txt", list[2].GetGitPathString());
2920         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[2].m_Action);
2921         EXPECT_STREQ(L"9", list[2].m_StatAdd);
2922         EXPECT_STREQ(L"0", list[2].m_StatDel);
2923         EXPECT_FALSE(list[2].IsDirectory());
2924         list.Clear();
2925         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
2926         ASSERT_EQ(0, list.GetCount());
2927         list.Clear();
2928         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
2929         ASSERT_EQ(0, list.GetCount());
2930         list.Clear();
2931         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
2932         ASSERT_EQ(2, list.GetCount());
2933         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2934         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2935         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2936         EXPECT_FALSE(list[0].IsDirectory());
2937         EXPECT_STREQ(L"änsi2.txt", list[1].GetGitPathString());
2938         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
2939         EXPECT_FALSE(list[1].IsDirectory());
2940         list.Clear();
2941         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
2942         ASSERT_EQ(2, list.GetCount());
2943         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2944         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2945         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2946         EXPECT_FALSE(list[0].IsDirectory());
2947         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2948         EXPECT_STREQ(L"änsi2.txt", list[1].GetGitPathString());
2949         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
2950         EXPECT_FALSE(list[1].IsDirectory());
2951         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2952         list.Clear();
2953         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
2954         ASSERT_EQ(0, list.GetCount());
2955         list.Clear();
2956         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
2957         ASSERT_EQ(0, list.GetCount());
2958         list.Clear();
2959         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
2960         ASSERT_EQ(3, list.GetCount());
2961         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2962         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2963         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2964         EXPECT_FALSE(list[0].IsDirectory());
2965         EXPECT_STREQ(L"ascii.txt", list[1].GetGitPathString());
2966         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2967         EXPECT_FALSE(list[1].IsDirectory());
2968         EXPECT_STREQ(L"änsi2.txt", list[2].GetGitPathString());
2969         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[2].m_Action);
2970         EXPECT_FALSE(list[2].IsDirectory());
2971         list.Clear();
2972         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
2973         ASSERT_EQ(3, list.GetCount());
2974         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2975         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
2976         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
2977         EXPECT_FALSE(list[0].IsDirectory());
2978         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
2979         EXPECT_STREQ(L"ascii.txt", list[1].GetGitPathString());
2980         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2981         EXPECT_FALSE(list[1].IsDirectory());
2982         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
2983         EXPECT_STREQ(L"änsi2.txt", list[2].GetGitPathString());
2984         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[2].m_Action);
2985         EXPECT_FALSE(list[2].IsDirectory());
2986         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[2].m_stagingStatus);
2987
2988         // added and staged new file
2989         output.Empty();
2990         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
2991         EXPECT_STRNE(L"", output);
2992         testFile = m_Git.m_CurrentDir + L"\\copy\\test-file.txt";
2993         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
2994         output.Empty();
2995         EXPECT_EQ(0, m_Git.Run(L"git.exe add copy/test-file.txt", &output, CP_UTF8));
2996         EXPECT_STREQ(L"", output);
2997         list.Clear();
2998         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2999         ASSERT_EQ(1, list.GetCount());
3000         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3001         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
3002         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
3003         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3004         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3005         EXPECT_STREQ(L"0", list[0].m_StatDel);
3006         EXPECT_FALSE(list[0].IsDirectory());
3007         list.Clear();
3008         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
3009         ASSERT_EQ(1, list.GetCount());
3010         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3011         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
3012         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3013         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3014         EXPECT_STREQ(L"0", list[0].m_StatDel);
3015         EXPECT_FALSE(list[0].IsDirectory());
3016         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3017         list.Clear();
3018         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
3019         ASSERT_EQ(2, list.GetCount());
3020         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3021         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
3022         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3023         EXPECT_STREQ(L"2", list[0].m_StatAdd);
3024         EXPECT_STREQ(L"2", list[0].m_StatDel);
3025         EXPECT_FALSE(list[0].IsDirectory());
3026         EXPECT_STREQ(L"copy/test-file.txt", list[1].GetGitPathString());
3027         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3028         EXPECT_STREQ(L"1", list[1].m_StatAdd);
3029         EXPECT_STREQ(L"0", list[1].m_StatDel);
3030         EXPECT_FALSE(list[1].IsDirectory());
3031         list.Clear();
3032         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
3033         ASSERT_EQ(1, list.GetCount());
3034         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3035         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
3036         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3037         EXPECT_FALSE(list[0].IsDirectory());
3038         list.Clear();
3039         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
3040         ASSERT_EQ(1, list.GetCount());
3041         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3042         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
3043         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3044         EXPECT_FALSE(list[0].IsDirectory());
3045         list.Clear();
3046         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
3047         ASSERT_EQ(1, list.GetCount());
3048         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3049         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
3050         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3051         EXPECT_FALSE(list[0].IsDirectory());
3052         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3053         list.Clear();
3054         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
3055         ASSERT_EQ(2, list.GetCount());
3056         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3057         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
3058         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3059         EXPECT_FALSE(list[0].IsDirectory());
3060         EXPECT_STREQ(L"copy/test-file.txt", list[1].GetGitPathString());
3061         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3062         EXPECT_FALSE(list[1].IsDirectory());
3063         list.Clear();
3064         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
3065         ASSERT_EQ(2, list.GetCount());
3066         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3067         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
3068         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3069         EXPECT_FALSE(list[0].IsDirectory());
3070         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3071         EXPECT_STREQ(L"copy/test-file.txt", list[1].GetGitPathString());
3072         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3073         EXPECT_FALSE(list[1].IsDirectory());
3074         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
3075
3076         // added and staged new file, then modified without staging
3077         output.Empty();
3078         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
3079         EXPECT_STRNE(L"", output);
3080         testFile = m_Git.m_CurrentDir + L"\\copy\\test-file.txt";
3081         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"*.enc filter=openssl\n"));
3082         output.Empty();
3083         EXPECT_EQ(0, m_Git.Run(L"git.exe add copy/test-file.txt", &output, CP_UTF8));
3084         EXPECT_STREQ(L"", output);
3085         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"something else\n"));
3086         list.Clear();
3087         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3088         ASSERT_EQ(1, list.GetCount());
3089         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3090         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
3091         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
3092         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3093         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3094         EXPECT_STREQ(L"0", list[0].m_StatDel);
3095         EXPECT_FALSE(list[0].IsDirectory());
3096         list.Clear();
3097         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
3098         ASSERT_EQ(1, list.GetCount());
3099         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3100         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
3101         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3102         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3103         EXPECT_STREQ(L"0", list[0].m_StatDel);
3104         EXPECT_FALSE(list[0].IsDirectory());
3105         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[0].m_stagingStatus);
3106         list.Clear();
3107         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
3108         ASSERT_EQ(2, list.GetCount());
3109         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3110         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
3111         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3112         EXPECT_STREQ(L"2", list[0].m_StatAdd);
3113         EXPECT_STREQ(L"2", list[0].m_StatDel);
3114         EXPECT_FALSE(list[0].IsDirectory());
3115         EXPECT_STREQ(L"copy/test-file.txt", list[1].GetGitPathString());
3116         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3117         EXPECT_STREQ(L"1", list[1].m_StatAdd);
3118         EXPECT_STREQ(L"0", list[1].m_StatDel);
3119         EXPECT_FALSE(list[1].IsDirectory());
3120         list.Clear();
3121         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
3122         ASSERT_EQ(1, list.GetCount());
3123         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3124         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
3125         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3126         EXPECT_FALSE(list[0].IsDirectory());
3127         list.Clear();
3128         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
3129         ASSERT_EQ(1, list.GetCount());
3130         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3131         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
3132         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3133         EXPECT_FALSE(list[0].IsDirectory());
3134         list.Clear();
3135         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
3136         ASSERT_EQ(1, list.GetCount());
3137         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3138         EXPECT_STREQ(L"copy/test-file.txt", list[0].GetGitPathString());
3139         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3140         EXPECT_FALSE(list[0].IsDirectory());
3141         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[0].m_stagingStatus);
3142         list.Clear();
3143         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
3144         ASSERT_EQ(2, list.GetCount());
3145         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3146         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
3147         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3148         EXPECT_FALSE(list[0].IsDirectory());
3149         EXPECT_STREQ(L"copy/test-file.txt", list[1].GetGitPathString());
3150         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3151         EXPECT_FALSE(list[1].IsDirectory());
3152         list.Clear();
3153         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
3154         ASSERT_EQ(2, list.GetCount());
3155         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3156         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
3157         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3158         EXPECT_FALSE(list[0].IsDirectory());
3159         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3160         EXPECT_STREQ(L"copy/test-file.txt", list[1].GetGitPathString());
3161         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3162         EXPECT_FALSE(list[1].IsDirectory());
3163         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[1].m_stagingStatus);
3164
3165         // file copied and staged
3166         output.Empty();
3167         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
3168         EXPECT_STRNE(L"", output);
3169         testFile = m_Git.m_CurrentDir + L"\\ansi.txt";
3170         EXPECT_TRUE(CopyFile(m_Git.m_CurrentDir + L"\\ansi.txt", m_Git.m_CurrentDir + L"\\ansi2.txt", TRUE));
3171         output.Empty();
3172         EXPECT_EQ(0, m_Git.Run(L"git.exe add ansi2.txt", &output, CP_UTF8));
3173         EXPECT_STREQ(L"", output);
3174         list.Clear();
3175         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3176         ASSERT_EQ(1, list.GetCount());
3177         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3178         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
3179         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
3180         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3181         EXPECT_STREQ(L"9", list[0].m_StatAdd);
3182         EXPECT_STREQ(L"0", list[0].m_StatDel);
3183         EXPECT_FALSE(list[0].IsDirectory());
3184         list.Clear();
3185         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
3186         ASSERT_EQ(1, list.GetCount());
3187         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3188         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
3189         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3190         EXPECT_FALSE(list[0].IsDirectory());
3191         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3192         list.Clear();
3193         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
3194         ASSERT_EQ(2, list.GetCount());
3195         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3196         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
3197         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3198         EXPECT_FALSE(list[0].IsDirectory());
3199         EXPECT_STREQ(L"ascii.txt", list[1].GetGitPathString());
3200         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
3201         EXPECT_FALSE(list[1].IsDirectory());
3202         list.Clear();
3203         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
3204         ASSERT_EQ(0, list.GetCount());
3205         list.Clear();
3206         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
3207         ASSERT_EQ(0, list.GetCount());
3208         list.Clear();
3209         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
3210         ASSERT_EQ(1, list.GetCount());
3211         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3212         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
3213         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3214         EXPECT_FALSE(list[0].IsDirectory());
3215         list.Clear();
3216         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
3217         ASSERT_EQ(1, list.GetCount());
3218         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3219         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
3220         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3221         EXPECT_FALSE(list[0].IsDirectory());
3222         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3223         list.Clear();
3224         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
3225         ASSERT_EQ(0, list.GetCount());
3226         list.Clear();
3227         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
3228         ASSERT_EQ(0, list.GetCount());
3229         list.Clear();
3230         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
3231         ASSERT_EQ(2, list.GetCount());
3232         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3233         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
3234         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3235         EXPECT_FALSE(list[0].IsDirectory());
3236         EXPECT_STREQ(L"ascii.txt", list[1].GetGitPathString());
3237         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
3238         EXPECT_FALSE(list[1].IsDirectory());
3239         list.Clear();
3240         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
3241         ASSERT_EQ(2, list.GetCount());
3242         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3243         EXPECT_STREQ(L"ansi2.txt", list[0].GetGitPathString());
3244         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3245         EXPECT_FALSE(list[0].IsDirectory());
3246         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3247         EXPECT_STREQ(L"ascii.txt", list[1].GetGitPathString());
3248         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
3249         EXPECT_FALSE(list[1].IsDirectory());
3250         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
3251
3252         // file renamed + moved to sub-folder
3253         output.Empty();
3254         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
3255         EXPECT_STRNE(L"", output);
3256         output.Empty();
3257         EXPECT_EQ(0, m_Git.Run(L"git.exe mv ansi.txt copy/ansi2.txt", &output, CP_UTF8));
3258         EXPECT_STREQ(L"", output);
3259         list.Clear();
3260         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3261         ASSERT_EQ(1, list.GetCount());
3262         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
3263         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
3264         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
3265         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
3266         EXPECT_FALSE(list[0].IsDirectory());
3267         list.Clear();
3268         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
3269         ASSERT_EQ(1, list.GetCount());
3270         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
3271         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
3272         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
3273         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
3274         EXPECT_FALSE(list[0].IsDirectory());
3275         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3276         list.Clear();
3277         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
3278         ASSERT_EQ(2, list.GetCount());
3279         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
3280         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
3281         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3282         EXPECT_FALSE(list[0].IsDirectory());
3283         EXPECT_STREQ(L"copy/ansi2.txt", list[1].GetGitPathString());
3284         EXPECT_STREQ(L"ansi.txt", list[1].GetGitOldPathString());
3285         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
3286         EXPECT_FALSE(list[1].IsDirectory());
3287         list.Clear();
3288         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false)); // TODO: due to filter restrictions we cannot detect the rename here
3289         ASSERT_EQ(1, list.GetCount());
3290         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3291         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
3292         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action); // TODO
3293         EXPECT_FALSE(list[0].IsDirectory());
3294         list.Clear();
3295         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true)); // TODO: due to filter restrictions we cannot detect the rename here
3296         ASSERT_EQ(1, list.GetCount());
3297         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3298         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
3299         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action); // TODO
3300         EXPECT_FALSE(list[0].IsDirectory());
3301         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3302         list.Clear();
3303         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
3304         ASSERT_EQ(1, list.GetCount());
3305         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
3306         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
3307         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
3308         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
3309         EXPECT_FALSE(list[0].IsDirectory());
3310         list.Clear();
3311         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
3312         ASSERT_EQ(1, list.GetCount());
3313         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
3314         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
3315         EXPECT_STREQ(L"ansi.txt", list[0].GetGitOldPathString());
3316         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
3317         EXPECT_FALSE(list[0].IsDirectory());
3318         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3319         list.Clear();
3320         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false)); // TODO: due to filter restrictions we cannot detect the rename here
3321         ASSERT_EQ(1, list.GetCount());
3322         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3323         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
3324         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action); // TODO
3325         EXPECT_FALSE(list[0].IsDirectory());
3326         list.Clear();
3327         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true)); // TODO: due to filter restrictions we cannot detect the rename here
3328         ASSERT_EQ(1, list.GetCount());
3329         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3330         EXPECT_STREQ(L"copy/ansi2.txt", list[0].GetGitPathString());
3331         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action); // TODO
3332         EXPECT_FALSE(list[0].IsDirectory());
3333         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3334         list.Clear();
3335         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
3336         ASSERT_EQ(2, list.GetCount());
3337         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
3338         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
3339         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3340         EXPECT_FALSE(list[0].IsDirectory());
3341         EXPECT_STREQ(L"copy/ansi2.txt", list[1].GetGitPathString());
3342         EXPECT_STREQ(L"ansi.txt", list[1].GetGitOldPathString());
3343         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
3344         EXPECT_FALSE(list[1].IsDirectory());
3345         list.Clear();
3346         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
3347         ASSERT_EQ(2, list.GetCount());
3348         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
3349         EXPECT_STREQ(L"ascii.txt", list[0].GetGitPathString());
3350         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3351         EXPECT_FALSE(list[0].IsDirectory());
3352         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3353         EXPECT_STREQ(L"copy/ansi2.txt", list[1].GetGitPathString());
3354         EXPECT_STREQ(L"ansi.txt", list[1].GetGitOldPathString());
3355         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
3356         EXPECT_FALSE(list[1].IsDirectory());
3357         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
3358
3359         // conflicting files
3360         output.Empty();
3361         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
3362         EXPECT_STRNE(L"", output);
3363         output.Empty();
3364         EXPECT_EQ(0, m_Git.Run(L"git.exe merge forconflict", &output, CP_UTF8));
3365         EXPECT_STRNE(L"", output);
3366         output.Empty();
3367         EXPECT_EQ(1, m_Git.Run(L"git.exe merge simple-conflict", &output, CP_UTF8));
3368         EXPECT_STRNE(L"", output);
3369         list.Clear();
3370         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3371         ASSERT_EQ(1, list.GetCount());
3372         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
3373         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3374         EXPECT_STREQ(L"", list[0].GetGitOldPathString());
3375         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3376         EXPECT_STREQ(L"6", list[0].m_StatAdd);
3377         EXPECT_STREQ(L"0", list[0].m_StatDel);
3378         EXPECT_FALSE(list[0].IsDirectory());
3379         list.Clear();
3380         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
3381         ASSERT_EQ(1, list.GetCount());
3382         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
3383         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3384         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3385         EXPECT_FALSE(list[0].IsDirectory());
3386         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
3387         list.Clear();
3388         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
3389         ASSERT_EQ(7, list.GetCount());
3390         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
3391         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3392         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3393         EXPECT_FALSE(list[0].IsDirectory());
3394         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
3395         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
3396         EXPECT_FALSE(list[1].IsDirectory());
3397         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
3398         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
3399         EXPECT_FALSE(list[2].IsDirectory());
3400         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
3401         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
3402         EXPECT_FALSE(list[3].IsDirectory());
3403         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
3404         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
3405         EXPECT_FALSE(list[4].IsDirectory());
3406         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
3407         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
3408         EXPECT_FALSE(list[5].IsDirectory());
3409         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
3410         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
3411         EXPECT_FALSE(list[6].IsDirectory());
3412         list.Clear();
3413         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
3414         ASSERT_EQ(0, list.GetCount());
3415         list.Clear();
3416         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
3417         ASSERT_EQ(0, list.GetCount());
3418         list.Clear();
3419         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
3420         ASSERT_EQ(1, list.GetCount());
3421         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list.GetAction());
3422         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3423         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
3424         EXPECT_FALSE(list[0].IsDirectory());
3425         list.Clear();
3426         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
3427         ASSERT_EQ(1, list.GetCount());
3428         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list.GetAction());
3429         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3430         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
3431         EXPECT_FALSE(list[0].IsDirectory());
3432         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
3433         list.Clear();
3434         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false));
3435         ASSERT_EQ(0, list.GetCount());
3436         list.Clear();
3437         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, false, true));
3438         ASSERT_EQ(0, list.GetCount());
3439         list.Clear();
3440         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true));
3441         ASSERT_EQ(7, list.GetCount());
3442         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
3443         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3444         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
3445         EXPECT_FALSE(list[0].IsDirectory());
3446         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
3447         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
3448         EXPECT_FALSE(list[1].IsDirectory());
3449         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
3450         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
3451         EXPECT_FALSE(list[2].IsDirectory());
3452         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
3453         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
3454         EXPECT_FALSE(list[3].IsDirectory());
3455         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
3456         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
3457         EXPECT_FALSE(list[4].IsDirectory());
3458         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
3459         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
3460         EXPECT_FALSE(list[5].IsDirectory());
3461         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
3462         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
3463         EXPECT_FALSE(list[6].IsDirectory());
3464         list.Clear();
3465         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter, true, true));
3466         ASSERT_EQ(7, list.GetCount());
3467         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
3468         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3469         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
3470         EXPECT_FALSE(list[0].IsDirectory());
3471         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
3472         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
3473         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
3474         EXPECT_FALSE(list[1].IsDirectory());
3475         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
3476         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
3477         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
3478         EXPECT_FALSE(list[2].IsDirectory());
3479         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[2].m_stagingStatus);
3480         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
3481         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
3482         EXPECT_FALSE(list[3].IsDirectory());
3483         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[3].m_stagingStatus);
3484         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
3485         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
3486         EXPECT_FALSE(list[4].IsDirectory());
3487         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[4].m_stagingStatus);
3488         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
3489         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
3490         EXPECT_FALSE(list[5].IsDirectory());
3491         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[5].m_stagingStatus);
3492         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
3493         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
3494         EXPECT_FALSE(list[6].IsDirectory());
3495         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[6].m_stagingStatus);
3496 }
3497
3498 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges_DeleteModifyConflict_DeletedRemotely)
3499 {
3500         if (GetParam() != 0)
3501                 return;
3502
3503         CString output;
3504         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
3505         EXPECT_STRNE(L"", output);
3506
3507         output.Empty();
3508         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout forconflict", &output, CP_UTF8));
3509         EXPECT_STRNE(L"", output);
3510         output.Empty();
3511         EXPECT_EQ(0, m_Git.Run(L"git.exe rm ansi.txt", &output, CP_UTF8));
3512         EXPECT_STRNE(L"", output);
3513         output.Empty();
3514         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Prepare conflict case\"", &output, CP_UTF8));
3515         EXPECT_STRNE(L"", output);
3516         output.Empty();
3517         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout simple-conflict", &output, CP_UTF8));
3518         EXPECT_STRNE(L"", output);
3519         output.Empty();
3520         EXPECT_EQ(1, m_Git.Run(L"git.exe merge forconflict", &output, CP_UTF8));
3521         EXPECT_STRNE(L"", output);
3522
3523         CTGitPathList filter(CTGitPath(L"copy"));
3524
3525         CTGitPathList list;
3526         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3527         ASSERT_EQ(7, list.GetCount());
3528         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
3529         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3530         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3531         EXPECT_STREQ(L"0", list[0].m_StatAdd);
3532         EXPECT_STREQ(L"0", list[0].m_StatDel);
3533         EXPECT_FALSE(list[0].IsDirectory());
3534         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
3535         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
3536         EXPECT_STREQ(L"-", list[1].m_StatAdd);
3537         EXPECT_STREQ(L"-", list[1].m_StatDel);
3538         EXPECT_FALSE(list[1].IsDirectory());
3539         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
3540         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
3541         EXPECT_STREQ(L"-", list[2].m_StatAdd);
3542         EXPECT_STREQ(L"-", list[2].m_StatDel);
3543         EXPECT_FALSE(list[2].IsDirectory());
3544         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
3545         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
3546         EXPECT_STREQ(L"-", list[3].m_StatAdd);
3547         EXPECT_STREQ(L"-", list[3].m_StatDel);
3548         EXPECT_FALSE(list[3].IsDirectory());
3549         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
3550         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
3551         EXPECT_STREQ(L"-", list[4].m_StatAdd);
3552         EXPECT_STREQ(L"-", list[4].m_StatDel);
3553         EXPECT_FALSE(list[4].IsDirectory());
3554         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
3555         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
3556         EXPECT_STREQ(L"6", list[5].m_StatAdd);
3557         EXPECT_STREQ(L"6", list[5].m_StatDel);
3558         EXPECT_FALSE(list[5].IsDirectory());
3559         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
3560         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
3561         EXPECT_STREQ(L"3", list[6].m_StatAdd);
3562         EXPECT_STREQ(L"3", list[6].m_StatDel);
3563         EXPECT_FALSE(list[6].IsDirectory());
3564         list.Clear();
3565         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
3566         ASSERT_EQ(7, list.GetCount());
3567         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
3568         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3569         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3570         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3571         EXPECT_STREQ(L"1", list[0].m_StatDel);
3572         EXPECT_FALSE(list[0].IsDirectory());
3573         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
3574         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
3575         EXPECT_STREQ(L"-", list[1].m_StatAdd);
3576         EXPECT_STREQ(L"-", list[1].m_StatDel);
3577         EXPECT_FALSE(list[1].IsDirectory());
3578         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
3579         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
3580         EXPECT_STREQ(L"-", list[2].m_StatAdd);
3581         EXPECT_STREQ(L"-", list[2].m_StatDel);
3582         EXPECT_FALSE(list[2].IsDirectory());
3583         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
3584         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
3585         EXPECT_STREQ(L"-", list[3].m_StatAdd);
3586         EXPECT_STREQ(L"-", list[3].m_StatDel);
3587         EXPECT_FALSE(list[3].IsDirectory());
3588         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
3589         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
3590         EXPECT_FALSE(list[4].IsDirectory());
3591         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
3592         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
3593         EXPECT_FALSE(list[5].IsDirectory());
3594         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
3595         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
3596         EXPECT_FALSE(list[6].IsDirectory());
3597         list.Clear();
3598         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
3599         ASSERT_EQ(0, list.GetCount());
3600         list.Clear();
3601         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
3602         ASSERT_EQ(0, list.GetCount());
3603         list.Clear();
3604         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
3605         ASSERT_EQ(7, list.GetCount());
3606         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
3607         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3608         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
3609         EXPECT_FALSE(list[0].IsDirectory());
3610         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
3611         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
3612         EXPECT_FALSE(list[1].IsDirectory());
3613         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
3614         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
3615         EXPECT_FALSE(list[2].IsDirectory());
3616         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
3617         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
3618         EXPECT_FALSE(list[3].IsDirectory());
3619         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
3620         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
3621         EXPECT_FALSE(list[4].IsDirectory());
3622         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
3623         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
3624         EXPECT_FALSE(list[5].IsDirectory());
3625         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
3626         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
3627         EXPECT_FALSE(list[6].IsDirectory());
3628         list.Clear();
3629         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
3630         ASSERT_EQ(7, list.GetCount());
3631         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
3632         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3633         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
3634         EXPECT_FALSE(list[0].IsDirectory());
3635         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
3636         EXPECT_STREQ(L"utf16-be-bom.txt", list[1].GetGitPathString());
3637         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
3638         EXPECT_FALSE(list[1].IsDirectory());
3639         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
3640         EXPECT_STREQ(L"utf16-be-nobom.txt", list[2].GetGitPathString());
3641         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
3642         EXPECT_FALSE(list[2].IsDirectory());
3643         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[2].m_stagingStatus);
3644         EXPECT_STREQ(L"utf16-le-bom.txt", list[3].GetGitPathString());
3645         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
3646         EXPECT_FALSE(list[3].IsDirectory());
3647         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[3].m_stagingStatus);
3648         EXPECT_STREQ(L"utf16-le-nobom.txt", list[4].GetGitPathString());
3649         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
3650         EXPECT_FALSE(list[4].IsDirectory());
3651         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[4].m_stagingStatus);
3652         EXPECT_STREQ(L"utf8-bom.txt", list[5].GetGitPathString());
3653         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
3654         EXPECT_FALSE(list[5].IsDirectory());
3655         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[5].m_stagingStatus);
3656         EXPECT_STREQ(L"utf8-nobom.txt", list[6].GetGitPathString());
3657         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
3658         EXPECT_FALSE(list[6].IsDirectory());
3659         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[6].m_stagingStatus);
3660 }
3661
3662 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges_DeleteModifyConflict_DeletedLocally)
3663 {
3664         if (GetParam() != 0)
3665                 return;
3666
3667         CString output;
3668         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
3669         EXPECT_STRNE(L"", output);
3670
3671         output.Empty();
3672         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout forconflict", &output, CP_UTF8));
3673         EXPECT_STRNE(L"", output);
3674         output.Empty();
3675         EXPECT_EQ(0, m_Git.Run(L"git.exe rm ansi.txt", &output, CP_UTF8));
3676         EXPECT_STRNE(L"", output);
3677         output.Empty();
3678         EXPECT_EQ(0, m_Git.Run(L"git.exe commit -m \"Prepare conflict case\"", &output, CP_UTF8));
3679         EXPECT_STRNE(L"", output);
3680         output.Empty();
3681         EXPECT_EQ(1, m_Git.Run(L"git.exe merge simple-conflict", &output, CP_UTF8));
3682         EXPECT_STRNE(L"", output);
3683
3684         CTGitPathList filter(CTGitPath(L"copy"));
3685
3686         CTGitPathList list;
3687         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3688         ASSERT_EQ(1, list.GetCount());
3689         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
3690         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3691         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3692         //EXPECT_STREQ(L"9", list[0].m_StatAdd);
3693         //EXPECT_STREQ(L"0", list[0].m_StatDel);
3694         EXPECT_FALSE(list[0].IsDirectory());
3695         list.Clear();
3696         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
3697         ASSERT_EQ(1, list.GetCount());
3698         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
3699         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3700         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3701         EXPECT_STREQ(L"4", list[0].m_StatAdd);
3702         EXPECT_STREQ(L"4", list[0].m_StatDel);
3703         EXPECT_FALSE(list[0].IsDirectory());
3704         list.Clear();
3705         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false));
3706         ASSERT_EQ(0, list.GetCount());
3707         list.Clear();
3708         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
3709         ASSERT_EQ(0, list.GetCount());
3710         list.Clear();
3711         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true));
3712         ASSERT_EQ(1, list.GetCount());
3713         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list.GetAction());
3714         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3715         EXPECT_STREQ(L"0", list[0].m_StatAdd);
3716         EXPECT_STREQ(L"0", list[0].m_StatDel);
3717         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
3718         EXPECT_FALSE(list[0].IsDirectory());
3719         list.Clear();
3720         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
3721         ASSERT_EQ(1, list.GetCount());
3722         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list.GetAction());
3723         EXPECT_STREQ(L"ansi.txt", list[0].GetGitPathString());
3724         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
3725         EXPECT_STREQ(L"0", list[0].m_StatAdd);
3726         EXPECT_STREQ(L"0", list[0].m_StatDel);
3727         EXPECT_FALSE(list[0].IsDirectory());
3728         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
3729 }
3730
3731 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetWorkingTreeChanges)
3732 {
3733         if (GetParam() != 0)
3734                 return;
3735
3736         CTGitPathList list;
3737         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3738         EXPECT_TRUE(list.IsEmpty());
3739
3740         CString testFile = m_Dir.GetTempDir() + L"\\test.txt";
3741         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing file."));
3742         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3743         EXPECT_TRUE(list.IsEmpty());
3744         CString output;
3745         EXPECT_EQ(0, m_Git.Run(L"git.exe add test.txt", &output, CP_UTF8));
3746         EXPECT_STREQ(L"", output);
3747         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3748         ASSERT_EQ(1, list.GetCount());
3749         // 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
3750         EXPECT_STREQ(L"test.txt", list[0].GetGitPathString());
3751         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3752         EXPECT_STREQ(L"", list[0].m_StatAdd); // TODO: right now no numstat is parsed
3753         EXPECT_STREQ(L"", list[0].m_StatDel);
3754         EXPECT_FALSE(list[0].IsDirectory());
3755         list.Clear();
3756         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
3757         ASSERT_EQ(1, list.GetCount());
3758         // 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
3759         EXPECT_STREQ(L"test.txt", list[0].GetGitPathString());
3760         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3761         EXPECT_FALSE(list[0].IsDirectory());
3762         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3763         list.Clear();
3764         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, false, true));
3765         ASSERT_EQ(1, list.GetCount());
3766         // 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
3767         EXPECT_STREQ(L"test.txt", list[0].GetGitPathString());
3768         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3769         EXPECT_FALSE(list[0].IsDirectory());
3770         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3771
3772         CTGitPathList filter(CTGitPath(L"copy"));
3773         list.Clear();
3774         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
3775         ASSERT_EQ(1, list.GetCount());
3776         // 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
3777         EXPECT_STREQ(L"test.txt", list[0].GetGitPathString());
3778         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3779         EXPECT_FALSE(list[0].IsDirectory());
3780         list.Clear();
3781         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
3782         ASSERT_EQ(1, list.GetCount());
3783         // 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
3784         EXPECT_STREQ(L"test.txt", list[0].GetGitPathString());
3785         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3786         EXPECT_FALSE(list[0].IsDirectory());
3787         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3788         list.Clear();
3789         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
3790         ASSERT_EQ(1, list.GetCount());
3791         // 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
3792         EXPECT_STREQ(L"test.txt", list[0].GetGitPathString());
3793         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3794         EXPECT_FALSE(list[0].IsDirectory());
3795         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3796
3797         list.Clear();
3798         EXPECT_TRUE(::CreateDirectory(m_Dir.GetTempDir() + L"\\copy", nullptr));
3799         testFile = m_Dir.GetTempDir() + L"\\copy\\test2.txt";
3800         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is another testing file."));
3801         EXPECT_EQ(0, m_Git.Run(L"git.exe add copy/test2.txt", &output, CP_UTF8));
3802         EXPECT_STREQ(L"", output);
3803         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
3804         ASSERT_EQ(2, list.GetCount());
3805         // 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
3806         EXPECT_STREQ(L"copy/test2.txt", list[0].GetGitPathString());
3807         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3808         EXPECT_FALSE(list[0].IsDirectory());
3809         EXPECT_STREQ(L"test.txt", list[1].GetGitPathString());
3810         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3811         EXPECT_FALSE(list[1].IsDirectory());
3812         list.Clear();
3813         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
3814         ASSERT_EQ(2, list.GetCount());
3815         // 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
3816         EXPECT_STREQ(L"copy/test2.txt", list[0].GetGitPathString());
3817         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3818         EXPECT_FALSE(list[0].IsDirectory());
3819         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3820         EXPECT_STREQ(L"test.txt", list[1].GetGitPathString());
3821         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3822         EXPECT_FALSE(list[1].IsDirectory());
3823         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
3824         list.Clear();
3825         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
3826         ASSERT_EQ(2, list.GetCount());
3827         // 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
3828         EXPECT_STREQ(L"copy/test2.txt", list[0].GetGitPathString());
3829         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3830         EXPECT_FALSE(list[0].IsDirectory());
3831         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[0].m_stagingStatus);
3832         EXPECT_STREQ(L"test.txt", list[1].GetGitPathString());
3833         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3834         EXPECT_FALSE(list[1].IsDirectory());
3835         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
3836
3837         // file modified after staging
3838         output.Empty();
3839         list.Clear();
3840         testFile = m_Dir.GetTempDir() + L"\\copy\\test2.txt";
3841         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"different content now"));
3842         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
3843         ASSERT_EQ(2, list.GetCount());
3844         // 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
3845         EXPECT_STREQ(L"copy/test2.txt", list[0].GetGitPathString());
3846         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3847         EXPECT_FALSE(list[0].IsDirectory());
3848         EXPECT_STREQ(L"test.txt", list[1].GetGitPathString());
3849         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3850         EXPECT_FALSE(list[1].IsDirectory());
3851         list.Clear();
3852         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, true, true));
3853         ASSERT_EQ(2, list.GetCount());
3854         // 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
3855         EXPECT_STREQ(L"copy/test2.txt", list[0].GetGitPathString());
3856         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3857         EXPECT_FALSE(list[0].IsDirectory());
3858         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[0].m_stagingStatus);
3859         EXPECT_STREQ(L"test.txt", list[1].GetGitPathString());
3860         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3861         EXPECT_FALSE(list[1].IsDirectory());
3862         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
3863         list.Clear();
3864         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter, false, true));
3865         ASSERT_EQ(2, list.GetCount());
3866         // 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
3867         EXPECT_STREQ(L"copy/test2.txt", list[0].GetGitPathString());
3868         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3869         EXPECT_FALSE(list[0].IsDirectory());
3870         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[0].m_stagingStatus);
3871         EXPECT_STREQ(L"test.txt", list[1].GetGitPathString());
3872         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
3873         EXPECT_FALSE(list[1].IsDirectory());
3874         EXPECT_EQ(CTGitPath::StagingStatus::TotallyStaged, list[1].m_stagingStatus);
3875 }
3876
3877 static int DoSubmodule(const CString& cmd, CGit& git, const CString& submoduleDir, CString& output)
3878 {
3879         output.Empty();
3880         CString old = git.m_CurrentDir;
3881         SCOPE_EXIT { git.m_CurrentDir = old; };
3882         git.m_CurrentDir = submoduleDir;
3883         return git.Run(cmd, &output, CP_UTF8);
3884 }
3885
3886 TEST_P(CBasicGitWithSubmoduleRepositoryFixture, GetWorkingTreeChanges_Submodules)
3887 {
3888         if (GetParam() != 0)
3889                 return;
3890
3891         CTGitPathList list;
3892
3893         CString resourcesDir;
3894         ASSERT_TRUE(GetResourcesDir(resourcesDir));
3895         CString submoduleDir = m_Dir.GetTempDir() + L"\\submodule";
3896         ASSERT_TRUE(CreateDirectory(submoduleDir, nullptr));
3897         ASSERT_TRUE(CreateDirectory(submoduleDir + L"\\.git", nullptr));
3898         CString repoDir = resourcesDir + L"\\git-repo1";
3899         CopyRecursively(repoDir, submoduleDir + L"\\.git");
3900
3901         CString output;
3902         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
3903         EXPECT_STRNE(L"", output);
3904
3905         // test for clean repo which contains an unrelated git submodule
3906         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3907         EXPECT_TRUE(list.IsEmpty());
3908
3909         // test for added, uncommitted submodule
3910         output.Empty();
3911         EXPECT_EQ(0, m_Git.Run(L"git.exe add submodule", &output, CP_UTF8));
3912         //EXPECT_STREQ(L"", output); // Git 2.14 starts to print a warning here
3913         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3914         ASSERT_EQ(1, list.GetCount());
3915         // 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
3916         EXPECT_STREQ(L"submodule", list[0].GetGitPathString());
3917         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3918         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3919         EXPECT_STREQ(L"0", list[0].m_StatDel);
3920         EXPECT_TRUE(list[0].IsDirectory());
3921         list.Clear();
3922         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
3923         ASSERT_EQ(1, list.GetCount());
3924         // 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
3925         EXPECT_STREQ(L"submodule", list[0].GetGitPathString());
3926         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
3927         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3928         EXPECT_STREQ(L"0", list[0].m_StatDel);
3929         EXPECT_TRUE(list[0].IsDirectory());
3930         EXPECT_EQ(CTGitPath::StagingStatus::PartiallyStaged, list[0].m_stagingStatus);
3931
3932         // cleanup
3933         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
3934         submoduleDir = m_Dir.GetTempDir() + L"\\something";
3935
3936         // test for unchanged submodule
3937         output.Empty();
3938         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard branch1", &output, CP_UTF8));
3939         EXPECT_STRNE(L"", output);
3940         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3941         ASSERT_EQ(0, list.GetCount());
3942
3943         // test for unchanged submodule with checkout out files
3944         output.Empty();
3945         ASSERT_TRUE(CreateDirectory(submoduleDir + L"\\.git", nullptr));
3946         CopyRecursively(repoDir, submoduleDir + L"\\.git");
3947         EXPECT_EQ(0, DoSubmodule(L"git.exe reset --hard 49ecdfff36bfe2b9b499b33e5034f427e2fa54dd", m_Git, submoduleDir, output));
3948         EXPECT_STRNE(L"", output);
3949         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3950         ASSERT_EQ(0, list.GetCount());
3951
3952         // test for changed submodule
3953         EXPECT_EQ(0, DoSubmodule(L"git.exe reset --hard HEAD~1", m_Git, submoduleDir, output));
3954         EXPECT_STRNE(L"", output);
3955         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3956         ASSERT_EQ(1, list.GetCount());
3957         EXPECT_STREQ(L"something", list[0].GetGitPathString());
3958         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3959         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3960         EXPECT_STREQ(L"1", list[0].m_StatDel);
3961         EXPECT_TRUE(list[0].IsDirectory());
3962         list.Clear();
3963         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
3964         ASSERT_EQ(1, list.GetCount());
3965         EXPECT_STREQ(L"something", list[0].GetGitPathString());
3966         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3967         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3968         EXPECT_STREQ(L"1", list[0].m_StatDel);
3969         EXPECT_TRUE(list[0].IsDirectory());
3970         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
3971
3972         // test for modify-delete conflict (deleted remote)
3973         output.Empty();
3974         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force branch1", &output, CP_UTF8));
3975         EXPECT_STRNE(L"", output);
3976         output.Empty();
3977         EXPECT_EQ(1, m_Git.Run(L"git.exe merge deleted", &output, CP_UTF8));
3978         EXPECT_STRNE(L"", output);
3979         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
3980         ASSERT_EQ(1, list.GetCount());
3981         EXPECT_STREQ(L"something", list[0].GetGitPathString());
3982         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3983         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3984         EXPECT_STREQ(L"1", list[0].m_StatDel);
3985         EXPECT_TRUE(list[0].IsDirectory());
3986         list.Clear();
3987         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
3988         ASSERT_EQ(1, list.GetCount());
3989         EXPECT_STREQ(L"something", list[0].GetGitPathString());
3990         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
3991         EXPECT_STREQ(L"1", list[0].m_StatAdd);
3992         EXPECT_STREQ(L"1", list[0].m_StatDel);
3993         EXPECT_TRUE(list[0].IsDirectory());
3994         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
3995
3996         // test for modify-delete conflict (deleted locally)
3997         output.Empty();
3998         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
3999         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force deleted", &output, CP_UTF8));
4000         EXPECT_STRNE(L"", output);
4001         output.Empty();
4002         EXPECT_EQ(1, m_Git.Run(L"git.exe merge branch1", &output, CP_UTF8));
4003         EXPECT_STRNE(L"", output);
4004         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
4005         ASSERT_EQ(1, list.GetCount());
4006         EXPECT_STREQ(L"something", list[0].GetGitPathString());
4007         if (m_Git.ms_LastMsysGitVersion < ConvertVersionToInt(2, 34, 0)) {
4008                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
4009                 EXPECT_FALSE(list[0].IsDirectory()); // neither file nor directory is in filesystem
4010         }
4011         else
4012         {
4013                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
4014                 EXPECT_STREQ(L"1", list[0].m_StatAdd);
4015                 EXPECT_STREQ(L"0", list[0].m_StatDel);
4016                 EXPECT_TRUE(list[0].IsDirectory()); // now a directory is in filesystem
4017         }
4018         list.Clear();
4019         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr, true, true));
4020         ASSERT_EQ(1, list.GetCount());
4021         EXPECT_STREQ(L"something", list[0].GetGitPathString());
4022         EXPECT_EQ(CTGitPath::StagingStatus::TotallyUnstaged, list[0].m_stagingStatus);
4023         if (m_Git.ms_LastMsysGitVersion < ConvertVersionToInt(2, 34, 0)) {
4024                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
4025                 EXPECT_FALSE(list[0].IsDirectory()); // neither file nor directory is in filesystem
4026         }
4027         else
4028         {
4029                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
4030                 EXPECT_STREQ(L"1", list[0].m_StatAdd);
4031                 EXPECT_STREQ(L"0", list[0].m_StatDel);
4032                 EXPECT_TRUE(list[0].IsDirectory()); // now a directory is in filesystem
4033         }
4034
4035         // test for merge conflict submodule/file (local submodule, remote file)
4036         output.Empty();
4037         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
4038         DeleteFile(submoduleDir);
4039         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force branch1", &output, CP_UTF8));
4040         EXPECT_STRNE(L"", output);
4041         output.Empty();
4042         EXPECT_EQ(1, m_Git.Run(L"git.exe merge file", &output, CP_UTF8));
4043         EXPECT_STRNE(L"", output);
4044         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
4045         if (m_Git.ms_LastMsysGitVersion < ConvertVersionToInt(2, 34, 0))
4046                 ASSERT_EQ(1, list.GetCount());
4047         else
4048                 ASSERT_EQ(2, list.GetCount());
4049         EXPECT_STREQ(L"something", list[0].GetGitPathString());
4050         if (m_Git.ms_LastMsysGitVersion < ConvertVersionToInt(2, 34, 0) && (m_Git.ms_bCygwinGit || m_Git.ms_bMsys2Git))
4051         {
4052                 EXPECT_TRUE(output.Find(L"error: failed to create path") > 0);
4053                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
4054                 EXPECT_TRUE(list[0].IsDirectory()); // folder is in filesystem
4055         }
4056         else if (m_Git.ms_LastMsysGitVersion < ConvertVersionToInt(2, 34, 0))
4057         {
4058                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
4059                 EXPECT_FALSE(list[0].IsDirectory()); // file is in filesystem
4060         }
4061         else
4062         {
4063                 EXPECT_STREQ(L"something", list[0].GetGitPathString());
4064                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
4065                 EXPECT_STREQ(L"0", list[0].m_StatAdd);
4066                 EXPECT_STREQ(L"0", list[0].m_StatDel);
4067                 EXPECT_TRUE(list[0].IsDirectory()); // directory is in filesystem
4068                 EXPECT_STREQ(L"something~file", list[1].GetGitPathString());
4069                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
4070                 EXPECT_STREQ(L"1", list[1].m_StatAdd);
4071                 EXPECT_STREQ(L"0", list[1].m_StatDel);
4072                 EXPECT_FALSE(list[1].IsDirectory()); // alternative file is in filesystem
4073         }
4074
4075         // test for merge conflict submodule/file (remote submodule, local file)
4076         output.Empty();
4077         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
4078         DeleteFile(submoduleDir);
4079         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force file", &output, CP_UTF8));
4080         EXPECT_STRNE(L"", output);
4081         output.Empty();
4082         EXPECT_EQ(1, m_Git.Run(L"git.exe merge branch1", &output, CP_UTF8));
4083         EXPECT_STRNE(L"", output);
4084         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
4085         if (m_Git.ms_LastMsysGitVersion < ConvertVersionToInt(2, 34, 0))
4086                 ASSERT_EQ(1, list.GetCount());
4087         else
4088                 ASSERT_EQ(2, list.GetCount());
4089         EXPECT_STREQ(L"something", list[0].GetGitPathString());
4090         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
4091         EXPECT_STREQ(L"1", list[0].m_StatAdd);
4092         EXPECT_STREQ(L"1", list[0].m_StatDel);
4093         if (m_Git.ms_LastMsysGitVersion < ConvertVersionToInt(2, 34, 0))
4094                 EXPECT_FALSE(list[0].IsDirectory()); // file is in filesystem
4095         else
4096         {
4097                 EXPECT_TRUE(list[0].IsDirectory()); // directory is in filesystem
4098                 EXPECT_STREQ(L"something~HEAD", list[1].GetGitPathString());
4099                 EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
4100                 EXPECT_STREQ(L"1", list[1].m_StatAdd);
4101                 EXPECT_STREQ(L"0", list[1].m_StatDel);
4102                 EXPECT_FALSE(list[1].IsDirectory()); // alternative file is in filesystem
4103         }
4104
4105         // test for simple merge conflict
4106         DeleteFile(submoduleDir);
4107         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir); // delete .git folder so that we get a simple merge conflict!
4108         output.Empty();
4109         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force branch1", &output, CP_UTF8));
4110         EXPECT_STRNE(L"", output);
4111         output.Empty();
4112         EXPECT_EQ(1, m_Git.Run(L"git.exe merge branch2", &output, CP_UTF8));
4113         EXPECT_STRNE(L"", output);
4114         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
4115         ASSERT_EQ(1, list.GetCount());
4116         EXPECT_STREQ(L"something", list[0].GetGitPathString());
4117         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
4118         EXPECT_STREQ(L"1", list[0].m_StatAdd);
4119         EXPECT_STREQ(L"1", list[0].m_StatDel);
4120         EXPECT_TRUE(list[0].IsDirectory());
4121
4122         // test for submodule to file
4123         DeleteFile(submoduleDir);
4124         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
4125         output.Empty();
4126         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force branch1", &output, CP_UTF8));
4127         EXPECT_STRNE(L"", output);
4128         output.Empty();
4129         EXPECT_EQ(0, m_Git.Run(L"git.exe rm -rf something", &output, CP_UTF8));
4130         EXPECT_STRNE(L"", output);
4131         ASSERT_TRUE(CStringUtils::WriteStringToTextFile(submoduleDir, L"something"));
4132         output.Empty();
4133         EXPECT_EQ(0, m_Git.Run(L"git.exe add something", &output, CP_UTF8));
4134         EXPECT_STREQ(L"", output);
4135         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
4136         ASSERT_EQ(1, list.GetCount());
4137         EXPECT_STREQ(L"something", list[0].GetGitPathString());
4138         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
4139         EXPECT_STREQ(L"1", list[0].m_StatAdd);
4140         EXPECT_STREQ(L"1", list[0].m_StatDel);
4141         EXPECT_FALSE(list[0].IsDirectory());
4142
4143         // test for file to submodule
4144         DeleteFile(submoduleDir);
4145         CAutoTempDir::DeleteDirectoryRecursive(submoduleDir);
4146         output.Empty();
4147         EXPECT_EQ(0, m_Git.Run(L"git.exe checkout --force file", &output, CP_UTF8));
4148         EXPECT_STRNE(L"", output);
4149         output.Empty();
4150         EXPECT_EQ(0, m_Git.Run(L"git.exe rm something", &output, CP_UTF8));
4151         EXPECT_STRNE(L"", output);
4152         ASSERT_TRUE(CreateDirectory(submoduleDir, nullptr));
4153         ASSERT_TRUE(CreateDirectory(submoduleDir + L"\\.git", nullptr));
4154         CopyRecursively(repoDir, submoduleDir + L"\\.git");
4155         EXPECT_EQ(0, DoSubmodule(L"git.exe reset --hard 49ecdfff36bfe2b9b499b33e5034f427e2fa54dd", m_Git, submoduleDir, output));
4156         EXPECT_STRNE(L"", output);
4157         output.Empty();
4158         EXPECT_EQ(0, m_Git.Run(L"git.exe add something", &output, CP_UTF8));
4159         //EXPECT_STREQ(L"", output); // Git 2.14 starts to print a warning here
4160         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
4161         ASSERT_EQ(1, list.GetCount());
4162         EXPECT_STREQ(L"something", list[0].GetGitPathString());
4163         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
4164         EXPECT_STREQ(L"1", list[0].m_StatAdd);
4165         EXPECT_STREQ(L"1", list[0].m_StatDel);
4166         EXPECT_FALSE(list[0].IsDirectory());
4167 }
4168
4169 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges_RefreshGitIndex)
4170 {
4171         if (GetParam() != 0)
4172                 return;
4173
4174         // adding ansi2.txt (as a copy of ansi.txt) produces a warning
4175         m_Git.SetConfigValue(L"core.autocrlf", L"false");
4176
4177         CString output;
4178         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
4179         EXPECT_STRNE(L"", output);
4180
4181         CTGitPathList list;
4182         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
4183         EXPECT_TRUE(list.IsEmpty());
4184
4185         // touch file
4186         HANDLE handle = CreateFile(m_Git.m_CurrentDir + L"\\ascii.txt", GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
4187         ASSERT_NE(handle, INVALID_HANDLE_VALUE);
4188         FILETIME ft;
4189         EXPECT_EQ(TRUE, GetFileTime(handle, nullptr, nullptr, &ft));
4190         ft.dwLowDateTime -= 1000 * 60 * 1000;
4191         EXPECT_NE(0, SetFileTime(handle, nullptr, nullptr, &ft));
4192         CloseHandle(handle);
4193
4194         // START: this is the undesired behavior
4195         // this test is just there so we notice when this change somehow
4196         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
4197         if (m_Git.ms_bCygwinGit || m_Git.ms_bMsys2Git)
4198                 EXPECT_EQ(0, list.GetCount());
4199         else
4200                 EXPECT_EQ(1, list.GetCount());
4201         list.Clear();
4202         // END: this is the undesired behavior
4203
4204         m_Git.RefreshGitIndex(); // without this GetWorkingTreeChanges might report this file as modified (if no msys or cygwin hack is on)
4205         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
4206         EXPECT_EQ(0, list.GetCount());
4207 }
4208
4209 TEST_P(CBasicGitWithTestRepoFixture, GetBisectTerms)
4210 {
4211         if (m_Git.ms_bCygwinGit)
4212                 return;
4213
4214         CString good, bad;
4215         CString output;
4216
4217         EXPECT_EQ(0, m_Git.Run(L"git.exe bisect start", &output, CP_UTF8));
4218         m_Git.GetBisectTerms(&good, &bad);
4219         EXPECT_STREQ(L"good", good);
4220         EXPECT_STREQ(L"bad", bad);
4221
4222         good.Empty();
4223         bad.Empty();
4224         m_Git.GetBisectTerms(&good, &bad);
4225         EXPECT_STREQ(L"good", good);
4226         EXPECT_STREQ(L"bad", bad);
4227
4228         EXPECT_EQ(0, m_Git.Run(L"git.exe bisect reset", &output, CP_UTF8));
4229
4230         if (m_Git.GetGitVersion(nullptr, nullptr) < 0x02070000)
4231                 return;
4232
4233         EXPECT_EQ(0, m_Git.Run(L"git.exe bisect start --term-good=original --term-bad=changed", &output, CP_UTF8));
4234         m_Git.GetBisectTerms(&good, &bad);
4235         EXPECT_STREQ(L"original", good);
4236         EXPECT_STREQ(L"changed", bad);
4237
4238         EXPECT_EQ(0, m_Git.Run(L"git.exe bisect reset", &output, CP_UTF8));
4239 }
4240
4241 TEST_P(CBasicGitWithTestRepoFixture, GetRefsCommitIsOn)
4242 {
4243         STRING_VECTOR list;
4244         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6"), false, false));
4245         EXPECT_TRUE(list.empty());
4246
4247         list.clear();
4248         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6"), true, true));
4249         ASSERT_EQ(1U, list.size());
4250         EXPECT_STREQ(L"refs/heads/master", list[0]);
4251
4252         list.clear();
4253         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), true, true));
4254         ASSERT_EQ(1U, list.size());
4255         EXPECT_STREQ(L"refs/heads/master", list[0]);
4256
4257         list.clear();
4258         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), false, true));
4259         ASSERT_EQ(1U, list.size());
4260         EXPECT_STREQ(L"refs/heads/master", list[0]);
4261
4262         list.clear();
4263         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), true, true, CGit::BRANCH_REMOTE));
4264         EXPECT_TRUE(list.empty());
4265
4266         list.clear();
4267         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), false, true, CGit::BRANCH_ALL));
4268         ASSERT_EQ(1U, list.size());
4269         EXPECT_STREQ(L"refs/heads/master", list[0]);
4270
4271         list.clear();
4272         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), true, false));
4273         EXPECT_TRUE(list.empty());
4274
4275         list.clear();
4276         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), true, false));
4277         ASSERT_EQ(2U, list.size());
4278         EXPECT_STREQ(L"refs/tags/also-signed", list[0]);
4279         EXPECT_STREQ(L"refs/tags/normal-tag", list[1]);
4280
4281         list.clear();
4282         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"35c91b4ae2f77f4f21a7aba56d3c473c705d89e6"), true, true));
4283         ASSERT_EQ(3U, list.size());
4284         EXPECT_STREQ(L"refs/heads/master", list[0]);
4285         EXPECT_STREQ(L"refs/heads/master2", list[1]);
4286         EXPECT_STREQ(L"refs/tags/also-signed", list[2]);
4287
4288         list.clear();
4289         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"313a41bc88a527289c87d7531802ab484715974f"), false, true));
4290         ASSERT_EQ(6U, list.size());
4291         EXPECT_STREQ(L"refs/heads/forconflict", list[0]);
4292         EXPECT_STREQ(L"refs/heads/master", list[1]);
4293         EXPECT_STREQ(L"refs/heads/master2", list[2]);
4294         EXPECT_STREQ(L"refs/heads/signed-commit", list[3]);
4295         EXPECT_STREQ(L"refs/heads/simple-conflict", list[4]);
4296         EXPECT_STREQ(L"refs/heads/subdir/branch", list[5]);
4297
4298         list.clear();
4299         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"313a41bc88a527289c87d7531802ab484715974f"), false, true, CGit::BRANCH_REMOTE));
4300         ASSERT_EQ(1U, list.size());
4301         EXPECT_STREQ(L"refs/remotes/origin/master", list[0]);
4302
4303         list.clear();
4304         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"313a41bc88a527289c87d7531802ab484715974f"), false, true, CGit::BRANCH_LOCAL));
4305         ASSERT_EQ(6U, list.size());
4306         EXPECT_STREQ(L"refs/heads/forconflict", list[0]);
4307         EXPECT_STREQ(L"refs/heads/master", list[1]);
4308         EXPECT_STREQ(L"refs/heads/master2", list[2]);
4309         EXPECT_STREQ(L"refs/heads/signed-commit", list[3]);
4310         EXPECT_STREQ(L"refs/heads/simple-conflict", list[4]);
4311         EXPECT_STREQ(L"refs/heads/subdir/branch", list[5]);
4312
4313         list.clear();
4314         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"313a41bc88a527289c87d7531802ab484715974f"), false, true, CGit::BRANCH_ALL));
4315         ASSERT_EQ(7U, list.size());
4316         EXPECT_STREQ(L"refs/heads/forconflict", list[0]);
4317         EXPECT_STREQ(L"refs/remotes/origin/master", list[6]);
4318
4319         // test for symbolic refs
4320         CString adminDir;
4321         ASSERT_TRUE(GitAdminDir::GetAdminDirPath(g_Git.m_CurrentDir, adminDir));
4322         adminDir += L"refs\\remotes\\origin\\HEAD";
4323         ASSERT_TRUE(CStringUtils::WriteStringToTextFile(adminDir, L"ref: refs/remotes/origin/master"));
4324         list.clear();
4325         EXPECT_EQ(0, m_Git.GetRefsCommitIsOn(list, CGitHash::FromHexStr(L"313a41bc88a527289c87d7531802ab484715974f"), false, true, CGit::BRANCH_ALL));
4326         ASSERT_EQ(8U, list.size());
4327         EXPECT_STREQ(L"refs/heads/forconflict", list[0]);
4328         EXPECT_STREQ(L"refs/remotes/origin/HEAD", list[6]);
4329         EXPECT_STREQ(L"refs/remotes/origin/master", list[7]);
4330 }
4331
4332 TEST_P(CBasicGitWithTestRepoFixture, GetUnifiedDiff)
4333 {
4334         CString tmpfile = m_Dir.GetTempDir() + L"\\output.txt";
4335         EXPECT_EQ(0, m_Git.GetUnifiedDiff(CTGitPath(L""), L"b02add66f48814a73aa2f0876d6bbc8662d6a9a8", L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", tmpfile, false, false, -1, false));
4336         CString fileContents;
4337         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpfile, fileContents));
4338         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);
4339 }
4340
4341 static void GetGitNotes(CGit& m_Git, config testConfig)
4342 {
4343         if (testConfig != LIBGIT2_ALL)
4344                 return;
4345
4346         CString notes;
4347         EXPECT_EQ(0, m_Git.GetGitNotes(CGitHash::FromHexStr(L"1fc3c9688e27596d8717b54f2939dc951568f6cb"), notes));
4348         EXPECT_STREQ(L"A note here!\n", notes);
4349
4350         EXPECT_EQ(0, m_Git.GetGitNotes(CGitHash::FromHexStr(L"1ce788330fd3a306c8ad37654063ceee13a7f172"), notes));
4351         EXPECT_STREQ(L"", notes);
4352 }
4353
4354 TEST_P(CBasicGitWithTestRepoFixture, GetGitNotes)
4355 {
4356         GetGitNotes(m_Git, GetParam());
4357 }
4358
4359 TEST_P(CBasicGitWithTestRepoBareFixture, GetGitNotes)
4360 {
4361         GetGitNotes(m_Git, GetParam());
4362 }
4363
4364 TEST_P(CBasicGitWithTestRepoFixture, GuessRefForHash)
4365 {
4366         CString ref;
4367         // HEAD
4368         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash::FromHexStr(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6")));
4369         EXPECT_STREQ(L"master", ref);
4370
4371         // local branch
4372         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash::FromHexStr(L"10385764a4d42d7428bbeb245015f8f338fc1e40")));
4373         EXPECT_STREQ(L"forconflict", ref);
4374
4375         // stash
4376         EXPECT_EQ(1, m_Git.GuessRefForHash(ref, CGitHash::FromHexStr(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb")));
4377         EXPECT_STREQ(CString(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb").Left(m_Git.GetShortHASHLength()), ref);
4378
4379         // tag only
4380         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash::FromHexStr(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb")));
4381         EXPECT_STREQ(L"normal-tag", ref);
4382
4383         // local branch & tag
4384         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash::FromHexStr(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")));
4385         EXPECT_STREQ(L"master2", ref);
4386
4387         // remote branch
4388         EXPECT_EQ(0, m_Git.GuessRefForHash(ref, CGitHash::FromHexStr(L"a9d53b535cb49640a6099860ac4999f5a0857b91")));
4389         EXPECT_STREQ(L"origin/master", ref);
4390
4391         // no ref
4392         EXPECT_EQ(1, m_Git.GuessRefForHash(ref, CGitHash::FromHexStr(L"1ce788330fd3a306c8ad37654063ceee13a7f172")));
4393         EXPECT_STREQ(CString(L"1ce788330fd3a306c8ad37654063ceee13a7f172").Left(m_Git.GetShortHASHLength()), ref);
4394 }
4395
4396 TEST_P(CBasicGitWithTestRepoFixture, IsResultingCommitBecomeEmpty)
4397 {
4398         // all files are missing, thus we resulting commit won't be empty
4399         EXPECT_EQ(FALSE, m_Git.IsResultingCommitBecomeEmpty());
4400         EXPECT_EQ(FALSE, m_Git.IsResultingCommitBecomeEmpty(true));
4401
4402         CString output;
4403         EXPECT_EQ(0, m_Git.Run(L"git.exe reset --hard master", &output, CP_UTF8));
4404         EXPECT_STRNE(L"", output);
4405
4406         // now we have no staged stuff
4407         EXPECT_EQ(TRUE, m_Git.IsResultingCommitBecomeEmpty());
4408         EXPECT_EQ(FALSE, m_Git.IsResultingCommitBecomeEmpty(true));
4409
4410         output.Empty();
4411         EXPECT_EQ(0, m_Git.Run(L"git.exe commit --allow-empty -m \"Add test.txt\"", &output, CP_UTF8));
4412         EXPECT_STRNE(L"", output);
4413
4414         // empty commit and no staged files
4415         EXPECT_EQ(TRUE, m_Git.IsResultingCommitBecomeEmpty());
4416         EXPECT_EQ(TRUE, m_Git.IsResultingCommitBecomeEmpty(true));
4417
4418         // create a file and stage it, thus, resulting commits won't be empty
4419         CString testFile = m_Dir.GetTempDir() + L"\\test.txt";
4420         EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"this is testing file."));
4421         EXPECT_EQ(TRUE, m_Git.IsResultingCommitBecomeEmpty());
4422         EXPECT_EQ(TRUE, m_Git.IsResultingCommitBecomeEmpty(true));
4423         output.Empty();
4424         EXPECT_EQ(0, m_Git.Run(L"git.exe add test.txt", &output, CP_UTF8));
4425         EXPECT_STREQ(L"", output);
4426
4427         EXPECT_EQ(FALSE, m_Git.IsResultingCommitBecomeEmpty());
4428         EXPECT_EQ(FALSE, m_Git.IsResultingCommitBecomeEmpty(true));
4429 }
4430
4431 TEST(CGit, ParseConflictHashesFromLsFile_Empty)
4432 {
4433         CGitByteArray byteArray;
4434         bool baseIsFile = true, localIsFile = true, remoteIsFile = true;
4435         CGitHash baseHash, localHash, remoteHash;
4436         EXPECT_NE(0, CGit::ParseConflictHashesFromLsFile(byteArray, baseHash, baseIsFile, localHash, localIsFile, remoteHash, remoteIsFile));
4437 }
4438
4439 TEST(CGit, ParseConflictHashesFromLsFile_SimpleConflict)
4440 {
4441         constexpr char git_ls_file_u_t_z_output[] = { "M 100644 1f9f46da1ee155aa765d6e379d9d19853358cb07 1      bla.txt\0M 100644 3aa011e7d3609ab9af90c4b10f616312d2be422f 2    bla.txt\0M 100644 56d252d69d535834b9fbfa6f6a633ecd505ea2e6 3    bla.txt" };
4442         CGitByteArray byteArray;
4443         byteArray.append(git_ls_file_u_t_z_output, sizeof(git_ls_file_u_t_z_output));
4444         bool baseIsFile = true, localIsFile = true, remoteIsFile = true;
4445         CGitHash baseHash, localHash, remoteHash;
4446         EXPECT_EQ(0, CGit::ParseConflictHashesFromLsFile(byteArray, baseHash, baseIsFile, localHash, localIsFile, remoteHash, remoteIsFile));
4447         EXPECT_STREQ(L"1f9f46da1ee155aa765d6e379d9d19853358cb07", baseHash.ToString());
4448         EXPECT_TRUE(baseIsFile);
4449         EXPECT_STREQ(L"3aa011e7d3609ab9af90c4b10f616312d2be422f", localHash.ToString());
4450         EXPECT_TRUE(localIsFile);
4451         EXPECT_STREQ(L"56d252d69d535834b9fbfa6f6a633ecd505ea2e6", remoteHash.ToString());
4452         EXPECT_TRUE(remoteIsFile);
4453 }
4454
4455 TEST(CGit, ParseConflictHashesFromLsFile_SubmoduleConflict_Simple)
4456 {
4457         constexpr char git_ls_files_u_t_z_output[] = { "M 160000 46a2b8e855d5f6d8b60b81500a9f6779c7f63e63 1     libgit2\0M 160000 533da4ea00703f4ad6d5518e1ce81d20261c40c0 2    libgit2\0M 160000 ab2af775ec467ebb328a7374653f247920f258f3 3    libgit2" };
4458         CGitByteArray byteArray;
4459         byteArray.append(git_ls_files_u_t_z_output, sizeof(git_ls_files_u_t_z_output));
4460         bool baseIsFile = true, localIsFile = true, remoteIsFile = true;
4461         CGitHash baseHash, localHash, remoteHash;
4462         EXPECT_EQ(0, CGit::ParseConflictHashesFromLsFile(byteArray, baseHash, baseIsFile, localHash, localIsFile, remoteHash, remoteIsFile));
4463         EXPECT_STREQ(L"46a2b8e855d5f6d8b60b81500a9f6779c7f63e63", baseHash.ToString());
4464         EXPECT_FALSE(baseIsFile);
4465         EXPECT_STREQ(L"533da4ea00703f4ad6d5518e1ce81d20261c40c0", localHash.ToString());
4466         EXPECT_FALSE(localIsFile);
4467         EXPECT_STREQ(L"ab2af775ec467ebb328a7374653f247920f258f3", remoteHash.ToString());
4468         EXPECT_FALSE(remoteIsFile);
4469 }
4470
4471 TEST(CGit, ParseConflictHashesFromLsFile_SubmoduleConflict_DeletedModified)
4472 {
4473         // merged commit where submodule was modified into commit where it was deleted (git status says "deleted by us: libgit2")
4474         constexpr char git_ls_files_u_t_z_output[] = { "M 160000 46a2b8e855d5f6d8b60b81500a9f6779c7f63e63 1     libgit2\0M 160000 ab2af775ec467ebb328a7374653f247920f258f3 3    libgit2" };
4475         CGitByteArray byteArray;
4476         byteArray.append(git_ls_files_u_t_z_output, sizeof(git_ls_files_u_t_z_output));
4477         bool baseIsFile = true, localIsFile = true, remoteIsFile = true;
4478         CGitHash baseHash, localHash, remoteHash;
4479         EXPECT_EQ(0, CGit::ParseConflictHashesFromLsFile(byteArray, baseHash, baseIsFile, localHash, localIsFile, remoteHash, remoteIsFile));
4480         EXPECT_STREQ(L"46a2b8e855d5f6d8b60b81500a9f6779c7f63e63", baseHash.ToString());
4481         EXPECT_FALSE(baseIsFile);
4482         EXPECT_STREQ(L"0000000000000000000000000000000000000000", localHash.ToString());
4483         EXPECT_TRUE(localIsFile);
4484         EXPECT_STREQ(L"ab2af775ec467ebb328a7374653f247920f258f3", remoteHash.ToString());
4485         EXPECT_FALSE(remoteIsFile);
4486 }
4487
4488 TEST(CGit, ParseConflictHashesFromLsFile_SubmoduleConflict_ToNormalDir)
4489 {
4490         // merged commit where libgit2 is a normal folder (git status says "added by us: libgit2" and "new file: libgit2/Neues Textdokument.txt")
4491         constexpr char git_ls_files_u_t_z_output[] = { "M 160000 533da4ea00703f4ad6d5518e1ce81d20261c40c0 2     libgit2" };
4492         CGitByteArray byteArray;
4493         byteArray.append(git_ls_files_u_t_z_output, sizeof(git_ls_files_u_t_z_output));
4494         bool baseIsFile = true, localIsFile = true, remoteIsFile = true;
4495         CGitHash baseHash, localHash, remoteHash;
4496         EXPECT_EQ(0, CGit::ParseConflictHashesFromLsFile(byteArray, baseHash, baseIsFile, localHash, localIsFile, remoteHash, remoteIsFile));
4497         EXPECT_STREQ(L"0000000000000000000000000000000000000000", baseHash.ToString());
4498         EXPECT_TRUE(baseIsFile);
4499         EXPECT_STREQ(L"533da4ea00703f4ad6d5518e1ce81d20261c40c0", localHash.ToString());
4500         EXPECT_FALSE(localIsFile);
4501         EXPECT_STREQ(L"0000000000000000000000000000000000000000", remoteHash.ToString());
4502         EXPECT_TRUE(remoteIsFile);
4503 }
4504
4505 TEST(CGit, ParseConflictHashesFromLsFile_SubmoduleConflict_FileSubmodule)
4506 {
4507         // merged commit where a file with the same name was created (git status says "both added: libgit2")
4508         constexpr char git_ls_file_u_t_z_output[] = { "M 160000 533da4ea00703f4ad6d5518e1ce81d20261c40c0 2      libgit2\0M 100644 9ae3e601584cc03f8f03f93761416b6599ac7c0d 3    libgit2" };
4509         CGitByteArray byteArray;
4510         byteArray.append(git_ls_file_u_t_z_output, sizeof(git_ls_file_u_t_z_output));
4511         bool baseIsFile = true, localIsFile = true, remoteIsFile = true;
4512         CGitHash baseHash, localHash, remoteHash;
4513         EXPECT_EQ(0, CGit::ParseConflictHashesFromLsFile(byteArray, baseHash, baseIsFile, localHash, localIsFile, remoteHash, remoteIsFile));
4514         EXPECT_STREQ(L"0000000000000000000000000000000000000000", baseHash.ToString());
4515         EXPECT_TRUE(baseIsFile);
4516         EXPECT_STREQ(L"533da4ea00703f4ad6d5518e1ce81d20261c40c0", localHash.ToString());
4517         EXPECT_FALSE(localIsFile);
4518         EXPECT_STREQ(L"9ae3e601584cc03f8f03f93761416b6599ac7c0d", remoteHash.ToString());
4519         EXPECT_TRUE(remoteIsFile);
4520 }
4521
4522 TEST(CGit, ParseConflictHashesFromLsFile_DeletedFileConflict)
4523 {
4524         // file added, modified on branch A, deleted on branch B, merge branch A on B (git status says: "deleted by us")
4525         constexpr char git_ls_file_u_t_z_output[] = { "M 100644 24091f0add7afc47ac7cdc80ae4d3866b2ef588c 1      Neues Textdokument.txt\0M 100644 293b6f6293106b6ebb5d54ad482d7561b0f1c9ae 3     Neues Textdokument.txt" };
4526         CGitByteArray byteArray;
4527         byteArray.append(git_ls_file_u_t_z_output, sizeof(git_ls_file_u_t_z_output));
4528         bool baseIsFile = true, localIsFile = true, remoteIsFile = true;
4529         CGitHash baseHash, localHash, remoteHash;
4530         EXPECT_EQ(0, CGit::ParseConflictHashesFromLsFile(byteArray, baseHash, baseIsFile, localHash, localIsFile, remoteHash, remoteIsFile));
4531         EXPECT_STREQ(L"24091f0add7afc47ac7cdc80ae4d3866b2ef588c", baseHash.ToString());
4532         EXPECT_TRUE(baseIsFile);
4533         EXPECT_STREQ(L"0000000000000000000000000000000000000000", localHash.ToString());
4534         EXPECT_TRUE(localIsFile);
4535         EXPECT_STREQ(L"293b6f6293106b6ebb5d54ad482d7561b0f1c9ae", remoteHash.ToString());
4536         EXPECT_TRUE(remoteIsFile);
4537 }
4538
4539 TEST(CGit, ParseConflictHashesFromLsFile_Invalid)
4540 {
4541         constexpr char git_ls_file_u_t_z_output[] = { "M 160000 533da4ea00703f4ad6d5518e1ce81d20261c40c0 2      libgit2\0M 100644 9ae3e601584cc03f8f03f93761416b6599ac7c0d 3    libgit2" };
4542         for (int i = 1; i < sizeof(git_ls_file_u_t_z_output); ++i)
4543         {
4544                 if (i == 60)
4545                         continue;
4546                 CGitByteArray byteArray;
4547                 byteArray.append(git_ls_file_u_t_z_output, i);
4548                 bool baseIsFile = true, localIsFile = true, remoteIsFile = true;
4549                 CGitHash baseHash, localHash, remoteHash;
4550                 EXPECT_EQ(-1, CGit::ParseConflictHashesFromLsFile(byteArray, baseHash, baseIsFile, localHash, localIsFile, remoteHash, remoteIsFile));
4551         }
4552 }