test/UnitTests/GitTest.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2015-2016 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19
  20 #include "stdafx.h"
  21 #include "Git.h"
  22 #include "StringUtils.h"
  23 #include "RepositoryFixtures.h"
  24
  25 // For performance reason, turn LIBGIT off by default,
  26 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitFixture, testing::Values(GIT_CLI, /*LIBGIT,*/ LIBGIT2, LIBGIT2_ALL));
  27 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitWithEmptyRepositoryFixture, testing::Values(GIT_CLI, /*LIBGIT,*/ LIBGIT2, LIBGIT2_ALL));
  28 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitWithEmptyBareRepositoryFixture, testing::Values(GIT_CLI, /*LIBGIT,*/ LIBGIT2, LIBGIT2_ALL));
  29 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitWithTestRepoFixture, testing::Values(GIT_CLI, LIBGIT, LIBGIT2, LIBGIT2_ALL));
  30 INSTANTIATE_TEST_CASE_P(CGit, CBasicGitWithTestRepoBareFixture, testing::Values(GIT_CLI, LIBGIT, LIBGIT2, LIBGIT2_ALL));
  31
  32 TEST(CGit, RunSet)
  33 {
  34         CString output;
  35         CGit cgit;
  36         ASSERT_EQ(0, cgit.Run(_T("cmd /c set"), &output, CP_UTF8));
  37         ASSERT_FALSE(output.IsEmpty());
  38         ASSERT_TRUE(output.Find(_T("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(_T("git --version"), &output, CP_UTF8));
  46         ASSERT_FALSE(output.IsEmpty());
  47 }
  48
  49 TEST(CGit, RunGit_BashPipe)
  50 {
  51         CString tmpfile = GetTempFile();
  52         tmpfile.Replace(L"\\", L"/");
  53         ASSERT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)tmpfile, L"testing piping..."));
  54         SCOPE_EXIT{ ::DeleteFile(tmpfile); };
  55         CString pipefile = GetTempFile();
  56         pipefile.Replace(L"\\", L"/");
  57         CString pipecmd;
  58         pipecmd.Format(L"cat < %s", (LPCTSTR)tmpfile);
  59         ASSERT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)pipefile, (LPCTSTR)pipecmd));
  60         SCOPE_EXIT{ ::DeleteFile(pipefile); };
  61         CString output;
  62         CGit cgit;
  63         ASSERT_EQ(0, cgit.Run(L"bash.exe " + pipefile, &output, CP_UTF8));
  64         ASSERT_STREQ(L"testing piping...", output);
  65 }
  66
  67 TEST(CGit, RunGit_Error)
  68 {
  69         CAutoTempDir tempdir;
  70         CGit cgit;
  71         cgit.m_CurrentDir = tempdir.GetTempDir();
  72
  73         CString output;
  74         EXPECT_NE(0, cgit.Run(_T("git-not-found.exe"), &output, CP_UTF8)); // Git for Windows returns 2, cygwin-hack returns 127
  75         //EXPECT_TRUE(output.IsEmpty()); with cygwin-hack we get an error message from sh.exe
  76
  77         output.Empty();
  78         EXPECT_EQ(128, cgit.Run(_T("git.exe add file.txt"), &output, CP_UTF8));
  79         EXPECT_TRUE(output.Find(_T("fatal: Not a git repository (or any")) == 0);
  80 }
  81
  82 TEST_P(CBasicGitWithTestRepoBareFixture, RunGit_AbsolutePath)
  83 {
  84         CAutoTempDir tempdir;
  85
  86         CString output;
  87         EXPECT_EQ(0, m_Git.Run(_T("git archive -o ") + tempdir.GetTempDir() + _T("\\export.zip HEAD"), &output, CP_UTF8));
  88         EXPECT_TRUE(output.IsEmpty());
  89
  90         EXPECT_TRUE(PathFileExists(tempdir.GetTempDir() + _T("\\export.zip")));
  91 }
  92
  93 TEST(CGit, StringAppend)
  94 {
  95         CGit::StringAppend(nullptr, nullptr); // string may be null
  96         CString string = _T("something");
  97         CGit::StringAppend(&string, nullptr, CP_UTF8, 0);
  98         EXPECT_STREQ(_T("something"), string);
  99         const BYTE somebytes[1] = { 0 };
 100         CGit::StringAppend(&string, somebytes, CP_UTF8, 0);
 101         EXPECT_STREQ(_T("something"), string);
 102         CGit::StringAppend(&string, somebytes);
 103         EXPECT_STREQ(_T("something"), string);
 104         const BYTE moreBytesUTFEight[] = { 0x68, 0x65, 0x6C, 0x6C, 0xC3, 0xB6, 0x0A, 0x00 };
 105         CGit::StringAppend(&string, moreBytesUTFEight, CP_UTF8, 3);
 106         EXPECT_STREQ(_T("somethinghel"), string);
 107         CGit::StringAppend(&string, moreBytesUTFEight + 3, CP_ACP, 1);
 108         EXPECT_STREQ(_T("somethinghell"), string);
 109         CGit::StringAppend(&string, moreBytesUTFEight);
 110         EXPECT_STREQ(_T("somethinghellhellö\n"), string);
 111         CGit::StringAppend(&string, moreBytesUTFEight, CP_UTF8, sizeof(moreBytesUTFEight));
 112         EXPECT_STREQ(_T("somethinghellhellö\nhellö\n\0"), string);
 113         CGit::StringAppend(&string, moreBytesUTFEight, CP_UTF8, 3);
 114         EXPECT_STREQ(_T("somethinghellhellö\nhellö\n\0hel"), string);
 115 }
 116
 117 TEST(CGit, GetFileModifyTime)
 118 {
 119         __int64 time = -1;
 120         bool isDir = false;
 121         __int64 size = -1;
 122         EXPECT_EQ(-1, CGit::GetFileModifyTime(L"does-not-exist.txt", &time, &isDir, &size));
 123
 124         time = -1;
 125         isDir = false;
 126         size = -1;
 127         EXPECT_EQ(0, CGit::GetFileModifyTime(L"c:\\Windows", &time, &isDir, &size));
 128         EXPECT_TRUE(isDir);
 129
 130         time = -1;
 131         isDir = false;
 132         size = -1;
 133         EXPECT_EQ(0, CGit::GetFileModifyTime(L"c:\\Windows\\", &time, &isDir, &size));
 134         EXPECT_TRUE(isDir);
 135
 136         CAutoTempDir tempdir;
 137         CString testFile = tempdir.GetTempDir() + L"\\test.txt";
 138         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is testing fileöäü."));
 139
 140         time = -1;
 141         EXPECT_EQ(0, CGit::GetFileModifyTime(testFile, &time));
 142         EXPECT_NE(-1, time);
 143
 144         __int64 time2 = -1;
 145         isDir = false;
 146         size = -1;
 147         ULONGLONG ticks = GetTickCount64();
 148         EXPECT_EQ(0, CGit::GetFileModifyTime(testFile, &time2, &isDir, &size));
 149         EXPECT_EQ(time, time2);
 150         EXPECT_FALSE(isDir);
 151         EXPECT_EQ(27, size);
 152
 153         Sleep(1200);
 154         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is testing fileöü."));
 155         __int64 time3 = -1;
 156         isDir = false;
 157         size = -1;
 158         EXPECT_EQ(0, CGit::GetFileModifyTime(testFile, &time3, &isDir, &size));
 159         EXPECT_NE(-1, time3);
 160         EXPECT_FALSE(isDir);
 161         EXPECT_EQ(25, size);
 162         EXPECT_TRUE(time3 >= time);
 163         EXPECT_TRUE(time3 - time <= 1 + (__int64)(GetTickCount64() - ticks) / 1000);
 164 }
 165
 166 TEST(CGit, LoadTextFile)
 167 {
 168         CAutoTempDir tempdir;
 169
 170         CString msg = L"something--";
 171         EXPECT_FALSE(CGit::LoadTextFile(L"does-not-exist.txt", msg));
 172         EXPECT_STREQ(L"something--", msg);
 173
 174         CString testFile = tempdir.GetTempDir() + L"\\test.txt";
 175         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is testing fileöäü."));
 176         EXPECT_TRUE(CGit::LoadTextFile(testFile, msg));
 177         EXPECT_STREQ(L"something--this is testing fileöäü.\n", msg);
 178
 179         msg.Empty();
 180         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is testing\nfileöäü."));
 181         EXPECT_TRUE(CGit::LoadTextFile(testFile, msg));
 182         EXPECT_STREQ(L"this is testing\nfileöäü.\n", msg);
 183
 184         msg.Empty();
 185         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is\r\ntesting\nfileöäü.\r\n\r\n"));
 186         EXPECT_TRUE(CGit::LoadTextFile(testFile, msg));
 187         EXPECT_STREQ(L"this is\ntesting\nfileöäü.\n", msg);
 188 }
 189
 190 TEST(CGit, IsBranchNameValid)
 191 {
 192         CGit cgit;
 193         EXPECT_TRUE(cgit.IsBranchNameValid(_T("master")));
 194         EXPECT_TRUE(cgit.IsBranchNameValid(_T("def/master")));
 195         EXPECT_FALSE(cgit.IsBranchNameValid(_T("-test")));
 196         EXPECT_FALSE(cgit.IsBranchNameValid(_T("jfjf>ff")));
 197         EXPECT_FALSE(cgit.IsBranchNameValid(_T("jf ff")));
 198         EXPECT_FALSE(cgit.IsBranchNameValid(_T("jf~ff")));
 199 }
 200
 201 TEST(CGit, StripRefName)
 202 {
 203         EXPECT_STREQ(_T("abc"), CGit::StripRefName(_T("abc")));
 204         EXPECT_STREQ(_T("bcd"), CGit::StripRefName(_T("refs/bcd")));
 205         EXPECT_STREQ(_T("cde"), CGit::StripRefName(_T("refs/heads/cde")));
 206 }
 207
 208 TEST(CGit, CombinePath)
 209 {
 210         CGit cgit;
 211         cgit.m_CurrentDir = _T("c:\\something");
 212         EXPECT_STREQ(_T("c:\\something"), cgit.CombinePath(_T("")));
 213         EXPECT_STREQ(_T("c:\\something\\file.txt"), cgit.CombinePath(_T("file.txt")));
 214         EXPECT_STREQ(_T("c:\\something\\sub\\file.txt"), cgit.CombinePath(_T("sub\\file.txt")));
 215         EXPECT_STREQ(_T("c:\\something\\subdir\\file2.txt"), cgit.CombinePath(CTGitPath(_T("subdir/file2.txt"))));
 216 }
 217
 218 TEST(CGit, GetShortName)
 219 {
 220         CGit::REF_TYPE type = CGit::UNKNOWN;
 221         EXPECT_STREQ(_T("master"), CGit::GetShortName(_T("refs/heads/master"), &type));
 222         EXPECT_EQ(CGit::LOCAL_BRANCH, type);
 223
 224         type = CGit::UNKNOWN;
 225         EXPECT_STREQ(_T("somedir/mastr"), CGit::GetShortName(_T("refs/heads/somedir/mastr"), &type));
 226         EXPECT_EQ(CGit::LOCAL_BRANCH, type);
 227
 228         type = CGit::BISECT_BAD; // do not use UNKNOWN here to make sure it gets set
 229         EXPECT_STREQ(_T("svn/something"), CGit::GetShortName(_T("refs/svn/something"), &type));
 230         EXPECT_EQ(CGit::UNKNOWN, type);
 231
 232         type = CGit::UNKNOWN;
 233         EXPECT_STREQ(_T("origin/master"), CGit::GetShortName(_T("refs/remotes/origin/master"), &type));
 234         EXPECT_EQ(CGit::REMOTE_BRANCH, type);
 235
 236         type = CGit::UNKNOWN;
 237         EXPECT_STREQ(_T("origin/sub/master"), CGit::GetShortName(_T("refs/remotes/origin/sub/master"), &type));
 238         EXPECT_EQ(CGit::REMOTE_BRANCH, type);
 239
 240         type = CGit::UNKNOWN;
 241         EXPECT_STREQ(_T("release1"), CGit::GetShortName(_T("refs/tags/release1"), &type));
 242         EXPECT_EQ(CGit::TAG, type);
 243
 244         type = CGit::UNKNOWN;
 245         EXPECT_STREQ(_T("releases/v1"), CGit::GetShortName(_T("refs/tags/releases/v1"), &type));
 246         EXPECT_EQ(CGit::TAG, type);
 247
 248         type = CGit::UNKNOWN;
 249         EXPECT_STREQ(_T("release2"), CGit::GetShortName(_T("refs/tags/release2^{}"), &type));
 250         EXPECT_EQ(CGit::ANNOTATED_TAG, type);
 251
 252         type = CGit::UNKNOWN;
 253         EXPECT_STREQ(_T("releases/v2"), CGit::GetShortName(_T("refs/tags/releases/v2^{}"), &type));
 254         EXPECT_EQ(CGit::ANNOTATED_TAG, type);
 255
 256         type = CGit::UNKNOWN;
 257         EXPECT_STREQ(_T("stash"), CGit::GetShortName(_T("refs/stash"), &type));
 258         EXPECT_EQ(CGit::STASH, type);
 259
 260         type = CGit::BISECT_BAD; // do not use UNKNOWN here to make sure it gets set
 261         EXPECT_STREQ(_T("something"), CGit::GetShortName(_T("refs/something"), &type));
 262         EXPECT_EQ(CGit::UNKNOWN, type);
 263
 264         type = CGit::BISECT_BAD; // do not use UNKNOWN here to make sure it gets set
 265         EXPECT_STREQ(_T("sth"), CGit::GetShortName(_T("sth"), &type));
 266         EXPECT_EQ(CGit::UNKNOWN, type);
 267
 268         type = CGit::UNKNOWN;
 269         EXPECT_STREQ(_T("good"), CGit::GetShortName(_T("refs/bisect/good"), &type));
 270         EXPECT_EQ(CGit::BISECT_GOOD, type);
 271
 272         type = CGit::UNKNOWN;
 273         EXPECT_STREQ(_T("good"), CGit::GetShortName(_T("refs/bisect/good-5809ac97a1115a8380b1d6bb304b62cd0b0fa9bb"), &type));
 274         EXPECT_EQ(CGit::BISECT_GOOD, type);
 275
 276         type = CGit::UNKNOWN;
 277         EXPECT_STREQ(_T("bad"), CGit::GetShortName(_T("refs/bisect/bad"), &type));
 278         EXPECT_EQ(CGit::BISECT_BAD, type);
 279
 280         type = CGit::UNKNOWN;
 281         EXPECT_STREQ(_T("bad"), CGit::GetShortName(_T("refs/bisect/bad-5809ac97a1115a8380b1d6bb304b62cd0b0fd9bb"), &type));
 282         EXPECT_EQ(CGit::BISECT_BAD, type);
 283
 284         type = CGit::UNKNOWN;
 285         EXPECT_STREQ(_T("ab"), CGit::GetShortName(_T("refs/notes/ab"), &type));
 286         EXPECT_EQ(CGit::NOTES, type);
 287
 288         type = CGit::UNKNOWN;
 289         EXPECT_STREQ(_T("a/b"), CGit::GetShortName(_T("refs/notes/a/b"), &type));
 290         EXPECT_EQ(CGit::NOTES, type);
 291 }
 292
 293 TEST(CGit, GetRepository)
 294 {
 295         CAutoTempDir tempdir;
 296         CGit cgit;
 297         cgit.m_CurrentDir = tempdir.GetTempDir();
 298
 299         CAutoRepository repo = cgit.GetGitRepository();
 300         EXPECT_FALSE(repo.IsValid());
 301
 302         cgit.m_CurrentDir = tempdir.GetTempDir() + _T("\\aöäüb");
 303         ASSERT_TRUE(CreateDirectory(cgit.m_CurrentDir, nullptr));
 304
 305         CString output;
 306         EXPECT_EQ(0, cgit.Run(_T("git.exe init"), &output, CP_UTF8));
 307         EXPECT_FALSE(output.IsEmpty());
 308
 309         CAutoRepository repo2 = cgit.GetGitRepository(); // this tests GetGitRepository as well as m_Git.GetGitPathStringA
 310         EXPECT_TRUE(repo2.IsValid());
 311
 312         cgit.m_CurrentDir = tempdir.GetTempDir() + _T("\\aöäüb.git");
 313         ASSERT_TRUE(CreateDirectory(cgit.m_CurrentDir, nullptr));
 314
 315         output.Empty();
 316         EXPECT_EQ(0, cgit.Run(_T("git.exe init --bare"), &output, CP_UTF8));
 317         EXPECT_FALSE(output.IsEmpty());
 318
 319         CAutoRepository repo3 = cgit.GetGitRepository(); // this tests GetGitRepository as well as m_Git.GetGitPathStringA
 320         EXPECT_TRUE(repo3.IsValid());
 321 }
 322
 323 TEST_P(CBasicGitWithEmptyRepositoryFixture, IsInitRepos_GetInitAddList)
 324 {
 325         EXPECT_STREQ(_T("master"), m_Git.GetCurrentBranch());
 326
 327         CString output;
 328         CString testFile = m_Dir.GetTempDir() + L"\\test.txt";
 329
 330         CTGitPathList addedFiles;
 331
 332         EXPECT_TRUE(m_Git.IsInitRepos());
 333         EXPECT_EQ(0, m_Git.GetInitAddList(addedFiles));
 334         EXPECT_TRUE(addedFiles.IsEmpty());
 335
 336         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is testing file."));
 337         EXPECT_EQ(0, m_Git.GetInitAddList(addedFiles));
 338         EXPECT_TRUE(addedFiles.IsEmpty());
 339         EXPECT_EQ(0, m_Git.Run(_T("git.exe add test.txt"), &output, CP_UTF8));
 340         EXPECT_TRUE(output.IsEmpty());
 341         EXPECT_EQ(0, m_Git.GetInitAddList(addedFiles));
 342         ASSERT_EQ(1, addedFiles.GetCount());
 343         EXPECT_STREQ(_T("test.txt"), addedFiles[0].GetGitPathString());
 344
 345         output.Empty();
 346         EXPECT_EQ(0, m_Git.Run(_T("git.exe commit -m \"Add test.txt\""), &output, CP_UTF8));
 347         EXPECT_FALSE(output.IsEmpty());
 348
 349         EXPECT_FALSE(m_Git.IsInitRepos());
 350
 351         EXPECT_STREQ(_T("master"), m_Git.GetCurrentBranch());
 352 }
 353
 354 TEST_P(CBasicGitWithTestRepoFixture, IsInitRepos)
 355 {
 356         EXPECT_FALSE(m_Git.IsInitRepos());
 357
 358         CString output;
 359         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout --orphan orphanic"), &output, CP_UTF8));
 360         EXPECT_FALSE(output.IsEmpty());
 361
 362         EXPECT_TRUE(m_Git.IsInitRepos());
 363 }
 364
 365 TEST_P(CBasicGitWithTestRepoFixture, HasWorkingTreeConflicts)
 366 {
 367         CString output;
 368         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
 369         EXPECT_FALSE(output.IsEmpty());
 370
 371         EXPECT_EQ(FALSE, m_Git.HasWorkingTreeConflicts());
 372
 373         output.Empty();
 374         EXPECT_EQ(0, m_Git.Run(_T("git.exe merge forconflict"), &output, CP_UTF8));
 375         EXPECT_FALSE(output.IsEmpty());
 376         EXPECT_EQ(FALSE, m_Git.HasWorkingTreeConflicts());
 377
 378         output.Empty();
 379         EXPECT_EQ(1, m_Git.Run(_T("git.exe merge simple-conflict"), &output, CP_UTF8));
 380         EXPECT_FALSE(output.IsEmpty());
 381         EXPECT_EQ(TRUE, m_Git.HasWorkingTreeConflicts());
 382
 383         output.Empty();
 384         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
 385         EXPECT_FALSE(output.IsEmpty());
 386
 387         output.Empty();
 388         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout forconflict"), &output, CP_UTF8));
 389         EXPECT_FALSE(output.IsEmpty());
 390
 391         output.Empty();
 392         EXPECT_EQ(1, m_Git.Run(_T("git.exe merge simple-conflict"), &output, CP_UTF8));
 393         EXPECT_FALSE(output.IsEmpty());
 394         EXPECT_EQ(TRUE, m_Git.HasWorkingTreeConflicts());
 395 }
 396
 397 TEST_P(CBasicGitWithTestRepoFixture, GetCurrentBranch)
 398 {
 399         EXPECT_STREQ(_T("master"), m_Git.GetCurrentBranch());
 400         EXPECT_STREQ(_T("master"), m_Git.GetCurrentBranch(true));
 401
 402         CString output;
 403         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout simple-conflict"), &output, CP_UTF8));
 404         EXPECT_STREQ(_T("simple-conflict"), m_Git.GetCurrentBranch());
 405         EXPECT_STREQ(_T("simple-conflict"), m_Git.GetCurrentBranch(true));
 406
 407         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout subdir/branch"), &output, CP_UTF8));
 408         EXPECT_STREQ(_T("subdir/branch"), m_Git.GetCurrentBranch());
 409         EXPECT_STREQ(_T("subdir/branch"), m_Git.GetCurrentBranch(true));
 410
 411         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout 560deea87853158b22d0c0fd73f60a458d47838a"), &output, CP_UTF8));
 412         EXPECT_STREQ(_T("(no branch)"), m_Git.GetCurrentBranch());
 413         EXPECT_STREQ(_T("560deea87853158b22d0c0fd73f60a458d47838a"), m_Git.GetCurrentBranch(true));
 414
 415         output.Empty();
 416         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout --orphan orphanic"), &output, CP_UTF8));
 417         EXPECT_FALSE(output.IsEmpty());
 418
 419         EXPECT_STREQ(_T("orphanic"), m_Git.GetCurrentBranch());
 420         EXPECT_STREQ(_T("orphanic"), m_Git.GetCurrentBranch(true));
 421 }
 422
 423 TEST_P(CBasicGitWithTestRepoBareFixture, GetCurrentBranch)
 424 {
 425         EXPECT_STREQ(_T("master"), m_Git.GetCurrentBranch());
 426         EXPECT_STREQ(_T("master"), m_Git.GetCurrentBranch(true));
 427 }
 428
 429 static void BranchTagExists_IsBranchTagNameUnique(CGit& m_Git)
 430 {
 431         EXPECT_TRUE(m_Git.BranchTagExists(_T("master"), true));
 432         EXPECT_FALSE(m_Git.BranchTagExists(_T("origin/master"), true));
 433         EXPECT_FALSE(m_Git.BranchTagExists(_T("normal-tag"), true));
 434         EXPECT_FALSE(m_Git.BranchTagExists(_T("also-signed"), true));
 435         EXPECT_FALSE(m_Git.BranchTagExists(_T("wuseldusel"), true));
 436
 437         EXPECT_FALSE(m_Git.BranchTagExists(_T("master"), false));
 438         EXPECT_TRUE(m_Git.BranchTagExists(_T("normal-tag"), false));
 439         EXPECT_TRUE(m_Git.BranchTagExists(_T("also-signed"), false));
 440         EXPECT_FALSE(m_Git.BranchTagExists(_T("wuseldusel"), false));
 441
 442         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(_T("master")));
 443         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(_T("simpleconflict")));
 444         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(_T("normal-tag")));
 445         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(_T("also-signed")));
 446         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(_T("origin/master")));
 447
 448         CString output;
 449         EXPECT_EQ(0, m_Git.Run(_T("git.exe tag master HEAD~2"), &output, CP_UTF8));
 450         EXPECT_TRUE(output.IsEmpty());
 451
 452         EXPECT_EQ(0, m_Git.Run(_T("git.exe branch normal-tag HEAD~2"), &output, CP_UTF8));
 453         EXPECT_TRUE(output.IsEmpty());
 454
 455         EXPECT_FALSE(m_Git.IsBranchTagNameUnique(_T("master")));
 456         EXPECT_FALSE(m_Git.IsBranchTagNameUnique(_T("normal-tag")));
 457         EXPECT_TRUE(m_Git.IsBranchTagNameUnique(_T("also-signed")));
 458 }
 459
 460 TEST_P(CBasicGitWithTestRepoFixture, BranchTagExists_IsBranchTagNameUnique)
 461 {
 462         BranchTagExists_IsBranchTagNameUnique(m_Git);
 463 }
 464
 465 TEST_P(CBasicGitWithTestRepoBareFixture, BranchTagExists_IsBranchTagNameUnique)
 466 {
 467         BranchTagExists_IsBranchTagNameUnique(m_Git);
 468 }
 469
 470 static void GetFullRefName(CGit& m_Git)
 471 {
 472         EXPECT_STREQ(_T(""), m_Git.GetFullRefName(_T("does_not_exist")));
 473         EXPECT_STREQ(_T("refs/heads/master"), m_Git.GetFullRefName(_T("master")));
 474         EXPECT_STREQ(_T("refs/remotes/origin/master"), m_Git.GetFullRefName(_T("origin/master")));
 475         EXPECT_STREQ(_T("refs/tags/normal-tag"), m_Git.GetFullRefName(_T("normal-tag")));
 476         EXPECT_STREQ(_T("refs/tags/also-signed"), m_Git.GetFullRefName(_T("also-signed")));
 477
 478         CString output;
 479         EXPECT_EQ(0, m_Git.Run(_T("git.exe tag master HEAD~2"), &output, CP_UTF8));
 480         EXPECT_TRUE(output.IsEmpty());
 481         EXPECT_STREQ(_T(""), m_Git.GetFullRefName(_T("master")));
 482         EXPECT_STREQ(_T("refs/remotes/origin/master"), m_Git.GetFullRefName(_T("origin/master")));
 483
 484         EXPECT_EQ(0, m_Git.Run(_T("git.exe branch normal-tag HEAD~2"), &output, CP_UTF8));
 485         EXPECT_TRUE(output.IsEmpty());
 486         EXPECT_STREQ(_T(""), m_Git.GetFullRefName(_T("normal-tag")));
 487
 488         EXPECT_EQ(0, m_Git.Run(_T("git.exe branch origin/master HEAD~2"), &output, CP_UTF8));
 489         EXPECT_TRUE(output.IsEmpty());
 490         EXPECT_STREQ(_T(""), m_Git.GetFullRefName(_T("origin/master")));
 491 }
 492
 493 TEST_P(CBasicGitWithTestRepoFixture, GetFullRefName)
 494 {
 495         GetFullRefName(m_Git);
 496
 497         CString output;
 498         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout --orphan orphanic"), &output, CP_UTF8));
 499         EXPECT_FALSE(output.IsEmpty());
 500         EXPECT_STREQ(_T(""), m_Git.GetFullRefName(_T("orphanic")));
 501 }
 502
 503 TEST_P(CBasicGitWithTestRepoBareFixture, GetFullRefName)
 504 {
 505         GetFullRefName(m_Git);
 506 }
 507
 508 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetRemoteTrackedBranch)
 509 {
 510         CString remote, branch;
 511         m_Git.GetRemoteTrackedBranchForHEAD(remote, branch);
 512         EXPECT_TRUE(remote.IsEmpty());
 513         EXPECT_TRUE(branch.IsEmpty());
 514
 515         m_Git.GetRemoteTrackedBranch(_T("master"), remote, branch);
 516         EXPECT_TRUE(remote.IsEmpty());
 517         EXPECT_TRUE(branch.IsEmpty());
 518
 519         m_Git.GetRemoteTrackedBranch(_T("non-existing"), remote, branch);
 520         EXPECT_TRUE(remote.IsEmpty());
 521         EXPECT_TRUE(branch.IsEmpty());
 522 }
 523
 524 static void GetRemoteTrackedBranch(CGit& m_Git)
 525 {
 526         CString remote, branch;
 527         m_Git.GetRemoteTrackedBranchForHEAD(remote, branch);
 528         EXPECT_STREQ(_T("origin"), remote);
 529         EXPECT_STREQ(_T("master"), branch);
 530
 531         remote.Empty();
 532         branch.Empty();
 533         m_Git.GetRemoteTrackedBranch(_T("master"), remote, branch);
 534         EXPECT_STREQ(_T("origin"), remote);
 535         EXPECT_STREQ(_T("master"), branch);
 536
 537         remote.Empty();
 538         branch.Empty();
 539         m_Git.GetRemoteTrackedBranch(_T("non-existing"), remote, branch);
 540         EXPECT_TRUE(remote.IsEmpty());
 541         EXPECT_TRUE(branch.IsEmpty());
 542 }
 543
 544 TEST_P(CBasicGitWithTestRepoFixture, GetRemoteTrackedBranch)
 545 {
 546         GetRemoteTrackedBranch(m_Git);
 547 }
 548
 549 TEST_P(CBasicGitWithTestRepoBareFixture, GetRemoteTrackedBranch)
 550 {
 551         GetRemoteTrackedBranch(m_Git);
 552 }
 553
 554 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetRemotePushBranch)
 555 {
 556         CString remote, branch;
 557         m_Git.GetRemotePushBranch(_T("master"), remote, branch);
 558         EXPECT_TRUE(remote.IsEmpty());
 559         EXPECT_TRUE(branch.IsEmpty());
 560
 561         m_Git.GetRemotePushBranch(_T("non-existing"), remote, branch);
 562         EXPECT_TRUE(remote.IsEmpty());
 563         EXPECT_TRUE(branch.IsEmpty());
 564 }
 565
 566 static void GetRemotePushBranch(CGit& m_Git)
 567 {
 568         CString remote, branch;
 569         m_Git.GetRemotePushBranch(_T("master"), remote, branch);
 570         EXPECT_STREQ(_T("origin"), remote);
 571         EXPECT_STREQ(_T("master"), branch);
 572
 573         remote.Empty();
 574         branch.Empty();
 575         m_Git.GetRemotePushBranch(_T("non-existing"), remote, branch);
 576         EXPECT_TRUE(remote.IsEmpty());
 577         EXPECT_TRUE(branch.IsEmpty());
 578
 579         CAutoRepository repo(m_Git.GetGitRepository());
 580         ASSERT_TRUE(repo.IsValid());
 581         CAutoConfig config(repo);
 582         ASSERT_TRUE(config.IsValid());
 583
 584         remote.Empty();
 585         branch.Empty();
 586         EXPECT_EQ(0, git_config_set_string(config, "remote.pushDefault", "originpush2"));
 587         m_Git.GetRemotePushBranch(_T("master"), remote, branch);
 588         EXPECT_STREQ(_T("originpush2"), remote);
 589         EXPECT_STREQ(_T("master"), branch);
 590
 591         remote.Empty();
 592         branch.Empty();
 593         EXPECT_EQ(0, git_config_set_string(config, "branch.master.pushremote", "originpush3"));
 594         m_Git.GetRemotePushBranch(_T("master"), remote, branch);
 595         EXPECT_STREQ(_T("originpush3"), remote);
 596         EXPECT_STREQ(_T("master"), branch);
 597
 598         remote.Empty();
 599         branch.Empty();
 600         EXPECT_EQ(0, git_config_set_string(config, "branch.master.pushbranch", "masterbranch2"));
 601         m_Git.GetRemotePushBranch(_T("master"), remote, branch);
 602         EXPECT_STREQ(_T("originpush3"), remote);
 603         EXPECT_STREQ(_T("masterbranch2"), branch);
 604
 605         remote.Empty();
 606         branch.Empty();
 607         m_Git.GetRemotePushBranch(_T("non-existing"), remote, branch);
 608         EXPECT_STREQ(_T("originpush2"), remote);
 609         EXPECT_TRUE(branch.IsEmpty());
 610 }
 611
 612 TEST_P(CBasicGitWithTestRepoFixture, GetRemotePushBranch)
 613 {
 614         GetRemotePushBranch(m_Git);
 615 }
 616
 617 TEST_P(CBasicGitWithTestRepoBareFixture, GetRemotePushBranch)
 618 {
 619         GetRemotePushBranch(m_Git);
 620 }
 621
 622 static void CanParseRev(CGit& m_Git)
 623 {
 624         EXPECT_TRUE(m_Git.CanParseRev(_T("")));
 625         EXPECT_TRUE(m_Git.CanParseRev(_T("HEAD")));
 626         EXPECT_TRUE(m_Git.CanParseRev(_T("master")));
 627         EXPECT_TRUE(m_Git.CanParseRev(_T("heads/master")));
 628         EXPECT_TRUE(m_Git.CanParseRev(_T("refs/heads/master")));
 629         EXPECT_TRUE(m_Git.CanParseRev(_T("master~1")));
 630         EXPECT_TRUE(m_Git.CanParseRev(_T("master forconflict")));
 631         EXPECT_TRUE(m_Git.CanParseRev(_T("origin/master..master")));
 632         EXPECT_TRUE(m_Git.CanParseRev(_T("origin/master...master")));
 633         EXPECT_TRUE(m_Git.CanParseRev(_T("49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")));
 634         EXPECT_FALSE(m_Git.CanParseRev(_T("non-existing")));
 635         EXPECT_TRUE(m_Git.CanParseRev(_T("normal-tag")));
 636         EXPECT_TRUE(m_Git.CanParseRev(_T("tags/normal-tag")));
 637         EXPECT_TRUE(m_Git.CanParseRev(_T("refs/tags/normal-tag")));
 638         EXPECT_TRUE(m_Git.CanParseRev(_T("all-files-signed")));
 639         EXPECT_TRUE(m_Git.CanParseRev(_T("all-files-signed^{}")));
 640
 641         EXPECT_FALSE(m_Git.CanParseRev(_T("orphanic")));
 642 }
 643
 644 TEST_P(CBasicGitWithTestRepoFixture, CanParseRev)
 645 {
 646         CanParseRev(m_Git);
 647
 648         CString output;
 649         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout --orphan orphanic"), &output, CP_UTF8));
 650         EXPECT_FALSE(output.IsEmpty());
 651         EXPECT_FALSE(m_Git.CanParseRev(_T("")));
 652         EXPECT_FALSE(m_Git.CanParseRev(_T("HEAD")));
 653         EXPECT_FALSE(m_Git.CanParseRev(_T("orphanic")));
 654         EXPECT_TRUE(m_Git.CanParseRev(_T("master")));
 655 }
 656
 657 TEST_P(CBasicGitWithTestRepoBareFixture, CanParseRev)
 658 {
 659         CanParseRev(m_Git);
 660 }
 661
 662 static void FETCHHEAD(CGit& m_Git, bool isBare)
 663 {
 664         CString repoDir = m_Git.m_CurrentDir;
 665         if (!isBare)
 666                 repoDir += _T("\\.git");
 667
 668         STRING_VECTOR list;
 669         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 670         EXPECT_EQ(5, list.size());
 671         list.clear();
 672         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 673         EXPECT_EQ(5, list.size());
 674
 675         EXPECT_STREQ(_T("HEAD"), m_Git.FixBranchName(_T("HEAD")));
 676         EXPECT_STREQ(_T("master"), m_Git.FixBranchName(_T("master")));
 677         EXPECT_STREQ(_T("non-existing"), m_Git.FixBranchName(_T("non-existing")));
 678         CString branch = _T("master");
 679         EXPECT_STREQ(_T("master"), m_Git.FixBranchName_Mod(branch));
 680         EXPECT_STREQ(_T("master"), branch);
 681         branch = _T("non-existing");
 682         EXPECT_STREQ(_T("non-existing"), m_Git.FixBranchName_Mod(branch));
 683         EXPECT_STREQ(_T("non-existing"), branch);
 684         CGitHash hash;
 685         EXPECT_NE(0, m_Git.GetHash(hash, _T("FETCH_HEAD")));
 686
 687         CString testFile = repoDir + L"\\FETCH_HEAD";
 688         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)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"));
 689
 690         list.clear();
 691         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 692         EXPECT_EQ(5, list.size());
 693         list.clear();
 694         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 695         EXPECT_EQ(6, list.size());
 696
 697         EXPECT_STREQ(_T("master"), m_Git.FixBranchName(_T("master")));
 698         EXPECT_STREQ(_T("non-existing"), m_Git.FixBranchName(_T("non-existing")));
 699         EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), m_Git.FixBranchName(_T("FETCH_HEAD")));
 700         branch = _T("HEAD");
 701         EXPECT_STREQ(_T("HEAD"), m_Git.FixBranchName_Mod(branch));
 702         EXPECT_STREQ(_T("HEAD"), branch);
 703         branch = _T("master");
 704         EXPECT_STREQ(_T("master"), m_Git.FixBranchName_Mod(branch));
 705         EXPECT_STREQ(_T("master"), branch);
 706         branch = _T("non-existing");
 707         EXPECT_STREQ(_T("non-existing"), m_Git.FixBranchName_Mod(branch));
 708         EXPECT_STREQ(_T("non-existing"), branch);
 709         branch = _T("FETCH_HEAD");
 710         EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), m_Git.FixBranchName_Mod(branch));
 711         EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), branch);
 712         EXPECT_EQ(0, m_Git.GetHash(hash, _T("FETCH_HEAD")));
 713         EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), hash.ToString());
 714
 715         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)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"));
 716
 717         list.clear();
 718         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 719         EXPECT_EQ(5, list.size());
 720         list.clear();
 721         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 722         EXPECT_EQ(6, list.size());
 723
 724         EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), m_Git.FixBranchName(_T("FETCH_HEAD")));
 725         branch = _T("FETCH_HEAD");
 726         EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), m_Git.FixBranchName_Mod(branch));
 727         EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), branch);
 728         // libgit2 fails here
 729         //EXPECT_EQ(0, m_Git.GetHash(hash, _T("FETCH_HEAD")));
 730         //EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), hash.ToString());
 731 }
 732
 733 TEST_P(CBasicGitWithTestRepoFixture, FETCHHEAD)
 734 {
 735         FETCHHEAD(m_Git, false);
 736 }
 737
 738 TEST_P(CBasicGitWithTestRepoBareFixture, FETCHHEAD)
 739 {
 740         FETCHHEAD(m_Git, true);
 741 }
 742
 743 TEST_P(CBasicGitWithTestRepoFixture, IsFastForward)
 744 {
 745         CGitHash commonAncestor;
 746         EXPECT_TRUE(m_Git.IsFastForward(_T("origin/master"), _T("master"), &commonAncestor));
 747         EXPECT_STREQ(_T("a9d53b535cb49640a6099860ac4999f5a0857b91"), commonAncestor.ToString());
 748
 749         EXPECT_FALSE(m_Git.IsFastForward(_T("simple-conflict"), _T("master"), &commonAncestor));
 750         EXPECT_STREQ(_T("b02add66f48814a73aa2f0876d6bbc8662d6a9a8"), commonAncestor.ToString());
 751 }
 752
 753 static void GetHash(CGit& m_Git)
 754 {
 755         CGitHash hash;
 756         EXPECT_EQ(0, m_Git.GetHash(hash, _T("HEAD")));
 757         EXPECT_STREQ(_T("7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6"), hash.ToString());
 758         EXPECT_EQ(0, m_Git.GetHash(hash, _T("HEAD~1")));
 759         EXPECT_STREQ(_T("1fc3c9688e27596d8717b54f2939dc951568f6cb"), hash.ToString());
 760         EXPECT_EQ(0, m_Git.GetHash(hash, _T("ff1fbef1a54a9849afd4a5e94d2ca4d80d5b96c2")));
 761         EXPECT_STREQ(_T("ff1fbef1a54a9849afd4a5e94d2ca4d80d5b96c2"), hash.ToString());
 762         EXPECT_EQ(0, m_Git.GetHash(hash, _T("master")));
 763         EXPECT_STREQ(_T("7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6"), hash.ToString());
 764         EXPECT_EQ(0, m_Git.GetHash(hash, _T("origin/master")));
 765         EXPECT_STREQ(_T("a9d53b535cb49640a6099860ac4999f5a0857b91"), hash.ToString());
 766         EXPECT_EQ(0, m_Git.GetHash(hash, _T("49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")));
 767         EXPECT_STREQ(_T("49ecdfff36bfe2b9b499b33e5034f427e2fa54dd"), hash.ToString());
 768         EXPECT_EQ(0, m_Git.GetHash(hash, _T("normal-tag")));
 769         EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), hash.ToString());
 770         EXPECT_EQ(0, m_Git.GetHash(hash, _T("all-files-signed")));
 771         EXPECT_STREQ(_T("ab555b2776c6b700ad93848d0dd050e7d08be779"), hash.ToString()); // maybe we need automatically to dereference it
 772         EXPECT_EQ(0, m_Git.GetHash(hash, _T("all-files-signed^{}")));
 773         EXPECT_STREQ(_T("313a41bc88a527289c87d7531802ab484715974f"), hash.ToString());
 774
 775         EXPECT_NE(0, m_Git.GetHash(hash, _T("non-existing")));
 776 }
 777
 778 TEST_P(CBasicGitWithTestRepoFixture, GetHash)
 779 {
 780         GetHash(m_Git);
 781 }
 782
 783 TEST_P(CBasicGitWithTestRepoBareFixture, GetHash)
 784 {
 785         GetHash(m_Git);
 786 }
 787
 788 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetHash_EmptyRepo)
 789 {
 790         CGitHash hash;
 791         EXPECT_EQ(0, m_Git.GetHash(hash, _T("HEAD")));
 792         EXPECT_TRUE(hash.IsEmpty());
 793 }
 794
 795 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetEmptyBranchesTagsRefs)
 796 {
 797         STRING_VECTOR branches;
 798         int current = -2;
 799         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
 800         EXPECT_TRUE(branches.empty());
 801         EXPECT_EQ(-2, current); // not touched
 802
 803         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
 804         EXPECT_TRUE(branches.empty());
 805         EXPECT_EQ(-2, current); // not touched
 806
 807         STRING_VECTOR tags;
 808         EXPECT_EQ(0, m_Git.GetTagList(tags));
 809         EXPECT_TRUE(tags.empty());
 810
 811         STRING_VECTOR refs;
 812         EXPECT_EQ(0, m_Git.GetRefList(refs));
 813         EXPECT_TRUE(refs.empty());
 814
 815         MAP_HASH_NAME map;
 816         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
 817         EXPECT_TRUE(map.empty());
 818
 819         STRING_VECTOR remotes;
 820         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
 821         EXPECT_TRUE(remotes.empty());
 822 }
 823
 824 static void GetBranchesTagsRefs(CGit& m_Git, config testConfig)
 825 {
 826         STRING_VECTOR branches;
 827         int current = -2;
 828         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
 829         ASSERT_EQ(5, branches.size());
 830         EXPECT_EQ(1, current);
 831         EXPECT_STREQ(_T("forconflict"), branches[0]);
 832         EXPECT_STREQ(_T("master"), branches[1]);
 833         EXPECT_STREQ(_T("master2"), branches[2]);
 834         EXPECT_STREQ(_T("simple-conflict"), branches[3]);
 835         EXPECT_STREQ(_T("subdir/branch"), branches[4]);
 836
 837         branches.clear();
 838         current = -2;
 839         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
 840         ASSERT_EQ(6, branches.size());
 841         EXPECT_EQ(1, current);
 842         EXPECT_STREQ(_T("forconflict"), branches[0]);
 843         EXPECT_STREQ(_T("master"), branches[1]);
 844         EXPECT_STREQ(_T("master2"), branches[2]);
 845         EXPECT_STREQ(_T("simple-conflict"), branches[3]);
 846         EXPECT_STREQ(_T("subdir/branch"), branches[4]);
 847         EXPECT_STREQ(_T("remotes/origin/master"), branches[5]);
 848
 849         branches.clear();
 850         current = -2;
 851         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_REMOTE));
 852         ASSERT_EQ(1, branches.size());
 853         EXPECT_EQ(-2, current); // not touched
 854         EXPECT_STREQ(_T("remotes/origin/master"), branches[0]);
 855
 856         STRING_VECTOR tags;
 857         EXPECT_EQ(0, m_Git.GetTagList(tags));
 858         ASSERT_EQ(3, tags.size());
 859         EXPECT_STREQ(_T("all-files-signed"), tags[0]);
 860         EXPECT_STREQ(_T("also-signed"), tags[1]);
 861         EXPECT_STREQ(_T("normal-tag"), tags[2]);
 862
 863         STRING_VECTOR refs;
 864         EXPECT_EQ(0, m_Git.GetRefList(refs));
 865         ASSERT_EQ(11, refs.size());
 866         EXPECT_STREQ(_T("refs/heads/forconflict"), refs[0]);
 867         EXPECT_STREQ(_T("refs/heads/master"), refs[1]);
 868         EXPECT_STREQ(_T("refs/heads/master2"), refs[2]);
 869         EXPECT_STREQ(_T("refs/heads/simple-conflict"), refs[3]);
 870         EXPECT_STREQ(_T("refs/heads/subdir/branch"), refs[4]);
 871         EXPECT_STREQ(_T("refs/notes/commits"), refs[5]);
 872         EXPECT_STREQ(_T("refs/remotes/origin/master"), refs[6]);
 873         EXPECT_STREQ(_T("refs/stash"), refs[7]);
 874         EXPECT_STREQ(_T("refs/tags/all-files-signed"), refs[8]);
 875         EXPECT_STREQ(_T("refs/tags/also-signed"), refs[9]);
 876         EXPECT_STREQ(_T("refs/tags/normal-tag"), refs[10]);
 877
 878         MAP_HASH_NAME map;
 879         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
 880         if (testConfig == GIT_CLI || testConfig == LIBGIT)
 881                 ASSERT_EQ(12, map.size()); // also contains the undereferenced tags with hashes
 882         else
 883                 ASSERT_EQ(10, map.size());
 884
 885         ASSERT_EQ(1, map[CGitHash(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6")].size());
 886         EXPECT_STREQ(_T("refs/heads/master"), map[CGitHash(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6")][0]);
 887         ASSERT_EQ(1, map[CGitHash(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44")].size());
 888         EXPECT_STREQ(_T("refs/heads/subdir/branch"), map[CGitHash(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44")][0]);
 889         ASSERT_EQ(1, map[CGitHash(L"5e702e1712aa6f8cd8e0328a87be006f3a923710")].size());
 890         EXPECT_STREQ(_T("refs/notes/commits"), map[CGitHash(L"5e702e1712aa6f8cd8e0328a87be006f3a923710")][0]);
 891         ASSERT_EQ(1, map[CGitHash(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb")].size());
 892         EXPECT_STREQ(_T("refs/stash"), map[CGitHash(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb")][0]);
 893         ASSERT_EQ(1, map[CGitHash(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")].size());
 894         EXPECT_STREQ(_T("refs/heads/simple-conflict"), map[CGitHash(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")][0]);
 895         ASSERT_EQ(1, map[CGitHash(L"10385764a4d42d7428bbeb245015f8f338fc1e40")].size());
 896         EXPECT_STREQ(_T("refs/heads/forconflict"), map[CGitHash(L"10385764a4d42d7428bbeb245015f8f338fc1e40")][0]);
 897         ASSERT_EQ(2, map[CGitHash(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")].size());
 898         EXPECT_STREQ(_T("refs/heads/master2"), map[CGitHash(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")][0]);
 899         EXPECT_STREQ(_T("refs/tags/also-signed^{}"), map[CGitHash(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")][1]);
 900         ASSERT_EQ(1, map[CGitHash(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb")].size());//
 901         EXPECT_STREQ(_T("refs/tags/normal-tag"), map[CGitHash(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb")][0]);
 902         ASSERT_EQ(1, map[CGitHash(L"a9d53b535cb49640a6099860ac4999f5a0857b91")].size());
 903         EXPECT_STREQ(_T("refs/remotes/origin/master"), map[CGitHash(L"a9d53b535cb49640a6099860ac4999f5a0857b91")][0]);
 904         ASSERT_EQ(1, map[CGitHash(L"313a41bc88a527289c87d7531802ab484715974f")].size());
 905         EXPECT_STREQ(_T("refs/tags/all-files-signed^{}"), map[CGitHash(L"313a41bc88a527289c87d7531802ab484715974f")][0]);
 906
 907         STRING_VECTOR remotes;
 908         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
 909         ASSERT_EQ(1, remotes.size());
 910         EXPECT_STREQ(_T("origin"), remotes[0]);
 911
 912         EXPECT_EQ(-1, m_Git.DeleteRef(_T("refs/tags/gibbednet")));
 913         branches.clear();
 914         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 915         EXPECT_EQ(6, branches.size());
 916         tags.clear();
 917         EXPECT_EQ(0, m_Git.GetTagList(tags));
 918         EXPECT_EQ(3, tags.size());
 919         refs.clear();
 920         EXPECT_EQ(0, m_Git.GetRefList(refs));
 921         EXPECT_EQ(11, refs.size());
 922
 923         EXPECT_EQ(-1, m_Git.DeleteRef(_T("refs/heads/gibbednet")));
 924         branches.clear();
 925         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 926         EXPECT_EQ(6, branches.size());
 927         tags.clear();
 928         EXPECT_EQ(0, m_Git.GetTagList(tags));
 929         EXPECT_EQ(3, tags.size());
 930         refs.clear();
 931         EXPECT_EQ(0, m_Git.GetRefList(refs));
 932         EXPECT_EQ(11, refs.size());
 933
 934         EXPECT_EQ(-1, m_Git.DeleteRef(_T("refs/remotes/origin/gibbednet")));
 935         branches.clear();
 936         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 937         EXPECT_EQ(6, branches.size());
 938         tags.clear();
 939         EXPECT_EQ(0, m_Git.GetTagList(tags));
 940         EXPECT_EQ(3, tags.size());
 941         refs.clear();
 942         EXPECT_EQ(0, m_Git.GetRefList(refs));
 943         EXPECT_EQ(11, refs.size());
 944
 945         EXPECT_EQ(0, m_Git.DeleteRef(_T("refs/tags/normal-tag")));
 946         branches.clear();
 947         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 948         EXPECT_EQ(6, branches.size());
 949         tags.clear();
 950         EXPECT_EQ(0, m_Git.GetTagList(tags));
 951         EXPECT_EQ(2, tags.size());
 952         refs.clear();
 953         EXPECT_EQ(0, m_Git.GetRefList(refs));
 954         EXPECT_EQ(10, refs.size());
 955
 956         EXPECT_EQ(0, m_Git.DeleteRef(_T("refs/tags/all-files-signed^{}")));
 957         branches.clear();
 958         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 959         EXPECT_EQ(6, branches.size());
 960         tags.clear();
 961         EXPECT_EQ(0, m_Git.GetTagList(tags));
 962         EXPECT_EQ(1, tags.size());
 963         refs.clear();
 964         EXPECT_EQ(0, m_Git.GetRefList(refs));
 965         EXPECT_EQ(9, refs.size());
 966
 967         EXPECT_EQ(0, m_Git.DeleteRef(_T("refs/heads/subdir/branch")));
 968         branches.clear();
 969         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 970         EXPECT_EQ(5, branches.size());
 971         tags.clear();
 972         EXPECT_EQ(0, m_Git.GetTagList(tags));
 973         EXPECT_EQ(1, tags.size());
 974         refs.clear();
 975         EXPECT_EQ(0, m_Git.GetRefList(refs));
 976         EXPECT_EQ(8, refs.size());
 977
 978         EXPECT_EQ(0, m_Git.DeleteRef(_T("refs/remotes/origin/master")));
 979         branches.clear();
 980         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 981         EXPECT_EQ(4, branches.size());
 982         tags.clear();
 983         EXPECT_EQ(0, m_Git.GetTagList(tags));
 984         EXPECT_EQ(1, tags.size());
 985         refs.clear();
 986         EXPECT_EQ(0, m_Git.GetRefList(refs));
 987         EXPECT_EQ(7, refs.size());
 988 }
 989
 990 TEST_P(CBasicGitWithTestRepoFixture, GetBranchesTagsRefs)
 991 {
 992         GetBranchesTagsRefs(m_Git, GetParam());
 993 }
 994
 995 TEST_P(CBasicGitWithTestRepoBareFixture, GetBranchesTagsRefs)
 996 {
 997         GetBranchesTagsRefs(m_Git, GetParam());
 998 }
 999
1000 TEST_P(CBasicGitWithTestRepoFixture, GetBranchList_orphan)
1001 {
1002         CString output;
1003         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout --orphan orphanic"), &output, CP_UTF8));
1004         EXPECT_FALSE(output.IsEmpty());
1005
1006         STRING_VECTOR branches;
1007         int current = -2;
1008         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1009         ASSERT_EQ(5, branches.size());
1010         EXPECT_EQ(-2, current);
1011         EXPECT_STREQ(_T("forconflict"), branches[0]);
1012         EXPECT_STREQ(_T("master"), branches[1]);
1013         EXPECT_STREQ(_T("master2"), branches[2]);
1014         EXPECT_STREQ(_T("simple-conflict"), branches[3]);
1015         EXPECT_STREQ(_T("subdir/branch"), branches[4]);
1016 }
1017
1018 TEST_P(CBasicGitWithTestRepoFixture, GetBranchList_detachedhead)
1019 {
1020         CString output;
1021         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout a9d53b535cb49640a6099860ac4999f5a0857b91"), &output, CP_UTF8));
1022         EXPECT_FALSE(output.IsEmpty());
1023
1024         STRING_VECTOR branches;
1025         int current = -2;
1026         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1027         ASSERT_EQ(5, branches.size());
1028         EXPECT_EQ(-2, current);
1029         EXPECT_STREQ(_T("forconflict"), branches[0]);
1030         EXPECT_STREQ(_T("master"), branches[1]);
1031         EXPECT_STREQ(_T("master2"), branches[2]);
1032         EXPECT_STREQ(_T("simple-conflict"), branches[3]);
1033         EXPECT_STREQ(_T("subdir/branch"), branches[4]);
1034
1035         // cygwin fails here
1036         if (CGit::ms_bCygwinGit)
1037                 return;
1038
1039         output.Empty();
1040         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout -b (HEAD a9d53b535cb49640a6099860ac4999f5a0857b91"), &output, CP_UTF8));
1041         EXPECT_FALSE(output.IsEmpty());
1042
1043         branches.clear();
1044         current = -2;
1045         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1046         ASSERT_EQ(6, branches.size());
1047         EXPECT_EQ(0, current);
1048         EXPECT_STREQ(_T("(HEAD"), branches[0]);
1049         EXPECT_STREQ(_T("forconflict"), branches[1]);
1050         EXPECT_STREQ(_T("master"), branches[2]);
1051         EXPECT_STREQ(_T("master2"), branches[3]);
1052         EXPECT_STREQ(_T("simple-conflict"), branches[4]);
1053         EXPECT_STREQ(_T("subdir/branch"), branches[5]);
1054 }
1055
1056 TEST_P(CBasicGitWithEmptyBareRepositoryFixture, GetEmptyBranchesTagsRefs)
1057 {
1058         EXPECT_STREQ(_T("master"), m_Git.GetCurrentBranch());
1059
1060         STRING_VECTOR branches;
1061         int current = -2;
1062         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
1063         EXPECT_TRUE(branches.empty());
1064         EXPECT_EQ(-2, current); // not touched
1065
1066         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
1067         EXPECT_TRUE(branches.empty());
1068         EXPECT_EQ(-2, current); // not touched
1069
1070         STRING_VECTOR tags;
1071         EXPECT_EQ(0, m_Git.GetTagList(tags));
1072         EXPECT_TRUE(tags.empty());
1073
1074         STRING_VECTOR refs;
1075         EXPECT_EQ(0, m_Git.GetRefList(refs));
1076         EXPECT_TRUE(refs.empty());
1077
1078         MAP_HASH_NAME map;
1079         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
1080         EXPECT_TRUE(map.empty());
1081
1082         STRING_VECTOR remotes;
1083         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
1084         EXPECT_TRUE(remotes.empty());
1085 }
1086
1087 TEST_P(CBasicGitWithEmptyRepositoryFixture, CheckCleanWorkTree)
1088 {
1089         // this test is known to fail with cygwin and also not enabled by default
1090         if (GetParam() == LIBGIT2_ALL && CGit::ms_bCygwinGit)
1091                 return;
1092
1093         CString output;
1094         CString testFile = m_Dir.GetTempDir() + L"\\test.txt";
1095         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is testing file."));
1096         EXPECT_EQ(0, m_Git.Run(_T("git.exe add test.txt"), &output, CP_UTF8));
1097         output.Empty();
1098         EXPECT_EQ(0, m_Git.Run(_T("git.exe commit -m \"Add test.txt\""), &output, CP_UTF8));
1099         // repo with 1 versioned file
1100         EXPECT_FALSE(output.IsEmpty());
1101         EXPECT_TRUE(m_Git.CheckCleanWorkTree());
1102         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
1103
1104         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"Overwriting this testing file."));
1105         // repo with 1 modified versioned file
1106         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
1107         EXPECT_FALSE(m_Git.CheckCleanWorkTree(true));
1108
1109         output.Empty();
1110         EXPECT_EQ(0, m_Git.Run(_T("git.exe add test.txt"), &output, CP_UTF8));
1111         // repo with 1 modified versioned and staged file
1112         EXPECT_TRUE(output.IsEmpty());
1113         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
1114         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
1115
1116         EXPECT_EQ(0, m_Git.Run(_T("git.exe commit -m \"Modified test.txt\""), &output, CP_UTF8));
1117         testFile = m_Dir.GetTempDir() + L"\\test2.txt";
1118         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is ANOTHER testing file."));
1119         EXPECT_TRUE(m_Git.CheckCleanWorkTree());
1120         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
1121
1122         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout --orphan orphanic"), &output, CP_UTF8));
1123         EXPECT_FALSE(output.IsEmpty());
1124         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
1125         EXPECT_FALSE(m_Git.CheckCleanWorkTree(true));
1126 }
1127
1128 TEST(CGit, CEnvironment)
1129 {
1130         CEnvironment env;
1131         wchar_t** basePtr = env;
1132         ASSERT_TRUE(basePtr);
1133         EXPECT_FALSE(*basePtr);
1134         EXPECT_TRUE(env.empty());
1135         env.SetEnv(_T("not-found"), nullptr);
1136         EXPECT_FALSE(static_cast<wchar_t*>(env));
1137         EXPECT_STREQ(_T(""), env.GetEnv(L"test"));
1138         env.SetEnv(L"key1", L"value1");
1139         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1140         EXPECT_STREQ(_T("value1"), env.GetEnv(L"kEy1")); // check case insensitivity
1141         EXPECT_TRUE(*basePtr);
1142         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1143         EXPECT_FALSE(env.empty());
1144         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1145         env.SetEnv(L"key1", nullptr); // delete first
1146         EXPECT_FALSE(*basePtr);
1147         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1148         EXPECT_TRUE(env.empty());
1149         env.SetEnv(L"key1", L"value1");
1150         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1151         EXPECT_TRUE(*basePtr);
1152         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1153         EXPECT_FALSE(env.empty());
1154         env.SetEnv(L"key2", L"value2");
1155         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1156         EXPECT_STREQ(_T("value2"), env.GetEnv(L"key2"));
1157         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1158         env.SetEnv(_T("not-found"), nullptr);
1159         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1160         EXPECT_STREQ(_T("value2"), env.GetEnv(L"key2"));
1161         env.SetEnv(_T("key2"), nullptr); // delete last
1162         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1163         EXPECT_STREQ(_T(""), env.GetEnv(L"key2"));
1164         env.SetEnv(L"key3", L"value3");
1165         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1166         EXPECT_STREQ(_T("value3"), env.GetEnv(L"key3"));
1167         env.SetEnv(L"key4", L"value4");
1168         env.SetEnv(_T("value3"), nullptr); // delete middle
1169         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1170         EXPECT_STREQ(_T("value4"), env.GetEnv(L"key4"));
1171         env.SetEnv(L"key5", L"value5");
1172         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1173         EXPECT_STREQ(_T("value4"), env.GetEnv(L"key4"));
1174         EXPECT_STREQ(_T("value5"), env.GetEnv(L"key5"));
1175         env.SetEnv(L"key4", L"value4a");
1176         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1177         EXPECT_STREQ(_T("value4a"), env.GetEnv(L"key4"));
1178         EXPECT_STREQ(_T("value5"), env.GetEnv(L"key5"));
1179         env.SetEnv(L"key5", L"value5a");
1180         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1181         EXPECT_STREQ(_T("value4a"), env.GetEnv(L"key4"));
1182         EXPECT_STREQ(_T("value5a"), env.GetEnv(L"key5"));
1183 #pragma warning(push)
1184 #pragma warning(disable: 4996)
1185         CString windir = _wgetenv(L"windir");
1186 #pragma warning(pop)
1187         env.CopyProcessEnvironment();
1188         EXPECT_STREQ(windir, env.GetEnv(L"windir"));
1189         EXPECT_STREQ(_T("value1"), env.GetEnv(L"key1"));
1190         EXPECT_STREQ(_T("value4a"), env.GetEnv(L"key4"));
1191         EXPECT_STREQ(_T("value5a"), env.GetEnv(L"key5"));
1192         env.clear();
1193         EXPECT_FALSE(*basePtr);
1194         EXPECT_TRUE(env.empty());
1195         EXPECT_STREQ(_T(""), env.GetEnv(L"key4"));
1196         env.CopyProcessEnvironment();
1197         EXPECT_STREQ(windir, env.GetEnv(L"windir"));
1198         EXPECT_TRUE(*basePtr);
1199
1200         // make sure baseptr always points to current values
1201         EXPECT_EQ(static_cast<wchar_t*>(env), *basePtr);
1202
1203         env.clear();
1204         CString path = L"c:\\windows;c:\\windows\\system32";
1205         env.SetEnv(L"PATH", path);
1206         env.AddToPath(L"");
1207         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1208         env.AddToPath(L"c:\\windows");
1209         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1210         env.AddToPath(L"c:\\windows\\");
1211         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1212         env.AddToPath(L"c:\\windows\\system32");
1213         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1214         env.AddToPath(L"c:\\windows\\system32\\");
1215         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1216         path += L";c:\\windows\\system";
1217         env.AddToPath(L"c:\\windows\\system");
1218         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1219         path += L";c:\\test";
1220         env.AddToPath(L"c:\\test\\");
1221         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1222         env.AddToPath(L"c:\\test\\");
1223         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1224         env.AddToPath(L"c:\\test");
1225         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1226         path = L"c:\\windows;c:\\windows\\system32;";
1227         env.SetEnv(L"PATH", path);
1228         env.AddToPath(L"");
1229         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1230         env.AddToPath(L"c:\\test");
1231         path += L"c:\\test";
1232         EXPECT_STREQ(path, env.GetEnv(L"PATH"));
1233
1234         // also test copy constructor
1235         CEnvironment env2(env);
1236         EXPECT_EQ(static_cast<wchar_t*>(env2), *static_cast<wchar_t**>(env2));
1237         EXPECT_NE(static_cast<wchar_t*>(env2), *basePtr);
1238
1239         // also test assignment operation
1240         CEnvironment env3a;
1241         basePtr = env3a;
1242         env3a.SetEnv(L"something", L"else");
1243         CEnvironment env3b;
1244         env3b = env3a;
1245         EXPECT_FALSE(env3b.empty());
1246         EXPECT_EQ(static_cast<wchar_t**>(env3a), basePtr);
1247         EXPECT_EQ(static_cast<wchar_t*>(env3a), *basePtr);
1248         EXPECT_NE(static_cast<wchar_t*>(env3b), *basePtr);
1249 }
1250
1251 static void GetOneFile(CGit& m_Git)
1252 {
1253         CString tmpFile = GetTempFile();
1254         EXPECT_EQ(0, m_Git.GetOneFile(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", CTGitPath(L"utf8-nobom.txt"), tmpFile));
1255         CString fileContents;
1256         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1257         struct _stat32 stat_buf = { 0 };
1258         EXPECT_EQ(0, _wstat32(tmpFile, &stat_buf));
1259         EXPECT_EQ(139, stat_buf.st_size);
1260         EXPECT_EQ(108, fileContents.GetLength());
1261         EXPECT_STREQ(_T("ä#ä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);
1262         ::DeleteFile(tmpFile);
1263 }
1264
1265 TEST_P(CBasicGitWithTestRepoFixture, GetOneFile)
1266 {
1267         GetOneFile(m_Git);
1268
1269         // clean&smudge filters are not available for GetOneFile without libigt2
1270         if (GetParam() == GIT_CLI || GetParam() == LIBGIT)
1271                 return;
1272
1273         CString cleanFilterFilename = m_Git.m_CurrentDir + L"\\clean_filter_openssl";
1274         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)cleanFilterFilename, L"#!/bin/bash\nopenssl enc -base64 -aes-256-ecb -S FEEDDEADBEEF -k PASS_FIXED"));
1275         CString smudgeFilterFilename = m_Git.m_CurrentDir + L"\\smudge_filter_openssl";
1276         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)smudgeFilterFilename, L"#!/bin/bash\nopenssl enc -d -base64 -aes-256-ecb -k PASS_FIXED"));
1277
1278         CAutoRepository repo(m_Git.GetGitRepository());
1279         ASSERT_TRUE(repo.IsValid());
1280         CAutoConfig config(repo);
1281         ASSERT_TRUE(config.IsValid());
1282         CStringA path = CUnicodeUtils::GetUTF8(m_Git.m_CurrentDir);
1283         path.Replace('\\', '/');
1284         EXPECT_EQ(0, git_config_set_string(config, "filter.openssl.clean", path + "/clean_filter_openssl"));
1285         EXPECT_EQ(0, git_config_set_string(config, "filter.openssl.smudge", path + "/smudge_filter_openssl"));
1286         EXPECT_EQ(0, git_config_set_bool(config, "filter.openssl.required", 1));
1287
1288         CString attributesFile = m_Git.m_CurrentDir + L"\\.gitattributes";
1289         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)attributesFile, L"*.enc filter=openssl\n"));
1290
1291         CString encryptedFileOne = m_Git.m_CurrentDir + L"\\1.enc";
1292         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)encryptedFileOne, L"This should be encrypted...\nAnd decrypted on the fly\n"));
1293
1294         CString encryptedFileTwo = m_Git.m_CurrentDir + L"\\2.enc";
1295         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)encryptedFileTwo, L"This should also be encrypted...\nAnd also decrypted on the fly\n"));
1296
1297         CString output;
1298         EXPECT_EQ(0, m_Git.Run(_T("git.exe add 1.enc"), &output, CP_UTF8));
1299         EXPECT_TRUE(output.IsEmpty());
1300
1301         CAutoIndex index;
1302         ASSERT_EQ(0, git_repository_index(index.GetPointer(), repo));
1303         EXPECT_EQ(0, git_index_add_bypath(index, "2.enc"));
1304         EXPECT_EQ(0, git_index_write(index));
1305
1306         EXPECT_EQ(0, m_Git.Run(_T("git.exe commit -m \"Message\""), &output, CP_UTF8));
1307         EXPECT_FALSE(output.IsEmpty());
1308
1309         CString fileContents;
1310         CString tmpFile = GetTempFile();
1311         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"1.enc"), tmpFile));
1312         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1313         EXPECT_STREQ(_T("This should be encrypted...\nAnd decrypted on the fly\n"), fileContents);
1314         ::DeleteFile(tmpFile);
1315
1316         fileContents.Empty();
1317         tmpFile = GetTempFile();
1318         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"2.enc"), tmpFile));
1319         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1320         EXPECT_STREQ(_T("This should also be encrypted...\nAnd also decrypted on the fly\n"), fileContents);
1321         ::DeleteFile(tmpFile);
1322
1323         EXPECT_TRUE(::DeleteFile(attributesFile));
1324
1325         fileContents.Empty();
1326         tmpFile = GetTempFile();
1327         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"1.enc"), tmpFile));
1328         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1329         EXPECT_STREQ(_T("U2FsdGVkX1/+7d6tvu8AABwbE+Xy7U4l5boTKjIgUkYHONqmYHD+0e6k35MgtUGx\ns11nq1QuKeFCW5wFWNSj1WcHg2n4W59xfnB7RkSSIDQ=\n"), fileContents);
1330         ::DeleteFile(tmpFile);
1331
1332         fileContents.Empty();
1333         tmpFile = GetTempFile();
1334         EXPECT_EQ(0, m_Git.GetOneFile(L"HEAD", CTGitPath(L"2.enc"), tmpFile));
1335         EXPECT_EQ(true, CStringUtils::ReadStringFromTextFile(tmpFile, fileContents));
1336         EXPECT_STREQ(_T("U2FsdGVkX1/+7d6tvu8AAIDDx8qi/l0qzkSMsS2YLt8tYK1oWzj8+o78fXH0/tlO\nCRVrKqTvh9eUFklY8QFYfZfj01zBkFat+4zrW+1rV4Q=\n"), fileContents);
1337         ::DeleteFile(tmpFile);
1338 }
1339
1340 TEST_P(CBasicGitWithTestRepoBareFixture, GetOneFile)
1341 {
1342         GetOneFile(m_Git);
1343 }
1344
1345 static void GetBranchDescriptions(CGit& m_Git)
1346 {
1347         MAP_STRING_STRING descriptions;
1348         EXPECT_EQ(0, m_Git.GetBranchDescriptions(descriptions));
1349         EXPECT_EQ(0, descriptions.size());
1350
1351         g_Git.SetConfigValue(_T("branch.master.description"), _T("test"));
1352         g_Git.SetConfigValue(_T("branch.subdir/branch.description"), _T("multi\nline"));
1353
1354         EXPECT_EQ(0, m_Git.GetBranchDescriptions(descriptions));
1355         ASSERT_EQ(2, descriptions.size());
1356         EXPECT_STREQ(_T("test"), descriptions[L"master"]);
1357         EXPECT_STREQ(_T("multi\nline"), descriptions[L"subdir/branch"]);
1358 }
1359
1360 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetBranchDescriptions)
1361 {
1362         GetBranchDescriptions(m_Git);
1363 }
1364
1365 TEST_P(CBasicGitWithEmptyBareRepositoryFixture, GetBranchDescriptions)
1366 {
1367         GetBranchDescriptions(m_Git);
1368 }
1369
1370 TEST_P(CBasicGitWithTestRepoFixture, Config)
1371 {
1372         EXPECT_STREQ(_T(""), m_Git.GetConfigValue(_T("not-found")));
1373         EXPECT_STREQ(_T("default"), m_Git.GetConfigValue(_T("not-found"), _T("default")));
1374
1375         EXPECT_STREQ(_T("false"), m_Git.GetConfigValue(_T("core.bare")));
1376         EXPECT_STREQ(_T("false"), m_Git.GetConfigValue(_T("core.bare"), _T("default-value"))); // value exist, so default does not match
1377         EXPECT_STREQ(_T("true"), m_Git.GetConfigValue(_T("core.ignorecase")));
1378         EXPECT_STREQ(_T("0"), m_Git.GetConfigValue(_T("core.repositoryformatversion")));
1379         EXPECT_STREQ(_T("https://example.com/git/testing"), m_Git.GetConfigValue(_T("remote.origin.url")));
1380
1381         EXPECT_EQ(false, m_Git.GetConfigValueBool(_T("not-found")));
1382         EXPECT_EQ(true, m_Git.GetConfigValueBool(_T("not-found"), true));
1383         EXPECT_EQ(false, m_Git.GetConfigValueBool(_T("core.bare")));
1384         EXPECT_EQ(false, m_Git.GetConfigValueBool(_T("core.bare"), true)); // value exist, so default does not match
1385         EXPECT_EQ(false, m_Git.GetConfigValueBool(_T("core.repositoryformatversion")));
1386         EXPECT_EQ(false, m_Git.GetConfigValueBool(_T("remote.origin.url")));
1387         EXPECT_EQ(true, m_Git.GetConfigValueBool(_T("core.ignorecase")));
1388
1389         CString values[] = { _T(""), _T(" "), _T("ending-with-space "), _T(" starting with-space"), _T("test1"), _T("some\\backslashes\\in\\it"), _T("with \" doublequote"), _T("with backslash before \\\" doublequote"), _T("with'quote"), _T("multi\nline"), _T("no-multi\\nline"), _T("new line at end\n") };
1390         for (int i = 0; i < _countof(values); ++i)
1391         {
1392                 CString key;
1393                 key.Format(_T("re-read.test%d"), i);
1394                 EXPECT_EQ(0, m_Git.SetConfigValue(key, values[i]));
1395                 EXPECT_STREQ(values[i], m_Git.GetConfigValue(key));
1396         }
1397
1398         m_Git.SetConfigValue(_T("booltest.true1"), _T("1"));
1399         m_Git.SetConfigValue(_T("booltest.true2"), _T("100"));
1400         m_Git.SetConfigValue(_T("booltest.true3"), _T("-2"));
1401         m_Git.SetConfigValue(_T("booltest.true4"), _T("yes"));
1402         m_Git.SetConfigValue(_T("booltest.true5"), _T("yEs"));
1403         m_Git.SetConfigValue(_T("booltest.true6"), _T("true"));
1404         m_Git.SetConfigValue(_T("booltest.true7"), _T("on"));
1405         for (int i = 1; i <= 7; ++i)
1406         {
1407                 CString key;
1408                 key.Format(_T("booltest.true%d"), i);
1409                 EXPECT_EQ(true, m_Git.GetConfigValueBool(key));
1410         }
1411         m_Git.SetConfigValue(_T("booltest.false1"), _T("0"));
1412         EXPECT_EQ(false, m_Git.GetConfigValueBool(_T("booltest.false1")));
1413         m_Git.SetConfigValue(_T("booltest.false2"), _T(""));
1414         EXPECT_EQ(false, m_Git.GetConfigValueBool(_T("booltest.false2")));
1415
1416         EXPECT_EQ(0, m_Git.GetConfigValueInt32(_T("does-not-exist")));
1417         EXPECT_EQ(15, m_Git.GetConfigValueInt32(_T("does-not-exist"), 15));
1418         EXPECT_EQ(0, m_Git.GetConfigValueInt32(_T("core.repositoryformatversion")));
1419         EXPECT_EQ(0, m_Git.GetConfigValueInt32(_T("core.repositoryformatversion"), 42)); // value exist, so default should not be returned
1420         EXPECT_EQ(1, m_Git.GetConfigValueInt32(_T("booltest.true1")));
1421         EXPECT_EQ(100, m_Git.GetConfigValueInt32(_T("booltest.true2")));
1422         EXPECT_EQ(-2, m_Git.GetConfigValueInt32(_T("booltest.true3")));
1423         EXPECT_EQ(0, m_Git.GetConfigValueInt32(_T("booltest.true4")));
1424         EXPECT_EQ(42, m_Git.GetConfigValueInt32(_T("booltest.true4"), 42));
1425         EXPECT_EQ(0, m_Git.GetConfigValueInt32(_T("booltest.true8")));
1426         EXPECT_EQ(42, m_Git.GetConfigValueInt32(_T("booltest.true8"), 42));
1427
1428         EXPECT_NE(0, m_Git.UnsetConfigValue(_T("does-not-exist")));
1429         EXPECT_STREQ(_T("false"), m_Git.GetConfigValue(_T("core.bare")));
1430         EXPECT_STREQ(_T("true"), m_Git.GetConfigValue(_T("core.ignorecase")));
1431         EXPECT_EQ(0, m_Git.UnsetConfigValue(_T("core.bare")));
1432         EXPECT_STREQ(_T("default"), m_Git.GetConfigValue(_T("core.bare"), _T("default")));
1433         EXPECT_STREQ(_T("true"), m_Git.GetConfigValue(_T("core.ignorecase")));
1434
1435         CString gitConfig = m_Git.m_CurrentDir + L"\\.git\\config";
1436         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)gitConfig, L"[booltest]\nistrue"));
1437         EXPECT_EQ(true, m_Git.GetConfigValueBool(L"booltest.istrue"));
1438
1439         // test includes from %HOME% specified as ~/
1440         EXPECT_STREQ(L"not-found", g_Git.GetConfigValue(L"test.fromincluded", L"not-found"));
1441         EXPECT_EQ(0, m_Git.SetConfigValue(L"include.path", L"~/a-path-that-should-not-exist.gconfig"));
1442         EXPECT_STREQ(L"~/a-path-that-should-not-exist.gconfig", g_Git.GetConfigValue(L"include.path", L"not-found"));
1443         CString testFile = g_Git.GetHomeDirectory() + _T("\\a-path-that-should-not-exist.gconfig");
1444         ASSERT_FALSE(PathFileExists(testFile)); // make sure we don't override a file by mistake ;)
1445         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"[test]\nfromincluded=yeah-this-is-included\n"));
1446         EXPECT_STREQ(L"yeah-this-is-included", g_Git.GetConfigValue(L"test.fromincluded", L"not-found"));
1447         EXPECT_TRUE(::DeleteFile(testFile));
1448 }
1449
1450 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges)
1451 {
1452         if (GetParam() != 0)
1453                 return;
1454
1455         // adding ansi2.txt (as a copy of ansi.txt) produces a warning
1456         m_Git.SetConfigValue(_T("core.autocrlf"), _T("false"));
1457
1458         CString output;
1459         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1460         EXPECT_FALSE(output.IsEmpty());
1461
1462         CTGitPathList filter(CTGitPath(_T("copy")));
1463
1464         // no changes
1465         CTGitPathList list;
1466         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1467         EXPECT_TRUE(list.IsEmpty());
1468         list.Clear();
1469         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1470         ASSERT_EQ(1, list.GetCount());
1471         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1472         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1473         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1474         list.Clear();
1475         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1476         EXPECT_TRUE(list.IsEmpty());
1477         list.Clear();
1478         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1479         ASSERT_EQ(1, list.GetCount());
1480         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1481         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1482         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1483
1484         // untracked file
1485         CString testFile = m_Git.m_CurrentDir + L"\\untracked-file.txt";
1486         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"*.enc filter=openssl\n"));
1487         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1488         EXPECT_TRUE(list.IsEmpty());
1489         list.Clear();
1490         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1491         ASSERT_EQ(1, list.GetCount());
1492         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1493         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1494         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1495         list.Clear();
1496         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1497         EXPECT_TRUE(list.IsEmpty());
1498         list.Clear();
1499         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1500         ASSERT_EQ(1, list.GetCount());
1501         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1502         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1503         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1504
1505         // untracked file in sub-directory
1506         testFile = m_Git.m_CurrentDir + L"\\copy\\untracked-file.txt";
1507         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"*.enc filter=openssl\n"));
1508         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1509         EXPECT_TRUE(list.IsEmpty());
1510         list.Clear();
1511         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1512         ASSERT_EQ(1, list.GetCount());
1513         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1514         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1515         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1516         list.Clear();
1517         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1518         EXPECT_TRUE(list.IsEmpty());
1519         list.Clear();
1520         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1521         ASSERT_EQ(1, list.GetCount());
1522         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1523         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1524         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1525
1526         // modified file in sub-directory
1527         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
1528         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"*.enc filter=openssl\n"));
1529         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1530         ASSERT_EQ(1, list.GetCount());
1531         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1532         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[0].GetGitPathString());
1533         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1534         list.Clear();
1535         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1536         ASSERT_EQ(2, list.GetCount());
1537         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1538         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1539         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1540         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[1].GetGitPathString());
1541         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1542         list.Clear();
1543         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1544         ASSERT_EQ(1, list.GetCount());
1545         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1546         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[0].GetGitPathString());
1547         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1548         list.Clear();
1549         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1550         ASSERT_EQ(2, list.GetCount());
1551         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1552         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1553         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1554         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[1].GetGitPathString());
1555         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1556
1557         // two modified files, one in root and one in sub-directory
1558         output.Empty();
1559         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1560         EXPECT_FALSE(output.IsEmpty());
1561         testFile = m_Git.m_CurrentDir + L"\\utf8-bom.txt";
1562         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"*.enc filter=openssl\n"));
1563         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
1564         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"*.enc filter=openssl\n"));
1565         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1566         ASSERT_EQ(2, list.GetCount());
1567         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1568         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[0].GetGitPathString());
1569         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1570         EXPECT_STREQ(_T("utf8-bom.txt"), list[1].GetGitPathString());
1571         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1572         list.Clear();
1573         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1574         ASSERT_EQ(3, list.GetCount());
1575         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1576         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1577         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1578         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[1].GetGitPathString());
1579         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1580         EXPECT_STREQ(_T("utf8-bom.txt"), list[2].GetGitPathString());
1581         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
1582         list.Clear();
1583         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1584         ASSERT_EQ(1, list.GetCount());
1585         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1586         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[0].GetGitPathString());
1587         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1588         list.Clear();
1589         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1590         ASSERT_EQ(2, list.GetCount());
1591         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1592         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1593         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1594         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[1].GetGitPathString());
1595         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1596
1597         // Staged modified file
1598         output.Empty();
1599         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1600         EXPECT_FALSE(output.IsEmpty());
1601         testFile = m_Git.m_CurrentDir + L"\\utf8-nobom.txt";
1602         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"*.enc filter=openssl\n"));
1603         output.Empty();
1604         EXPECT_EQ(0, m_Git.Run(_T("git.exe add utf8-nobom.txt"), &output, CP_UTF8));
1605         EXPECT_TRUE(output.IsEmpty());
1606         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1607         ASSERT_EQ(1, list.GetCount());
1608         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1609         EXPECT_STREQ(_T("utf8-nobom.txt"), list[0].GetGitPathString());
1610         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1611         list.Clear();
1612         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1613         ASSERT_EQ(2, list.GetCount());
1614         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1615         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1616         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1617         EXPECT_STREQ(_T("utf8-nobom.txt"), list[1].GetGitPathString());
1618         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1619         list.Clear();
1620         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1621         ASSERT_EQ(1, list.GetCount());
1622         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1623         EXPECT_STREQ(_T("utf8-nobom.txt"), list[0].GetGitPathString());
1624         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1625         list.Clear();
1626         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1627         ASSERT_EQ(2, list.GetCount());
1628         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1629         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1630         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1631         EXPECT_STREQ(_T("utf8-nobom.txt"), list[1].GetGitPathString());
1632         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1633
1634         // Staged modified file in subfolder
1635         output.Empty();
1636         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1637         EXPECT_FALSE(output.IsEmpty());
1638         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
1639         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"*.enc filter=openssl\n"));
1640         output.Empty();
1641         EXPECT_EQ(0, m_Git.Run(_T("git.exe add copy/utf8-nobom.txt"), &output, CP_UTF8));
1642         EXPECT_TRUE(output.IsEmpty());
1643         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1644         ASSERT_EQ(1, list.GetCount());
1645         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1646         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[0].GetGitPathString());
1647         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1648         list.Clear();
1649         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1650         ASSERT_EQ(2, list.GetCount());
1651         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1652         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1653         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1654         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[1].GetGitPathString());
1655         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1656         list.Clear();
1657         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1658         ASSERT_EQ(1, list.GetCount());
1659         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1660         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[0].GetGitPathString());
1661         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1662         list.Clear();
1663         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1664         ASSERT_EQ(2, list.GetCount());
1665         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1666         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1667         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1668         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[1].GetGitPathString());
1669         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1670
1671         // Modified file modified after staging
1672         output.Empty();
1673         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1674         EXPECT_FALSE(output.IsEmpty());
1675         testFile = m_Git.m_CurrentDir + L"\\copy\\utf8-nobom.txt";
1676         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"*.enc filter=openssl\n"));
1677         output.Empty();
1678         EXPECT_EQ(0, m_Git.Run(_T("git.exe add copy/utf8-nobom.txt"), &output, CP_UTF8));
1679         EXPECT_TRUE(output.IsEmpty());
1680         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"now with different content after staging"));
1681         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1682         ASSERT_EQ(1, list.GetCount());
1683         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1684         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[0].GetGitPathString());
1685         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1686         list.Clear();
1687         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1688         ASSERT_EQ(2, list.GetCount());
1689         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1690         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1691         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1692         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[1].GetGitPathString());
1693         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1694         list.Clear();
1695         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1696         ASSERT_EQ(1, list.GetCount());
1697         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1698         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[0].GetGitPathString());
1699         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1700         list.Clear();
1701         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1702         ASSERT_EQ(2, list.GetCount());
1703         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1704         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1705         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1706         EXPECT_STREQ(_T("copy/utf8-nobom.txt"), list[1].GetGitPathString());
1707         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1708
1709         // Missing file
1710         output.Empty();
1711         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1712         EXPECT_FALSE(output.IsEmpty());
1713         EXPECT_TRUE(::DeleteFile(m_Dir.GetTempDir()+_T("\\copy\\ansi.txt")));
1714         list.Clear();
1715         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1716         ASSERT_EQ(1, list.GetCount());
1717         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1718         EXPECT_STREQ(_T("copy/ansi.txt"), list[0].GetGitPathString());
1719         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
1720         list.Clear();
1721         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1722         ASSERT_EQ(2, list.GetCount());
1723         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1724         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1725         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1726         EXPECT_STREQ(_T("copy/ansi.txt"), list[1].GetGitPathString());
1727         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[1].m_Action);
1728         list.Clear();
1729         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1730         ASSERT_EQ(1, list.GetCount());
1731         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1732         EXPECT_STREQ(_T("copy/ansi.txt"), list[0].GetGitPathString());
1733         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[0].m_Action);
1734         list.Clear();
1735         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1736         ASSERT_EQ(2, list.GetCount());
1737         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1738         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1739         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1740         EXPECT_STREQ(_T("copy/ansi.txt"), list[1].GetGitPathString());
1741         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING, list[1].m_Action);
1742
1743         // deleted file, also deleted in index
1744         output.Empty();
1745         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1746         EXPECT_FALSE(output.IsEmpty());
1747         output.Empty();
1748         EXPECT_EQ(0, m_Git.Run(_T("git.exe rm copy/ansi.txt"), &output, CP_UTF8));
1749         EXPECT_FALSE(output.IsEmpty());
1750         list.Clear();
1751         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1752         ASSERT_EQ(1, list.GetCount());
1753         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1754         EXPECT_STREQ(_T("copy/ansi.txt"), list[0].GetGitPathString());
1755         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
1756         list.Clear();
1757         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1758         ASSERT_EQ(2, list.GetCount());
1759         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1760         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1761         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1762         EXPECT_STREQ(_T("copy/ansi.txt"), list[1].GetGitPathString());
1763         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
1764         list.Clear();
1765         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1766         ASSERT_EQ(1, list.GetCount());
1767         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1768         EXPECT_STREQ(_T("copy/ansi.txt"), list[0].GetGitPathString());
1769         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
1770         list.Clear();
1771         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1772         ASSERT_EQ(2, list.GetCount());
1773         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1774         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1775         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1776         EXPECT_STREQ(_T("copy/ansi.txt"), list[1].GetGitPathString());
1777         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
1778
1779         // file deleted in index, but still on disk
1780         output.Empty();
1781         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1782         EXPECT_FALSE(output.IsEmpty());
1783         output.Empty();
1784         EXPECT_EQ(0, m_Git.Run(_T("git.exe rm --cached copy/ansi.txt"), &output, CP_UTF8));
1785         EXPECT_FALSE(output.IsEmpty());
1786         list.Clear();
1787         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1788         ASSERT_EQ(1, list.GetCount());
1789         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1790         EXPECT_STREQ(_T("copy/ansi.txt"), list[0].GetGitPathString());
1791         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
1792         list.Clear();
1793         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1794         ASSERT_EQ(2, list.GetCount());
1795         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1796         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1797         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1798         EXPECT_STREQ(_T("copy/ansi.txt"), list[1].GetGitPathString());
1799         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
1800         list.Clear();
1801         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1802         ASSERT_EQ(1, list.GetCount());
1803         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1804         EXPECT_STREQ(_T("copy/ansi.txt"), list[0].GetGitPathString());
1805         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
1806         list.Clear();
1807         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1808         ASSERT_EQ(2, list.GetCount());
1809         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1810         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1811         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1812         EXPECT_STREQ(_T("copy/ansi.txt"), list[1].GetGitPathString());
1813         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
1814
1815         // file deleted in index, but still on disk, but modified
1816         output.Empty();
1817         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1818         EXPECT_FALSE(output.IsEmpty());
1819         output.Empty();
1820         EXPECT_EQ(0, m_Git.Run(_T("git.exe rm --cached copy/ansi.txt"), &output, CP_UTF8));
1821         EXPECT_FALSE(output.IsEmpty());
1822         testFile = m_Git.m_CurrentDir + L"\\copy\\ansi.txt";
1823         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"*.enc filter=openssl\n"));
1824         list.Clear();
1825         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1826         ASSERT_EQ(1, list.GetCount());
1827         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1828         EXPECT_STREQ(_T("copy/ansi.txt"), list[0].GetGitPathString());
1829         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
1830         list.Clear();
1831         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1832         ASSERT_EQ(2, list.GetCount());
1833         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1834         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1835         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1836         EXPECT_STREQ(_T("copy/ansi.txt"), list[1].GetGitPathString());
1837         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
1838         list.Clear();
1839         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1840         ASSERT_EQ(1, list.GetCount());
1841         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1842         EXPECT_STREQ(_T("copy/ansi.txt"), list[0].GetGitPathString());
1843         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[0].m_Action);
1844         list.Clear();
1845         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1846         ASSERT_EQ(2, list.GetCount());
1847         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_DELETED, list.GetAction());
1848         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1849         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1850         EXPECT_STREQ(_T("copy/ansi.txt"), list[1].GetGitPathString());
1851         EXPECT_EQ(CTGitPath::LOGACTIONS_DELETED, list[1].m_Action);
1852
1853         // renamed file in same folder
1854         output.Empty();
1855         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1856         EXPECT_FALSE(output.IsEmpty());
1857         output.Empty();
1858         EXPECT_EQ(0, m_Git.Run(_T("git.exe mv ansi.txt ansi2.txt"), &output, CP_UTF8));
1859         EXPECT_TRUE(output.IsEmpty());
1860         list.Clear();
1861         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1862         ASSERT_EQ(1, list.GetCount());
1863         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
1864         EXPECT_STREQ(_T("ansi2.txt"), list[0].GetGitPathString());
1865         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
1866         list.Clear();
1867         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1868         ASSERT_EQ(2, list.GetCount());
1869         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1870         EXPECT_STREQ(_T("ansi2.txt"), list[0].GetGitPathString());
1871         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
1872         EXPECT_STREQ(_T("ascii.txt"), list[1].GetGitPathString());
1873         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1874         list.Clear();
1875         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1876         ASSERT_EQ(1, list.GetCount());
1877         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
1878         EXPECT_STREQ(_T("ansi2.txt"), list[0].GetGitPathString());
1879         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
1880         list.Clear();
1881         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1882         ASSERT_EQ(2, list.GetCount());
1883         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
1884         EXPECT_STREQ(_T("ansi2.txt"), list[0].GetGitPathString());
1885         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
1886         EXPECT_STREQ(_T("ascii.txt"), list[1].GetGitPathString());
1887         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1888
1889         // added and staged new file
1890         output.Empty();
1891         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1892         EXPECT_FALSE(output.IsEmpty());
1893         testFile = m_Git.m_CurrentDir + L"\\copy\\test-file.txt";
1894         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"*.enc filter=openssl\n"));
1895         output.Empty();
1896         EXPECT_EQ(0, m_Git.Run(_T("git.exe add copy/test-file.txt"), &output, CP_UTF8));
1897         EXPECT_TRUE(output.IsEmpty());
1898         list.Clear();
1899         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1900         ASSERT_EQ(1, list.GetCount());
1901         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
1902         EXPECT_STREQ(_T("copy/test-file.txt"), list[0].GetGitPathString());
1903         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
1904         list.Clear();
1905         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1906         ASSERT_EQ(2, list.GetCount());
1907         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
1908         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1909         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1910         EXPECT_STREQ(_T("copy/test-file.txt"), list[1].GetGitPathString());
1911         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
1912         list.Clear();
1913         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1914         ASSERT_EQ(1, list.GetCount());
1915         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
1916         EXPECT_STREQ(_T("copy/test-file.txt"), list[0].GetGitPathString());
1917         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
1918         list.Clear();
1919         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1920         ASSERT_EQ(2, list.GetCount());
1921         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
1922         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1923         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1924         EXPECT_STREQ(_T("copy/test-file.txt"), list[1].GetGitPathString());
1925         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
1926
1927         // file copied and staged
1928         output.Empty();
1929         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1930         EXPECT_FALSE(output.IsEmpty());
1931         testFile = m_Git.m_CurrentDir + L"\\ansi.txt";
1932         EXPECT_TRUE(CopyFile(m_Git.m_CurrentDir + L"\\ansi.txt", m_Git.m_CurrentDir + L"\\ansi2.txt", TRUE));
1933         output.Empty();
1934         EXPECT_EQ(0, m_Git.Run(_T("git.exe add ansi2.txt"), &output, CP_UTF8));
1935         EXPECT_TRUE(output.IsEmpty());
1936         list.Clear();
1937         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1938         ASSERT_EQ(1, list.GetCount());
1939         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
1940         EXPECT_STREQ(_T("ansi2.txt"), list[0].GetGitPathString());
1941         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
1942         list.Clear();
1943         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1944         ASSERT_EQ(2, list.GetCount());
1945         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
1946         EXPECT_STREQ(_T("ansi2.txt"), list[0].GetGitPathString());
1947         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
1948         EXPECT_STREQ(_T("ascii.txt"), list[1].GetGitPathString());
1949         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1950         list.Clear();
1951         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1952         ASSERT_EQ(1, list.GetCount());
1953         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list.GetAction());
1954         EXPECT_STREQ(_T("ansi2.txt"), list[0].GetGitPathString());
1955         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
1956         list.Clear();
1957         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1958         ASSERT_EQ(2, list.GetCount());
1959         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
1960         EXPECT_STREQ(_T("ansi2.txt"), list[0].GetGitPathString());
1961         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
1962         EXPECT_STREQ(_T("ascii.txt"), list[1].GetGitPathString());
1963         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
1964
1965         // file renamed + moved to sub-folder
1966         output.Empty();
1967         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
1968         EXPECT_FALSE(output.IsEmpty());
1969         output.Empty();
1970         EXPECT_EQ(0, m_Git.Run(_T("git.exe mv ansi.txt copy/ansi2.txt"), &output, CP_UTF8));
1971         EXPECT_TRUE(output.IsEmpty());
1972         list.Clear();
1973         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
1974         ASSERT_EQ(1, list.GetCount());
1975         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
1976         EXPECT_STREQ(_T("copy/ansi2.txt"), list[0].GetGitPathString());
1977         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[0].m_Action);
1978         list.Clear();
1979         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
1980         ASSERT_EQ(2, list.GetCount());
1981         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_REPLACED, list.GetAction());
1982         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1983         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1984         EXPECT_STREQ(_T("copy/ansi2.txt"), list[1].GetGitPathString());
1985         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED, list[1].m_Action);
1986         list.Clear();
1987         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
1988         ASSERT_EQ(1, list.GetCount());
1989         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
1990         EXPECT_STREQ(_T("copy/ansi2.txt"), list[0].GetGitPathString());
1991         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_ADDED, list[0].m_Action); // TODO
1992         list.Clear();
1993         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
1994         ASSERT_EQ(2, list.GetCount());
1995         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
1996         EXPECT_STREQ(_T("ascii.txt"), list[0].GetGitPathString());
1997         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
1998         EXPECT_STREQ(_T("copy/ansi2.txt"), list[1].GetGitPathString());
1999         EXPECT_EQ(CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_ADDED, list[1].m_Action); // TODO
2000
2001         // conflicting files
2002         output.Empty();
2003         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
2004         EXPECT_FALSE(output.IsEmpty());
2005         output.Empty();
2006         EXPECT_EQ(0, m_Git.Run(_T("git.exe merge forconflict"), &output, CP_UTF8));
2007         EXPECT_FALSE(output.IsEmpty());
2008         output.Empty();
2009         EXPECT_EQ(1, m_Git.Run(_T("git.exe merge simple-conflict"), &output, CP_UTF8));
2010         EXPECT_FALSE(output.IsEmpty());
2011         list.Clear();
2012         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2013         ASSERT_EQ(1, list.GetCount());
2014         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2015         EXPECT_STREQ(_T("ansi.txt"), list[0].GetGitPathString());
2016         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2017         list.Clear();
2018         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2019         ASSERT_EQ(7, list.GetCount());
2020         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2021         EXPECT_STREQ(_T("ansi.txt"), list[0].GetGitPathString());
2022         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2023         EXPECT_STREQ(_T("utf16-be-bom.txt"), list[1].GetGitPathString());
2024         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2025         EXPECT_STREQ(_T("utf16-be-nobom.txt"), list[2].GetGitPathString());
2026         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
2027         EXPECT_STREQ(_T("utf16-le-bom.txt"), list[3].GetGitPathString());
2028         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
2029         EXPECT_STREQ(_T("utf16-le-nobom.txt"), list[4].GetGitPathString());
2030         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
2031         EXPECT_STREQ(_T("utf8-bom.txt"), list[5].GetGitPathString());
2032         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
2033         EXPECT_STREQ(_T("utf8-nobom.txt"), list[6].GetGitPathString());
2034         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
2035         list.Clear();
2036         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2037         ASSERT_EQ(1, list.GetCount());
2038         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list.GetAction());
2039         EXPECT_STREQ(_T("ansi.txt"), list[0].GetGitPathString());
2040         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
2041         list.Clear();
2042         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, &filter));
2043         ASSERT_EQ(7, list.GetCount());
2044         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2045         EXPECT_STREQ(_T("ansi.txt"), list[0].GetGitPathString());
2046         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
2047         EXPECT_STREQ(_T("utf16-be-bom.txt"), list[1].GetGitPathString());
2048         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2049         EXPECT_STREQ(_T("utf16-be-nobom.txt"), list[2].GetGitPathString());
2050         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
2051         EXPECT_STREQ(_T("utf16-le-bom.txt"), list[3].GetGitPathString());
2052         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
2053         EXPECT_STREQ(_T("utf16-le-nobom.txt"), list[4].GetGitPathString());
2054         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
2055         EXPECT_STREQ(_T("utf8-bom.txt"), list[5].GetGitPathString());
2056         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
2057         EXPECT_STREQ(_T("utf8-nobom.txt"), list[6].GetGitPathString());
2058         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
2059 }
2060
2061 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges_DeleteModifyConflict_DeletedRemotely)
2062 {
2063         if (GetParam() != 0)
2064                 return;
2065
2066         CString output;
2067         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
2068         EXPECT_FALSE(output.IsEmpty());
2069
2070         output.Empty();
2071         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout forconflict"), &output, CP_UTF8));
2072         EXPECT_FALSE(output.IsEmpty());
2073         output.Empty();
2074         EXPECT_EQ(0, m_Git.Run(_T("git.exe rm ansi.txt"), &output, CP_UTF8));
2075         EXPECT_FALSE(output.IsEmpty());
2076         output.Empty();
2077         EXPECT_EQ(0, m_Git.Run(_T("git.exe commit -m \"Prepare conflict case\""), &output, CP_UTF8));
2078         EXPECT_FALSE(output.IsEmpty());
2079         output.Empty();
2080         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout simple-conflict"), &output, CP_UTF8));
2081         EXPECT_FALSE(output.IsEmpty());
2082         output.Empty();
2083         EXPECT_EQ(1, m_Git.Run(_T("git.exe merge forconflict"), &output, CP_UTF8));
2084         EXPECT_FALSE(output.IsEmpty());
2085
2086         CTGitPathList filter(CTGitPath(_T("copy")));
2087
2088         CTGitPathList list;
2089         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2090         ASSERT_EQ(7, list.GetCount());
2091         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2092         EXPECT_STREQ(_T("ansi.txt"), list[0].GetGitPathString());
2093         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2094         EXPECT_STREQ(_T("utf16-be-bom.txt"), list[1].GetGitPathString());
2095         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2096         EXPECT_STREQ(_T("utf16-be-nobom.txt"), list[2].GetGitPathString());
2097         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
2098         EXPECT_STREQ(_T("utf16-le-bom.txt"), list[3].GetGitPathString());
2099         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
2100         EXPECT_STREQ(_T("utf16-le-nobom.txt"), list[4].GetGitPathString());
2101         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
2102         EXPECT_STREQ(_T("utf8-bom.txt"), list[5].GetGitPathString());
2103         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
2104         EXPECT_STREQ(_T("utf8-nobom.txt"), list[6].GetGitPathString());
2105         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
2106         list.Clear();
2107         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2108         ASSERT_EQ(7, list.GetCount());
2109         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2110         EXPECT_STREQ(_T("ansi.txt"), list[0].GetGitPathString());
2111         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2112         EXPECT_STREQ(_T("utf16-be-bom.txt"), list[1].GetGitPathString());
2113         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2114         EXPECT_STREQ(_T("utf16-be-nobom.txt"), list[2].GetGitPathString());
2115         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
2116         EXPECT_STREQ(_T("utf16-le-bom.txt"), list[3].GetGitPathString());
2117         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
2118         EXPECT_STREQ(_T("utf16-le-nobom.txt"), list[4].GetGitPathString());
2119         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
2120         EXPECT_STREQ(_T("utf8-bom.txt"), list[5].GetGitPathString());
2121         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
2122         EXPECT_STREQ(_T("utf8-nobom.txt"), list[6].GetGitPathString());
2123         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
2124         list.Clear();
2125         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2126         ASSERT_EQ(7, list.GetCount());
2127         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2128         EXPECT_STREQ(_T("ansi.txt"), list[0].GetGitPathString());
2129         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
2130         EXPECT_STREQ(_T("utf16-be-bom.txt"), list[1].GetGitPathString());
2131         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[1].m_Action);
2132         EXPECT_STREQ(_T("utf16-be-nobom.txt"), list[2].GetGitPathString());
2133         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[2].m_Action);
2134         EXPECT_STREQ(_T("utf16-le-bom.txt"), list[3].GetGitPathString());
2135         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[3].m_Action);
2136         EXPECT_STREQ(_T("utf16-le-nobom.txt"), list[4].GetGitPathString());
2137         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[4].m_Action);
2138         EXPECT_STREQ(_T("utf8-bom.txt"), list[5].GetGitPathString());
2139         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[5].m_Action);
2140         EXPECT_STREQ(_T("utf8-nobom.txt"), list[6].GetGitPathString());
2141         EXPECT_EQ(CTGitPath::LOGACTIONS_MODIFIED, list[6].m_Action);
2142 }
2143
2144 TEST_P(CBasicGitWithTestRepoFixture, GetWorkingTreeChanges_DeleteModifyConflict_DeletedLocally)
2145 {
2146         if (GetParam() != 0)
2147                 return;
2148
2149         CString output;
2150         EXPECT_EQ(0, m_Git.Run(_T("git.exe reset --hard master"), &output, CP_UTF8));
2151         EXPECT_FALSE(output.IsEmpty());
2152
2153         output.Empty();
2154         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout forconflict"), &output, CP_UTF8));
2155         EXPECT_FALSE(output.IsEmpty());
2156         output.Empty();
2157         EXPECT_EQ(0, m_Git.Run(_T("git.exe rm ansi.txt"), &output, CP_UTF8));
2158         EXPECT_FALSE(output.IsEmpty());
2159         output.Empty();
2160         EXPECT_EQ(0, m_Git.Run(_T("git.exe commit -m \"Prepare conflict case\""), &output, CP_UTF8));
2161         EXPECT_FALSE(output.IsEmpty());
2162         output.Empty();
2163         EXPECT_EQ(1, m_Git.Run(_T("git.exe merge simple-conflict"), &output, CP_UTF8));
2164         EXPECT_FALSE(output.IsEmpty());
2165
2166         CTGitPathList filter(CTGitPath(_T("copy")));
2167
2168         CTGitPathList list;
2169         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2170         ASSERT_EQ(1, list.GetCount());
2171         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED, list.GetAction());
2172         EXPECT_STREQ(_T("ansi.txt"), list[0].GetGitPathString());
2173         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2174         list.Clear();
2175         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, true, nullptr));
2176         ASSERT_EQ(1, list.GetCount());
2177         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list.GetAction());
2178         EXPECT_STREQ(_T("ansi.txt"), list[0].GetGitPathString());
2179         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED, list[0].m_Action);
2180         list.Clear();
2181         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2182         ASSERT_EQ(1, list.GetCount());
2183         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list.GetAction());
2184         EXPECT_STREQ(_T("ansi.txt"), list[0].GetGitPathString());
2185         EXPECT_EQ(CTGitPath::LOGACTIONS_UNMERGED, list[0].m_Action);
2186 }
2187
2188 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetWorkingTreeChanges)
2189 {
2190         if (GetParam() != 0)
2191                 return;
2192
2193         CTGitPathList list;
2194         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2195         EXPECT_TRUE(list.IsEmpty());
2196
2197         CString testFile = m_Dir.GetTempDir() + L"\\test.txt";
2198         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is testing file."));
2199         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2200         EXPECT_TRUE(list.IsEmpty());
2201         CString output;
2202         EXPECT_EQ(0, m_Git.Run(_T("git.exe add test.txt"), &output, CP_UTF8));
2203         EXPECT_TRUE(output.IsEmpty());
2204         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, nullptr));
2205         ASSERT_EQ(1, list.GetCount());
2206         // 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
2207         EXPECT_STREQ(_T("test.txt"), list[0].GetGitPathString());
2208         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2209
2210         CTGitPathList filter(CTGitPath(_T("copy")));
2211         list.Clear();
2212         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2213         ASSERT_EQ(1, list.GetCount());
2214         // 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
2215         EXPECT_STREQ(_T("test.txt"), list[0].GetGitPathString());
2216         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2217
2218         list.Clear();
2219         EXPECT_TRUE(::CreateDirectory(m_Dir.GetTempDir() + L"\\copy", nullptr));
2220         testFile = m_Dir.GetTempDir() + L"\\copy\\test2.txt";
2221         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is another testing file."));
2222         EXPECT_EQ(0, m_Git.Run(_T("git.exe add copy/test2.txt"), &output, CP_UTF8));
2223         EXPECT_TRUE(output.IsEmpty());
2224         EXPECT_EQ(0, m_Git.GetWorkingTreeChanges(list, false, &filter));
2225         ASSERT_EQ(2, list.GetCount());
2226         // 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
2227         EXPECT_STREQ(_T("copy/test2.txt"), list[0].GetGitPathString());
2228         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[0].m_Action);
2229         EXPECT_STREQ(_T("test.txt"), list[1].GetGitPathString());
2230         EXPECT_EQ(CTGitPath::LOGACTIONS_ADDED, list[1].m_Action);
2231 }
2232
2233 TEST_P(CBasicGitWithTestRepoFixture, GetBisectTerms)
2234 {
2235         if (m_Git.ms_bCygwinGit)
2236                 return;
2237
2238         CString good, bad;
2239         CString output;
2240
2241         EXPECT_EQ(0, m_Git.Run(_T("git.exe bisect start"), &output, CP_UTF8));
2242         m_Git.GetBisectTerms(&good, &bad);
2243         EXPECT_STREQ(_T("good"), good);
2244         EXPECT_STREQ(_T("bad"), bad);
2245
2246         good.Empty();
2247         bad.Empty();
2248         m_Git.GetBisectTerms(&good, &bad);
2249         EXPECT_STREQ(_T("good"), good);
2250         EXPECT_STREQ(_T("bad"), bad);
2251
2252         EXPECT_EQ(0, m_Git.Run(_T("git.exe bisect reset"), &output, CP_UTF8));
2253
2254         if (m_Git.GetGitVersion(nullptr, nullptr) < 0x02070000)
2255                 return;
2256
2257         EXPECT_EQ(0, m_Git.Run(_T("git.exe bisect start --term-good=original --term-bad=changed"), &output, CP_UTF8));
2258         m_Git.GetBisectTerms(&good, &bad);
2259         EXPECT_STREQ(_T("original"), good);
2260         EXPECT_STREQ(_T("changed"), bad);
2261
2262         EXPECT_EQ(0, m_Git.Run(_T("git.exe bisect reset"), &output, CP_UTF8));
2263 }