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         ASSERT_EQ(2, cgit.Run(_T("git-not-found.exe"), &output, CP_UTF8));
  57         ASSERT_TRUE(output.IsEmpty());
  58
  59         output.Empty();
  60         ASSERT_EQ(128, cgit.Run(_T("git.exe add file.txt"), &output, CP_UTF8));
  61         ASSERT_TRUE(output.Find(_T("fatal: Not a git repository (or any of the parent directories): .git")) == 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         STRING_VECTOR list;
 487         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 488         EXPECT_EQ(5, list.size());
 489         list.clear();
 490         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 491         EXPECT_EQ(5, list.size());
 492
 493         EXPECT_STREQ(_T("HEAD"), m_Git.FixBranchName(_T("HEAD")));
 494         EXPECT_STREQ(_T("master"), m_Git.FixBranchName(_T("master")));
 495         EXPECT_STREQ(_T("non-existing"), m_Git.FixBranchName(_T("non-existing")));
 496         CString branch = _T("master");
 497         EXPECT_STREQ(_T("master"), m_Git.FixBranchName_Mod(branch));
 498         EXPECT_STREQ(_T("master"), branch);
 499         branch = _T("non-existing");
 500         EXPECT_STREQ(_T("non-existing"), m_Git.FixBranchName_Mod(branch));
 501         EXPECT_STREQ(_T("non-existing"), branch);
 502         CGitHash hash;
 503         EXPECT_NE(0, m_Git.GetHash(hash, _T("FETCH_HEAD")));
 504
 505         CString testFile = m_Git.m_CurrentDir + L"\\.git\\FETCH_HEAD";
 506         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"));
 507
 508         list.clear();
 509         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr));
 510         EXPECT_EQ(5, list.size());
 511         list.clear();
 512         EXPECT_EQ(0, m_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL_F));
 513         EXPECT_EQ(isBare ? 5 : 6, list.size());
 514
 515         EXPECT_STREQ(_T("master"), m_Git.FixBranchName(_T("master")));
 516         EXPECT_STREQ(_T("non-existing"), m_Git.FixBranchName(_T("non-existing")));
 517         if (!isBare)
 518                 EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), m_Git.FixBranchName(_T("FETCH_HEAD")));
 519         branch = _T("HEAD");
 520         EXPECT_STREQ(_T("HEAD"), m_Git.FixBranchName_Mod(branch));
 521         EXPECT_STREQ(_T("HEAD"), branch);
 522         branch = _T("master");
 523         EXPECT_STREQ(_T("master"), m_Git.FixBranchName_Mod(branch));
 524         EXPECT_STREQ(_T("master"), branch);
 525         branch = _T("non-existing");
 526         EXPECT_STREQ(_T("non-existing"), m_Git.FixBranchName_Mod(branch));
 527         EXPECT_STREQ(_T("non-existing"), branch);
 528         if (!isBare)
 529         {
 530                 branch = _T("FETCH_HEAD");
 531                 EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), m_Git.FixBranchName_Mod(branch));
 532                 EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), branch);
 533                 EXPECT_EQ(0, m_Git.GetHash(hash, _T("FETCH_HEAD")));
 534                 EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), hash.ToString());
 535         }
 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(isBare ? 5 : 6, list.size());
 545
 546         if (!isBare)
 547         {
 548                 EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), m_Git.FixBranchName(_T("FETCH_HEAD")));
 549                 branch = _T("FETCH_HEAD");
 550                 EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), m_Git.FixBranchName_Mod(branch));
 551                 EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), branch);
 552                 // libgit2 fails here
 553                 // EXPECT_EQ(0, m_Git.GetHash(hash, _T("FETCH_HEAD")));
 554                 // EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), hash.ToString());
 555         }
 556 }
 557
 558 TEST_P(CBasicGitWithTestRepoFixture, FETCHHEAD)
 559 {
 560         FETCHHEAD(m_Git, false);
 561 }
 562
 563 TEST_P(CBasicGitWithTestRepoBareFixture, FETCHHEAD)
 564 {
 565         FETCHHEAD(m_Git, true);
 566 }
 567
 568 TEST_P(CBasicGitWithTestRepoFixture, IsFastForward)
 569 {
 570         CGitHash commonAncestor;
 571         EXPECT_TRUE(m_Git.IsFastForward(_T("origin/master"), _T("master"), &commonAncestor));
 572         EXPECT_STREQ(_T("a9d53b535cb49640a6099860ac4999f5a0857b91"), commonAncestor.ToString());
 573
 574         EXPECT_FALSE(m_Git.IsFastForward(_T("simple-conflict"), _T("master"), &commonAncestor));
 575         EXPECT_STREQ(_T("b02add66f48814a73aa2f0876d6bbc8662d6a9a8"), commonAncestor.ToString());
 576 }
 577
 578 static void GetHash(CGit& m_Git)
 579 {
 580         CGitHash hash;
 581         EXPECT_EQ(0, m_Git.GetHash(hash, _T("HEAD")));
 582         EXPECT_STREQ(_T("7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6"), hash.ToString());
 583         EXPECT_EQ(0, m_Git.GetHash(hash, _T("HEAD~1")));
 584         EXPECT_STREQ(_T("1fc3c9688e27596d8717b54f2939dc951568f6cb"), hash.ToString());
 585         EXPECT_EQ(0, m_Git.GetHash(hash, _T("ff1fbef1a54a9849afd4a5e94d2ca4d80d5b96c2")));
 586         EXPECT_STREQ(_T("ff1fbef1a54a9849afd4a5e94d2ca4d80d5b96c2"), hash.ToString());
 587         EXPECT_EQ(0, m_Git.GetHash(hash, _T("master")));
 588         EXPECT_STREQ(_T("7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6"), hash.ToString());
 589         EXPECT_EQ(0, m_Git.GetHash(hash, _T("origin/master")));
 590         EXPECT_STREQ(_T("a9d53b535cb49640a6099860ac4999f5a0857b91"), hash.ToString());
 591         EXPECT_EQ(0, m_Git.GetHash(hash, _T("49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")));
 592         EXPECT_STREQ(_T("49ecdfff36bfe2b9b499b33e5034f427e2fa54dd"), hash.ToString());
 593         EXPECT_EQ(0, m_Git.GetHash(hash, _T("normal-tag")));
 594         EXPECT_STREQ(_T("b9ef30183497cdad5c30b88d32dc1bed7951dfeb"), hash.ToString());
 595         EXPECT_EQ(0, m_Git.GetHash(hash, _T("all-files-signed")));
 596         EXPECT_STREQ(_T("ab555b2776c6b700ad93848d0dd050e7d08be779"), hash.ToString()); // maybe we need automatically to dereference it
 597         EXPECT_EQ(0, m_Git.GetHash(hash, _T("all-files-signed^{}")));
 598         EXPECT_STREQ(_T("313a41bc88a527289c87d7531802ab484715974f"), hash.ToString());
 599
 600         EXPECT_NE(0, m_Git.GetHash(hash, _T("non-existing")));
 601 }
 602
 603 TEST_P(CBasicGitWithTestRepoFixture, GetHash)
 604 {
 605         GetHash(m_Git);
 606 }
 607
 608 TEST_P(CBasicGitWithTestRepoBareFixture, GetHash)
 609 {
 610         GetHash(m_Git);
 611 }
 612
 613 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetHash_EmptyRepo)
 614 {
 615         CGitHash hash;
 616         EXPECT_EQ(0, m_Git.GetHash(hash, _T("HEAD")));
 617         EXPECT_TRUE(hash.IsEmpty());
 618 }
 619
 620 TEST_P(CBasicGitWithEmptyRepositoryFixture, GetEmptyBranchesTagsRefs)
 621 {
 622         STRING_VECTOR branches;
 623         int current = -2;
 624         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
 625         EXPECT_TRUE(branches.empty());
 626         EXPECT_EQ(-2, current); // not touched
 627
 628         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
 629         EXPECT_TRUE(branches.empty());
 630         EXPECT_EQ(-2, current); // not touched
 631
 632         STRING_VECTOR tags;
 633         EXPECT_EQ(0, m_Git.GetTagList(tags));
 634         EXPECT_TRUE(tags.empty());
 635
 636         STRING_VECTOR refs;
 637         EXPECT_EQ(0, m_Git.GetRefList(refs));
 638         EXPECT_TRUE(refs.empty());
 639
 640         MAP_HASH_NAME map;
 641         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
 642         EXPECT_TRUE(map.empty());
 643
 644         STRING_VECTOR remotes;
 645         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
 646         EXPECT_TRUE(remotes.empty());
 647 }
 648
 649 static void GetBranchesTagsRefs(CGit& m_Git, config testConfig)
 650 {
 651         STRING_VECTOR branches;
 652         int current = -2;
 653         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
 654         ASSERT_EQ(5, branches.size());
 655         EXPECT_EQ(1, current);
 656         EXPECT_STREQ(_T("forconflict"), branches[0]);
 657         EXPECT_STREQ(_T("master"), branches[1]);
 658         EXPECT_STREQ(_T("master2"), branches[2]);
 659         EXPECT_STREQ(_T("simple-conflict"), branches[3]);
 660         EXPECT_STREQ(_T("subdir/branch"), branches[4]);
 661
 662         branches.clear();
 663         current = -2;
 664         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
 665         ASSERT_EQ(6, branches.size());
 666         EXPECT_EQ(1, current);
 667         EXPECT_STREQ(_T("forconflict"), branches[0]);
 668         EXPECT_STREQ(_T("master"), branches[1]);
 669         EXPECT_STREQ(_T("master2"), branches[2]);
 670         EXPECT_STREQ(_T("simple-conflict"), branches[3]);
 671         EXPECT_STREQ(_T("subdir/branch"), branches[4]);
 672         EXPECT_STREQ(_T("remotes/origin/master"), branches[5]);
 673
 674         branches.clear();
 675         current = -2;
 676         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_REMOTE));
 677         ASSERT_EQ(1, branches.size());
 678         EXPECT_EQ(-2, current); // not touched
 679         EXPECT_STREQ(_T("remotes/origin/master"), branches[0]);
 680
 681         STRING_VECTOR tags;
 682         EXPECT_EQ(0, m_Git.GetTagList(tags));
 683         ASSERT_EQ(3, tags.size());
 684         EXPECT_STREQ(_T("all-files-signed"), tags[0]);
 685         EXPECT_STREQ(_T("also-signed"), tags[1]);
 686         EXPECT_STREQ(_T("normal-tag"), tags[2]);
 687
 688         STRING_VECTOR refs;
 689         EXPECT_EQ(0, m_Git.GetRefList(refs));
 690         ASSERT_EQ(11, refs.size());
 691         EXPECT_STREQ(_T("refs/heads/forconflict"), refs[0]);
 692         EXPECT_STREQ(_T("refs/heads/master"), refs[1]);
 693         EXPECT_STREQ(_T("refs/heads/master2"), refs[2]);
 694         EXPECT_STREQ(_T("refs/heads/simple-conflict"), refs[3]);
 695         EXPECT_STREQ(_T("refs/heads/subdir/branch"), refs[4]);
 696         EXPECT_STREQ(_T("refs/notes/commits"), refs[5]);
 697         EXPECT_STREQ(_T("refs/remotes/origin/master"), refs[6]);
 698         EXPECT_STREQ(_T("refs/stash"), refs[7]);
 699         EXPECT_STREQ(_T("refs/tags/all-files-signed"), refs[8]);
 700         EXPECT_STREQ(_T("refs/tags/also-signed"), refs[9]);
 701         EXPECT_STREQ(_T("refs/tags/normal-tag"), refs[10]);
 702
 703         MAP_HASH_NAME map;
 704         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
 705         if (testConfig == GIT_CLI)
 706                 ASSERT_EQ(12, map.size()); // also contains the undereferenced tags with hashes
 707         else
 708                 ASSERT_EQ(10, map.size());
 709
 710         ASSERT_EQ(1, map[CGitHash(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6")].size());
 711         EXPECT_STREQ(_T("refs/heads/master"), map[CGitHash(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6")][0]);
 712         ASSERT_EQ(1, map[CGitHash(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44")].size());
 713         EXPECT_STREQ(_T("refs/heads/subdir/branch"), map[CGitHash(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44")][0]);
 714         ASSERT_EQ(1, map[CGitHash(L"5e702e1712aa6f8cd8e0328a87be006f3a923710")].size());
 715         EXPECT_STREQ(_T("refs/notes/commits"), map[CGitHash(L"5e702e1712aa6f8cd8e0328a87be006f3a923710")][0]);
 716         ASSERT_EQ(1, map[CGitHash(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb")].size());
 717         EXPECT_STREQ(_T("refs/stash"), map[CGitHash(L"18da7c332dcad0f37f9977d9176dce0b0c66f3eb")][0]);
 718         ASSERT_EQ(1, map[CGitHash(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")].size());
 719         EXPECT_STREQ(_T("refs/heads/simple-conflict"), map[CGitHash(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")][0]);
 720         ASSERT_EQ(1, map[CGitHash(L"10385764a4d42d7428bbeb245015f8f338fc1e40")].size());
 721         EXPECT_STREQ(_T("refs/heads/forconflict"), map[CGitHash(L"10385764a4d42d7428bbeb245015f8f338fc1e40")][0]);
 722         ASSERT_EQ(2, map[CGitHash(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")].size());
 723         EXPECT_STREQ(_T("refs/heads/master2"), map[CGitHash(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")][0]);
 724         EXPECT_STREQ(_T("refs/tags/also-signed^{}"), map[CGitHash(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd")][1]);
 725         ASSERT_EQ(1, map[CGitHash(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb")].size());//
 726         EXPECT_STREQ(_T("refs/tags/normal-tag"), map[CGitHash(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb")][0]);
 727         ASSERT_EQ(1, map[CGitHash(L"a9d53b535cb49640a6099860ac4999f5a0857b91")].size());
 728         EXPECT_STREQ(_T("refs/remotes/origin/master"), map[CGitHash(L"a9d53b535cb49640a6099860ac4999f5a0857b91")][0]);
 729         ASSERT_EQ(1, map[CGitHash(L"313a41bc88a527289c87d7531802ab484715974f")].size());
 730         EXPECT_STREQ(_T("refs/tags/all-files-signed^{}"), map[CGitHash(L"313a41bc88a527289c87d7531802ab484715974f")][0]);
 731
 732         STRING_VECTOR remotes;
 733         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
 734         ASSERT_EQ(1, remotes.size());
 735         EXPECT_STREQ(_T("origin"), remotes[0]);
 736
 737         EXPECT_EQ(-1, m_Git.DeleteRef(_T("refs/tags/gibbednet")));
 738         branches.clear();
 739         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 740         EXPECT_EQ(6, branches.size());
 741         tags.clear();
 742         EXPECT_EQ(0, m_Git.GetTagList(tags));
 743         EXPECT_EQ(3, tags.size());
 744         refs.clear();
 745         EXPECT_EQ(0, m_Git.GetRefList(refs));
 746         EXPECT_EQ(11, refs.size());
 747
 748         EXPECT_EQ(-1, m_Git.DeleteRef(_T("refs/heads/gibbednet")));
 749         branches.clear();
 750         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 751         EXPECT_EQ(6, branches.size());
 752         tags.clear();
 753         EXPECT_EQ(0, m_Git.GetTagList(tags));
 754         EXPECT_EQ(3, tags.size());
 755         refs.clear();
 756         EXPECT_EQ(0, m_Git.GetRefList(refs));
 757         EXPECT_EQ(11, refs.size());
 758
 759         EXPECT_EQ(-1, m_Git.DeleteRef(_T("refs/remotes/origin/gibbednet")));
 760         branches.clear();
 761         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 762         EXPECT_EQ(6, branches.size());
 763         tags.clear();
 764         EXPECT_EQ(0, m_Git.GetTagList(tags));
 765         EXPECT_EQ(3, tags.size());
 766         refs.clear();
 767         EXPECT_EQ(0, m_Git.GetRefList(refs));
 768         EXPECT_EQ(11, refs.size());
 769
 770         EXPECT_EQ(0, m_Git.DeleteRef(_T("refs/tags/normal-tag")));
 771         branches.clear();
 772         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 773         EXPECT_EQ(6, branches.size());
 774         tags.clear();
 775         EXPECT_EQ(0, m_Git.GetTagList(tags));
 776         EXPECT_EQ(2, tags.size());
 777         refs.clear();
 778         EXPECT_EQ(0, m_Git.GetRefList(refs));
 779         EXPECT_EQ(10, refs.size());
 780
 781         EXPECT_EQ(0, m_Git.DeleteRef(_T("refs/tags/all-files-signed^{}")));
 782         branches.clear();
 783         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 784         EXPECT_EQ(6, branches.size());
 785         tags.clear();
 786         EXPECT_EQ(0, m_Git.GetTagList(tags));
 787         EXPECT_EQ(1, tags.size());
 788         refs.clear();
 789         EXPECT_EQ(0, m_Git.GetRefList(refs));
 790         EXPECT_EQ(9, refs.size());
 791
 792         EXPECT_EQ(0, m_Git.DeleteRef(_T("refs/heads/subdir/branch")));
 793         branches.clear();
 794         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 795         EXPECT_EQ(5, branches.size());
 796         tags.clear();
 797         EXPECT_EQ(0, m_Git.GetTagList(tags));
 798         EXPECT_EQ(1, tags.size());
 799         refs.clear();
 800         EXPECT_EQ(0, m_Git.GetRefList(refs));
 801         EXPECT_EQ(8, refs.size());
 802
 803         EXPECT_EQ(0, m_Git.DeleteRef(_T("refs/remotes/origin/master")));
 804         branches.clear();
 805         EXPECT_EQ(0, m_Git.GetBranchList(branches, nullptr, CGit::BRANCH_ALL));
 806         EXPECT_EQ(4, branches.size());
 807         tags.clear();
 808         EXPECT_EQ(0, m_Git.GetTagList(tags));
 809         EXPECT_EQ(1, tags.size());
 810         refs.clear();
 811         EXPECT_EQ(0, m_Git.GetRefList(refs));
 812         EXPECT_EQ(7, refs.size());
 813 }
 814
 815 TEST_P(CBasicGitWithTestRepoFixture, GetBranchesTagsRefs)
 816 {
 817         GetBranchesTagsRefs(m_Git, GetParam());
 818 }
 819
 820 TEST_P(CBasicGitWithTestRepoBareFixture, GetBranchesTagsRefs)
 821 {
 822         GetBranchesTagsRefs(m_Git, GetParam());
 823 }
 824
 825 TEST_P(CBasicGitWithTestRepoFixture, GetBranchList_orphan)
 826 {
 827         CString output;
 828         EXPECT_EQ(0, m_Git.Run(_T("git.exe checkout --orphan orphanic"), &output, CP_UTF8));
 829         EXPECT_FALSE(output.IsEmpty());
 830
 831         STRING_VECTOR branches;
 832         int current = -2;
 833         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
 834         ASSERT_EQ(5, branches.size());
 835         EXPECT_EQ(-2, current);
 836         EXPECT_STREQ(_T("forconflict"), branches[0]);
 837         EXPECT_STREQ(_T("master"), branches[1]);
 838         EXPECT_STREQ(_T("master2"), branches[2]);
 839         EXPECT_STREQ(_T("simple-conflict"), branches[3]);
 840         EXPECT_STREQ(_T("subdir/branch"), branches[4]);
 841 }
 842
 843 TEST_P(CBasicGitWithEmptyBareRepositoryFixture, GetEmptyBranchesTagsRefs)
 844 {
 845         EXPECT_STREQ(_T("master"), m_Git.GetCurrentBranch());
 846
 847         STRING_VECTOR branches;
 848         int current = -2;
 849         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current));
 850         EXPECT_TRUE(branches.empty());
 851         EXPECT_EQ(-2, current); // not touched
 852
 853         EXPECT_EQ(0, m_Git.GetBranchList(branches, &current, CGit::BRANCH_ALL));
 854         EXPECT_TRUE(branches.empty());
 855         EXPECT_EQ(-2, current); // not touched
 856
 857         STRING_VECTOR tags;
 858         EXPECT_EQ(0, m_Git.GetTagList(tags));
 859         EXPECT_TRUE(tags.empty());
 860
 861         STRING_VECTOR refs;
 862         EXPECT_EQ(0, m_Git.GetRefList(refs));
 863         EXPECT_TRUE(refs.empty());
 864
 865         MAP_HASH_NAME map;
 866         EXPECT_EQ(0, m_Git.GetMapHashToFriendName(map));
 867         EXPECT_TRUE(map.empty());
 868
 869         STRING_VECTOR remotes;
 870         EXPECT_EQ(0, m_Git.GetRemoteList(remotes));
 871         EXPECT_TRUE(remotes.empty());
 872 }
 873
 874 TEST_P(CBasicGitWithEmptyRepositoryFixture, CheckCleanWorkTree)
 875 {
 876         CString output;
 877         CString testFile = m_Dir.GetTempDir() + L"\\test.txt";
 878         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is testing file."));
 879         EXPECT_EQ(0, m_Git.Run(_T("git.exe add test.txt"), &output, CP_UTF8));
 880         output.Empty();
 881         EXPECT_EQ(0, m_Git.Run(_T("git.exe commit -m \"Add test.txt\""), &output, CP_UTF8));
 882         // repo with 1 versioned file
 883         EXPECT_FALSE(output.IsEmpty());
 884         EXPECT_TRUE(m_Git.CheckCleanWorkTree());
 885         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
 886
 887         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"Overwriting this testing file."));
 888         // repo with 1 modified versioned file
 889         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
 890         EXPECT_FALSE(m_Git.CheckCleanWorkTree(true));
 891
 892         output.Empty();
 893         EXPECT_EQ(0, m_Git.Run(_T("git.exe add test.txt"), &output, CP_UTF8));
 894         // repo with 1 modified versioned and staged file
 895         EXPECT_TRUE(output.IsEmpty());
 896         EXPECT_FALSE(m_Git.CheckCleanWorkTree());
 897         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
 898
 899         EXPECT_EQ(0, m_Git.Run(_T("git.exe commit -m \"Modified test.txt\""), &output, CP_UTF8));
 900         testFile = m_Dir.GetTempDir() + L"\\test2.txt";
 901         EXPECT_TRUE(CStringUtils::WriteStringToTextFile((LPCTSTR)testFile, L"this is ANOTHER testing file."));
 902         EXPECT_TRUE(m_Git.CheckCleanWorkTree());
 903         EXPECT_TRUE(m_Git.CheckCleanWorkTree(true));
 904 }