test/UnitTests/GitTest.cpp

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