test/UnitTests/LogDataVectorTest.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2015, 2017-2018 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19
  20 #include "stdafx.h"
  21 #include "RepositoryFixtures.h"
  22 #include "LogDlgHelper.h"
  23
  24 class CLogDataVectorCBasicGitWithTestRepoFixture : public CBasicGitWithTestRepoFixture
  25 {
  26 };
  27
  28 class CLogDataVectorCBasicGitWithEmptyRepositoryFixturee : public CBasicGitWithEmptyRepositoryFixture
  29 {
  30 };
  31
  32 class CLogDataVectorCBasicGitWithTestRepoBareFixture : public CBasicGitWithTestRepoBareFixture
  33 {
  34 };
  35
  36 class CLogDataVectorCBasicGitWithEmptyBareRepositoryFixturee : public CBasicGitWithEmptyBareRepositoryFixture
  37 {
  38 };
  39
  40 INSTANTIATE_TEST_CASE_P(CLogDataVector, CLogDataVectorCBasicGitWithTestRepoFixture, testing::Values(LIBGIT));
  41 INSTANTIATE_TEST_CASE_P(CLogDataVector, CLogDataVectorCBasicGitWithTestRepoBareFixture, testing::Values(LIBGIT));
  42 INSTANTIATE_TEST_CASE_P(CLogDataVector, CLogDataVectorCBasicGitWithEmptyRepositoryFixturee, testing::Values(LIBGIT));
  43 INSTANTIATE_TEST_CASE_P(CLogDataVector, CLogDataVectorCBasicGitWithEmptyBareRepositoryFixturee, testing::Values(LIBGIT));
  44
  45 TEST(CLogDataVector, Empty)
  46 {
  47         CLogDataVector logDataVector;
  48         logDataVector.m_logOrderBy = CGit::LOG_ORDER_TOPOORDER;
  49
  50         EXPECT_EQ(0U, logDataVector.size());
  51         EXPECT_EQ(0U, logDataVector.m_HashMap.size());
  52 }
  53
  54 TEST(CLogCache, GetCacheData)
  55 {
  56         CLogCache logCache;
  57         EXPECT_EQ(0U, logCache.m_HashMap.size());
  58         CGitHash hash1(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44");
  59         GitRevLoglist* pRev = logCache.GetCacheData(hash1);
  60         ASSERT_TRUE(pRev);
  61         EXPECT_EQ(hash1, pRev->m_CommitHash);
  62         EXPECT_EQ(1U, logCache.m_HashMap.size());
  63
  64         CGitHash hash2(L"dead91b4aedeaddeaddead2a56d3c473c705dead");
  65         pRev = logCache.GetCacheData(hash2);
  66         ASSERT_TRUE(pRev);
  67         EXPECT_EQ(hash2, pRev->m_CommitHash);
  68         EXPECT_EQ(2U, logCache.m_HashMap.size());
  69 }
  70
  71 TEST(CLogCache, ClearAllParent)
  72 {
  73         CLogCache logCache;
  74         CGitHash hash1(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44");
  75         GitRevLoglist* pRev = logCache.GetCacheData(hash1);
  76         ASSERT_TRUE(pRev);
  77         pRev->m_ParentHash.push_back(CGitHash(L"0000000000000000000000000000000000000000"));
  78         EXPECT_EQ(1U, pRev->m_ParentHash.size());
  79         pRev->m_Lanes.push_back(1);
  80         pRev->m_Lanes.push_back(2);
  81         pRev->m_Lanes.push_back(3);
  82         EXPECT_EQ(3U, pRev->m_Lanes.size());
  83         CGitHash hash2(L"dead91b4aedeaddeaddead2a56d3c473c705dead");
  84         pRev = logCache.GetCacheData(hash2);
  85         ASSERT_TRUE(pRev);
  86         pRev->m_ParentHash.push_back(CGitHash(L"1111111111111111111111111111111111111111"));
  87         pRev->m_ParentHash.push_back(CGitHash(L"1111111111111111111111111111111111111112"));
  88         EXPECT_EQ(2U, pRev->m_ParentHash.size());
  89         pRev->m_Lanes.push_back(4);
  90         EXPECT_EQ(1U, pRev->m_Lanes.size());
  91
  92         logCache.ClearAllParent();
  93         pRev = logCache.GetCacheData(hash1);
  94         ASSERT_TRUE(pRev);
  95         EXPECT_EQ(0U, pRev->m_ParentHash.size());
  96         EXPECT_EQ(0U, pRev->m_Lanes.size());
  97
  98         pRev = logCache.GetCacheData(hash2);
  99         ASSERT_TRUE(pRev);
 100         EXPECT_EQ(0U, pRev->m_ParentHash.size());
 101         EXPECT_EQ(0U, pRev->m_Lanes.size());
 102 }
 103
 104 TEST(CLogCache, ClearAllLanes)
 105 {
 106         CLogCache logCache;
 107         CGitHash hash1(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44");
 108         GitRevLoglist* pRev = logCache.GetCacheData(hash1);
 109         ASSERT_TRUE(pRev);
 110         pRev->m_ParentHash.push_back(CGitHash(L"0000000000000000000000000000000000000000"));
 111         EXPECT_EQ(1U, pRev->m_ParentHash.size());
 112         pRev->m_Lanes.push_back(1);
 113         pRev->m_Lanes.push_back(2);
 114         pRev->m_Lanes.push_back(3);
 115         EXPECT_EQ(3U, pRev->m_Lanes.size());
 116         CGitHash hash2(L"dead91b4aedeaddeaddead2a56d3c473c705dead");
 117         pRev = logCache.GetCacheData(hash2);
 118         ASSERT_TRUE(pRev);
 119         pRev->m_ParentHash.push_back(CGitHash(L"1111111111111111111111111111111111111111"));
 120         pRev->m_ParentHash.push_back(CGitHash(L"1111111111111111111111111111111111111112"));
 121         EXPECT_EQ(2U, pRev->m_ParentHash.size());
 122         pRev->m_Lanes.push_back(4);
 123         EXPECT_EQ(1U, pRev->m_Lanes.size());
 124
 125         logCache.ClearAllLanes();
 126         pRev = logCache.GetCacheData(hash1);
 127         ASSERT_TRUE(pRev);
 128         EXPECT_EQ(1U, pRev->m_ParentHash.size());
 129         EXPECT_EQ(0U, pRev->m_Lanes.size());
 130
 131         pRev = logCache.GetCacheData(hash2);
 132         ASSERT_TRUE(pRev);
 133         EXPECT_EQ(2U, pRev->m_ParentHash.size());
 134         EXPECT_EQ(0U, pRev->m_Lanes.size());
 135 }
 136
 137 static void ParserFromLogTests()
 138 {
 139         CLogCache logCache;
 140         CLogDataVector logDataVector;
 141         logDataVector.m_logOrderBy = CGit::LOG_ORDER_TOPOORDER;
 142         logDataVector.SetLogCache(&logCache);
 143
 144         EXPECT_EQ(0, logDataVector.ParserFromLog());
 145         EXPECT_EQ(12U, logDataVector.size());
 146         EXPECT_EQ(12U, logDataVector.m_HashMap.size());
 147         EXPECT_EQ(12U, logCache.m_HashMap.size());
 148
 149         logCache.m_HashMap.clear();
 150         logDataVector.ClearAll();
 151         EXPECT_EQ(0U, logDataVector.size());
 152         EXPECT_EQ(0U, logDataVector.m_HashMap.size());
 153         EXPECT_EQ(0U, logCache.m_HashMap.size());
 154
 155         EXPECT_EQ(0, logDataVector.ParserFromLog(nullptr, 5));
 156         ASSERT_EQ(5U, logDataVector.size());
 157         EXPECT_EQ(5U, logDataVector.m_HashMap.size());
 158         EXPECT_EQ(5U, logCache.m_HashMap.size());
 159         EXPECT_STREQ(L"Changed ASCII file", logDataVector.GetGitRevAt(0).GetSubject());
 160         EXPECT_STREQ(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 161         EXPECT_STREQ(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd", logDataVector.GetGitRevAt(2).m_CommitHash.ToString());
 162         EXPECT_STREQ(L"560deea87853158b22d0c0fd73f60a458d47838a", logDataVector.GetGitRevAt(4).m_CommitHash.ToString());
 163
 164         logCache.m_HashMap.clear();
 165         logDataVector.ClearAll();
 166         EXPECT_EQ(0, logDataVector.ParserFromLog(nullptr, 0, CGit::LOG_INFO_ALL_BRANCH));
 167         ASSERT_EQ(24U, logDataVector.size());
 168         EXPECT_EQ(24U, logDataVector.m_HashMap.size());
 169         EXPECT_EQ(24U, logCache.m_HashMap.size());
 170         EXPECT_STREQ(L"31ff87c86e9f6d3853e438cb151043f30f09029a", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 171         EXPECT_STREQ(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44", logDataVector.GetGitRevAt(1).m_CommitHash.ToString());
 172         EXPECT_STREQ(L"4517b91ee8f7497d40cf93d112f12196a7cec995", logDataVector.GetGitRevAt(12).m_CommitHash.ToString());
 173         EXPECT_STREQ(L"c5b89de0335fd674e2e421ac4543098cb2f22cde", logDataVector.GetGitRevAt(15).m_CommitHash.ToString());
 174         EXPECT_STREQ(L"844309789a13614b52d5e7cbfe6350dd73d1dc72", logDataVector.GetGitRevAt(23).m_CommitHash.ToString());
 175
 176         logCache.m_HashMap.clear();
 177         logDataVector.ClearAll();
 178         CString range(L"does-not-exist");
 179         EXPECT_EQ(-1, logDataVector.ParserFromLog(nullptr, 0, CGit::LOG_INFO_ALL_BRANCH, &range));
 180         EXPECT_EQ(0U, logDataVector.size());
 181         EXPECT_EQ(0U, logDataVector.m_HashMap.size());
 182         EXPECT_EQ(0U, logCache.m_HashMap.size());
 183
 184         EXPECT_EQ(-1, logDataVector.ParserFromLog(nullptr, 0, 0, &range));
 185         EXPECT_EQ(0U, logDataVector.size());
 186         EXPECT_EQ(0U, logDataVector.m_HashMap.size());
 187         EXPECT_EQ(0U, logCache.m_HashMap.size());
 188
 189         logCache.m_HashMap.clear();
 190         logDataVector.ClearAll();
 191         range = L"master2..master";
 192         EXPECT_EQ(0, logDataVector.ParserFromLog(nullptr, 0, 0, &range));
 193         ASSERT_EQ(2U, logDataVector.size());
 194         EXPECT_EQ(2U, logDataVector.m_HashMap.size());
 195         EXPECT_EQ(2U, logCache.m_HashMap.size());
 196         EXPECT_STREQ(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 197         EXPECT_STREQ(L"1fc3c9688e27596d8717b54f2939dc951568f6cb", logDataVector.GetGitRevAt(1).m_CommitHash.ToString());
 198
 199         logCache.m_HashMap.clear();
 200         logDataVector.ClearAll();
 201         EXPECT_EQ(0, logDataVector.ParserFromLog(nullptr, 0, CGit::LOG_INFO_ALL_BRANCH, &range)); // useless test?, all branches has higher precedence
 202         ASSERT_EQ(24U, logDataVector.size());
 203         EXPECT_EQ(24U, logDataVector.m_HashMap.size());
 204         EXPECT_EQ(24U, logCache.m_HashMap.size());
 205
 206         logCache.m_HashMap.clear();
 207         logDataVector.ClearAll();
 208         CTGitPath path(L"does-not-exist.txt");
 209         EXPECT_EQ(0, logDataVector.ParserFromLog(&path));
 210         EXPECT_EQ(0U, logDataVector.size());
 211         EXPECT_EQ(0U, logDataVector.m_HashMap.size());
 212         EXPECT_EQ(0U, logCache.m_HashMap.size());
 213
 214         logCache.m_HashMap.clear();
 215         logDataVector.ClearAll();
 216         path = CTGitPath(L"copy/utf16-be-bom.txt");
 217         EXPECT_EQ(0, logDataVector.ParserFromLog(&path));
 218         ASSERT_EQ(2U, logDataVector.size());
 219         EXPECT_EQ(2U, logDataVector.m_HashMap.size());
 220         EXPECT_EQ(2U, logCache.m_HashMap.size());
 221         EXPECT_STREQ(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 222         EXPECT_STREQ(L"560deea87853158b22d0c0fd73f60a458d47838a", logDataVector.GetGitRevAt(1).m_CommitHash.ToString());
 223
 224         logCache.m_HashMap.clear();
 225         logDataVector.ClearAll();
 226         EXPECT_EQ(0, logDataVector.ParserFromLog(&path, 0, CGit::LOG_INFO_FOLLOW));
 227         ASSERT_EQ(4U, logDataVector.size());
 228         EXPECT_EQ(4U, logDataVector.m_HashMap.size());
 229         EXPECT_EQ(4U, logCache.m_HashMap.size());
 230         EXPECT_STREQ(L"49ecdfff36bfe2b9b499b33e5034f427e2fa54dd", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 231         EXPECT_STREQ(L"560deea87853158b22d0c0fd73f60a458d47838a", logDataVector.GetGitRevAt(1).m_CommitHash.ToString());
 232         EXPECT_STREQ(L"ff1fbef1a54a9849afd4a5e94d2ca4d80d5b96c2", logDataVector.GetGitRevAt(3).m_CommitHash.ToString());
 233
 234         logCache.m_HashMap.clear();
 235         logDataVector.ClearAll();
 236         range = L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44";
 237         EXPECT_EQ(0, logDataVector.ParserFromLog(&path, 0, CGit::LOG_INFO_FOLLOW, &range));
 238         ASSERT_EQ(3U, logDataVector.size());
 239         EXPECT_EQ(3U, logDataVector.m_HashMap.size());
 240         EXPECT_EQ(3U, logCache.m_HashMap.size());
 241         EXPECT_STREQ(L"560deea87853158b22d0c0fd73f60a458d47838a", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 242         EXPECT_STREQ(L"a9d53b535cb49640a6099860ac4999f5a0857b91", logDataVector.GetGitRevAt(1).m_CommitHash.ToString());
 243         EXPECT_STREQ(L"ff1fbef1a54a9849afd4a5e94d2ca4d80d5b96c2", logDataVector.GetGitRevAt(2).m_CommitHash.ToString());
 244
 245         logCache.m_HashMap.clear();
 246         logDataVector.ClearAll();
 247         EXPECT_EQ(0, logDataVector.ParserFromLog(&path, 0, CGit::LOG_INFO_FULL_DIFF, &range));
 248         ASSERT_EQ(1U, logDataVector.size());
 249         EXPECT_EQ(1U, logDataVector.m_HashMap.size());
 250         EXPECT_EQ(1U, logCache.m_HashMap.size());
 251         EXPECT_STREQ(L"560deea87853158b22d0c0fd73f60a458d47838a", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 252
 253         // check whether libgit ref_cache is correctly invalidated
 254         CString output;
 255         EXPECT_EQ(0, g_Git.Run(L"git.exe branch -D simple-conflict", &output, CP_UTF8)); // normal ref in refs/heads
 256         EXPECT_STRNE(L"", output);
 257         logCache.m_HashMap.clear();
 258         logDataVector.ClearAll();
 259         EXPECT_EQ(0, logDataVector.ParserFromLog(nullptr, 0, CGit::LOG_INFO_ALL_BRANCH));
 260         ASSERT_EQ(23U, logDataVector.size());
 261         EXPECT_EQ(23U, logDataVector.m_HashMap.size());
 262         EXPECT_EQ(23U, logCache.m_HashMap.size());
 263         EXPECT_STREQ(L"31ff87c86e9f6d3853e438cb151043f30f09029a", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 264         EXPECT_STREQ(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44", logDataVector.GetGitRevAt(1).m_CommitHash.ToString());
 265         EXPECT_STREQ(L"4517b91ee8f7497d40cf93d112f12196a7cec995", logDataVector.GetGitRevAt(12).m_CommitHash.ToString());
 266         EXPECT_STREQ(L"10385764a4d42d7428bbeb245015f8f338fc1e40", logDataVector.GetGitRevAt(15).m_CommitHash.ToString());
 267         EXPECT_STREQ(L"844309789a13614b52d5e7cbfe6350dd73d1dc72", logDataVector.GetGitRevAt(22).m_CommitHash.ToString());
 268         EXPECT_TRUE(logDataVector.m_HashMap.find(CGitHash(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")) == logDataVector.m_HashMap.end());
 269         EXPECT_TRUE(logCache.m_HashMap.find(CGitHash(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")) == logCache.m_HashMap.end());
 270         output.Empty();
 271         EXPECT_EQ(0, g_Git.Run(L"git.exe branch -D forconflict", &output, CP_UTF8)); // ref in packed-refs
 272         EXPECT_STRNE(L"", output);
 273         logCache.m_HashMap.clear();
 274         logDataVector.ClearAll();
 275         EXPECT_EQ(0, logDataVector.ParserFromLog(nullptr, 0, CGit::LOG_INFO_ALL_BRANCH));
 276         ASSERT_EQ(22U, logDataVector.size());
 277         EXPECT_EQ(22U, logDataVector.m_HashMap.size());
 278         EXPECT_EQ(22U, logCache.m_HashMap.size());
 279         EXPECT_STREQ(L"31ff87c86e9f6d3853e438cb151043f30f09029a", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 280         EXPECT_STREQ(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44", logDataVector.GetGitRevAt(1).m_CommitHash.ToString());
 281         EXPECT_STREQ(L"4517b91ee8f7497d40cf93d112f12196a7cec995", logDataVector.GetGitRevAt(12).m_CommitHash.ToString());
 282         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", logDataVector.GetGitRevAt(15).m_CommitHash.ToString());
 283         EXPECT_STREQ(L"844309789a13614b52d5e7cbfe6350dd73d1dc72", logDataVector.GetGitRevAt(21).m_CommitHash.ToString());
 284         EXPECT_TRUE(logDataVector.m_HashMap.find(CGitHash(L"10385764a4d42d7428bbeb245015f8f338fc1e40")) == logDataVector.m_HashMap.end());
 285         EXPECT_TRUE(logCache.m_HashMap.find(CGitHash(L"10385764a4d42d7428bbeb245015f8f338fc1e40")) == logCache.m_HashMap.end());
 286 }
 287
 288 TEST_P(CLogDataVectorCBasicGitWithTestRepoFixture, ParserFromLog)
 289 {
 290         ParserFromLogTests();
 291 }
 292
 293 TEST_P(CLogDataVectorCBasicGitWithTestRepoBareFixture, ParserFromLog)
 294 {
 295         ParserFromLogTests();
 296 }
 297
 298 static void ParserFromLogTests_EmptyRepo()
 299 {
 300         CLogCache logCache;
 301         CLogDataVector logDataVector;
 302         logDataVector.m_logOrderBy = CGit::LOG_ORDER_TOPOORDER;
 303         logDataVector.SetLogCache(&logCache);
 304         EXPECT_EQ(-1, logDataVector.ParserFromLog());
 305         EXPECT_EQ(0U, logDataVector.size());
 306         EXPECT_EQ(0U, logDataVector.m_HashMap.size());
 307         EXPECT_EQ(0U, logCache.m_HashMap.size());
 308 }
 309
 310 TEST_P(CLogDataVectorCBasicGitWithEmptyRepositoryFixturee, ParserFromLog)
 311 {
 312         ParserFromLogTests_EmptyRepo();
 313 }
 314
 315 TEST_P(CLogDataVectorCBasicGitWithEmptyBareRepositoryFixturee, ParserFromLog)
 316 {
 317         ParserFromLogTests_EmptyRepo();
 318 }
 319
 320 static void FillTests()
 321 {
 322         CLogCache logCache;
 323         CLogDataVector logDataVector;
 324         logDataVector.m_logOrderBy = CGit::LOG_ORDER_TOPOORDER;
 325         logDataVector.SetLogCache(&logCache);
 326
 327         std::unordered_set<CGitHash> hashes;
 328         EXPECT_EQ(0, logDataVector.Fill(hashes));
 329         EXPECT_EQ(0U, logDataVector.size());
 330         EXPECT_EQ(0U, logCache.m_HashMap.size());
 331
 332         hashes.insert(CGitHash(L"35c91b4ae2f77f4f21a7aba56d3c473c705d89e6"));
 333         logCache.m_HashMap.clear();
 334         logDataVector.ClearAll();
 335         EXPECT_EQ(0, logDataVector.Fill(hashes));
 336         ASSERT_EQ(1U, logDataVector.size());
 337         EXPECT_TRUE(logDataVector.GetGitRevAt(0).m_CommitHash.ToString() == L"35c91b4ae2f77f4f21a7aba56d3c473c705d89e6");
 338         EXPECT_EQ(1U, logCache.m_HashMap.size());
 339
 340         hashes.insert(CGitHash(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6"));
 341         logCache.m_HashMap.clear();
 342         logDataVector.ClearAll();
 343         EXPECT_EQ(0, logDataVector.Fill(hashes));
 344         EXPECT_EQ(2U, logDataVector.size());
 345         EXPECT_EQ(2U, logCache.m_HashMap.size());
 346
 347         hashes.insert(CGitHash(L"dead91b4aedeaddeaddead2a56d3c473c705dead")); // non-existent commit
 348         logCache.m_HashMap.clear();
 349         logDataVector.ClearAll();
 350         EXPECT_EQ(-1, logDataVector.Fill(hashes));
 351         EXPECT_EQ(0U, logDataVector.size());
 352         // size of logCache.m_HashMap.size() depends on the order of the set
 353 }
 354
 355
 356 TEST_P(CLogDataVectorCBasicGitWithTestRepoFixture, Fill)
 357 {
 358         FillTests();
 359 }
 360
 361 TEST_P(CLogDataVectorCBasicGitWithTestRepoBareFixture, Fill)
 362 {
 363         FillTests();
 364 }