test/UnitTests/LogDataVectorTest.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2015, 2017-2020, 2023 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19
  20 #include "stdafx.h"
  21 #include "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_SUITE_P(CLogDataVector, CLogDataVectorCBasicGitWithTestRepoFixture, testing::Values(LIBGIT));
  41 INSTANTIATE_TEST_SUITE_P(CLogDataVector, CLogDataVectorCBasicGitWithTestRepoBareFixture, testing::Values(LIBGIT));
  42 INSTANTIATE_TEST_SUITE_P(CLogDataVector, CLogDataVectorCBasicGitWithEmptyRepositoryFixturee, testing::Values(LIBGIT));
  43 INSTANTIATE_TEST_SUITE_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= CGitHash::FromHexStr(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= CGitHash::FromHexStr(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 = CGitHash::FromHexStr(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44");
  75         GitRevLoglist* pRev = logCache.GetCacheData(hash1);
  76         ASSERT_TRUE(pRev);
  77         pRev->m_ParentHash.push_back(CGitHash::FromHexStr(L"0000000000000000000000000000000000000000"));
  78         EXPECT_EQ(1U, pRev->m_ParentHash.size());
  79         pRev->m_Lanes.push_back(Lanes::LaneType::ACTIVE);
  80         pRev->m_Lanes.push_back(Lanes::LaneType::NOT_ACTIVE);
  81         pRev->m_Lanes.push_back(Lanes::LaneType::MERGE_FORK);
  82         EXPECT_EQ(3U, pRev->m_Lanes.size());
  83         CGitHash hash2 = CGitHash::FromHexStr(L"dead91b4aedeaddeaddead2a56d3c473c705dead");
  84         pRev = logCache.GetCacheData(hash2);
  85         ASSERT_TRUE(pRev);
  86         pRev->m_ParentHash.push_back(CGitHash::FromHexStr(L"1111111111111111111111111111111111111111"));
  87         pRev->m_ParentHash.push_back(CGitHash::FromHexStr(L"1111111111111111111111111111111111111112"));
  88         EXPECT_EQ(2U, pRev->m_ParentHash.size());
  89         pRev->m_Lanes.push_back(Lanes::LaneType::MERGE_FORK_R);
  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 = CGitHash::FromHexStr(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44");
 108         GitRevLoglist* pRev = logCache.GetCacheData(hash1);
 109         ASSERT_TRUE(pRev);
 110         pRev->m_ParentHash.push_back(CGitHash::FromHexStr(L"0000000000000000000000000000000000000000"));
 111         EXPECT_EQ(1U, pRev->m_ParentHash.size());
 112         pRev->m_Lanes.push_back(Lanes::LaneType::ACTIVE);
 113         pRev->m_Lanes.push_back(Lanes::LaneType::NOT_ACTIVE);
 114         pRev->m_Lanes.push_back(Lanes::LaneType::MERGE_FORK);
 115         EXPECT_EQ(3U, pRev->m_Lanes.size());
 116         CGitHash hash2 = CGitHash::FromHexStr(L"dead91b4aedeaddeaddead2a56d3c473c705dead");
 117         pRev = logCache.GetCacheData(hash2);
 118         ASSERT_TRUE(pRev);
 119         pRev->m_ParentHash.push_back(CGitHash::FromHexStr(L"1111111111111111111111111111111111111111"));
 120         pRev->m_ParentHash.push_back(CGitHash::FromHexStr(L"1111111111111111111111111111111111111112"));
 121         EXPECT_EQ(2U, pRev->m_ParentHash.size());
 122         pRev->m_Lanes.push_back(Lanes::LaneType::MERGE_FORK_R);
 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         // check whether libgit ref_cache is correctly invalidated
 246         CString output;
 247         EXPECT_EQ(0, g_Git.Run(L"git.exe branch -D simple-conflict", &output, CP_UTF8)); // normal ref in refs/heads
 248         EXPECT_STRNE(L"", output);
 249         logCache.m_HashMap.clear();
 250         logDataVector.ClearAll();
 251         EXPECT_EQ(0, logDataVector.ParserFromLog(nullptr, 0, CGit::LOG_INFO_ALL_BRANCH));
 252         ASSERT_EQ(23U, logDataVector.size());
 253         EXPECT_EQ(23U, logDataVector.m_HashMap.size());
 254         EXPECT_EQ(23U, logCache.m_HashMap.size());
 255         EXPECT_STREQ(L"31ff87c86e9f6d3853e438cb151043f30f09029a", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 256         EXPECT_STREQ(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44", logDataVector.GetGitRevAt(1).m_CommitHash.ToString());
 257         EXPECT_STREQ(L"4517b91ee8f7497d40cf93d112f12196a7cec995", logDataVector.GetGitRevAt(12).m_CommitHash.ToString());
 258         EXPECT_STREQ(L"10385764a4d42d7428bbeb245015f8f338fc1e40", logDataVector.GetGitRevAt(15).m_CommitHash.ToString());
 259         EXPECT_STREQ(L"844309789a13614b52d5e7cbfe6350dd73d1dc72", logDataVector.GetGitRevAt(22).m_CommitHash.ToString());
 260         EXPECT_TRUE(logDataVector.m_HashMap.find(CGitHash::FromHexStr(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")) == logDataVector.m_HashMap.end());
 261         EXPECT_TRUE(logCache.m_HashMap.find(CGitHash::FromHexStr(L"c5b89de0335fd674e2e421ac4543098cb2f22cde")) == logCache.m_HashMap.end());
 262         output.Empty();
 263         EXPECT_EQ(0, g_Git.Run(L"git.exe branch -D forconflict", &output, CP_UTF8)); // ref in packed-refs
 264         EXPECT_STRNE(L"", output);
 265         logCache.m_HashMap.clear();
 266         logDataVector.ClearAll();
 267         EXPECT_EQ(0, logDataVector.ParserFromLog(nullptr, 0, CGit::LOG_INFO_ALL_BRANCH));
 268         ASSERT_EQ(22U, logDataVector.size());
 269         EXPECT_EQ(22U, logDataVector.m_HashMap.size());
 270         EXPECT_EQ(22U, logCache.m_HashMap.size());
 271         EXPECT_STREQ(L"31ff87c86e9f6d3853e438cb151043f30f09029a", logDataVector.GetGitRevAt(0).m_CommitHash.ToString());
 272         EXPECT_STREQ(L"4c5c93d2a0b368bc4570d5ec02ab03b9c4334d44", logDataVector.GetGitRevAt(1).m_CommitHash.ToString());
 273         EXPECT_STREQ(L"4517b91ee8f7497d40cf93d112f12196a7cec995", logDataVector.GetGitRevAt(12).m_CommitHash.ToString());
 274         EXPECT_STREQ(L"b9ef30183497cdad5c30b88d32dc1bed7951dfeb", logDataVector.GetGitRevAt(15).m_CommitHash.ToString());
 275         EXPECT_STREQ(L"844309789a13614b52d5e7cbfe6350dd73d1dc72", logDataVector.GetGitRevAt(21).m_CommitHash.ToString());
 276         EXPECT_TRUE(logDataVector.m_HashMap.find(CGitHash::FromHexStr(L"10385764a4d42d7428bbeb245015f8f338fc1e40")) == logDataVector.m_HashMap.end());
 277         EXPECT_TRUE(logCache.m_HashMap.find(CGitHash::FromHexStr(L"10385764a4d42d7428bbeb245015f8f338fc1e40")) == logCache.m_HashMap.end());
 278 }
 279
 280 TEST_P(CLogDataVectorCBasicGitWithTestRepoFixture, ParserFromLog)
 281 {
 282         ParserFromLogTests();
 283 }
 284
 285 TEST_P(CLogDataVectorCBasicGitWithTestRepoBareFixture, ParserFromLog)
 286 {
 287         ParserFromLogTests();
 288 }
 289
 290 static void ParserFromLogTests_EmptyRepo()
 291 {
 292         CLogCache logCache;
 293         CLogDataVector logDataVector;
 294         logDataVector.m_logOrderBy = CGit::LOG_ORDER_TOPOORDER;
 295         logDataVector.SetLogCache(&logCache);
 296         EXPECT_EQ(-1, logDataVector.ParserFromLog());
 297         EXPECT_EQ(0U, logDataVector.size());
 298         EXPECT_EQ(0U, logDataVector.m_HashMap.size());
 299         EXPECT_EQ(0U, logCache.m_HashMap.size());
 300 }
 301
 302 TEST_P(CLogDataVectorCBasicGitWithEmptyRepositoryFixturee, ParserFromLog)
 303 {
 304         ParserFromLogTests_EmptyRepo();
 305 }
 306
 307 TEST_P(CLogDataVectorCBasicGitWithEmptyBareRepositoryFixturee, ParserFromLog)
 308 {
 309         ParserFromLogTests_EmptyRepo();
 310 }
 311
 312 static void FillTests()
 313 {
 314         CLogCache logCache;
 315         CLogDataVector logDataVector;
 316         logDataVector.m_logOrderBy = CGit::LOG_ORDER_TOPOORDER;
 317         logDataVector.SetLogCache(&logCache);
 318
 319         std::unordered_set<CGitHash> hashes;
 320         EXPECT_EQ(0, logDataVector.Fill(hashes));
 321         EXPECT_EQ(0U, logDataVector.size());
 322         EXPECT_EQ(0U, logCache.m_HashMap.size());
 323
 324         hashes.insert(CGitHash::FromHexStr(L"35c91b4ae2f77f4f21a7aba56d3c473c705d89e6"));
 325         logCache.m_HashMap.clear();
 326         logDataVector.ClearAll();
 327         EXPECT_EQ(0, logDataVector.Fill(hashes));
 328         ASSERT_EQ(1U, logDataVector.size());
 329         EXPECT_TRUE(logDataVector.GetGitRevAt(0).m_CommitHash.ToString() == L"35c91b4ae2f77f4f21a7aba56d3c473c705d89e6");
 330         EXPECT_EQ(1U, logCache.m_HashMap.size());
 331
 332         hashes.insert(CGitHash::FromHexStr(L"7c3cbfe13a929d2291a574dca45e4fd2d2ac1aa6"));
 333         logCache.m_HashMap.clear();
 334         logDataVector.ClearAll();
 335         EXPECT_EQ(0, logDataVector.Fill(hashes));
 336         EXPECT_EQ(2U, logDataVector.size());
 337         EXPECT_EQ(2U, logCache.m_HashMap.size());
 338
 339         hashes.insert(CGitHash::FromHexStr(L"dead91b4aedeaddeaddead2a56d3c473c705dead")); // non-existent commit
 340         logCache.m_HashMap.clear();
 341         logDataVector.ClearAll();
 342         EXPECT_EQ(-1, logDataVector.Fill(hashes));
 343         EXPECT_EQ(0U, logDataVector.size());
 344         // size of logCache.m_HashMap.size() depends on the order of the set
 345 }
 346
 347
 348 TEST_P(CLogDataVectorCBasicGitWithTestRepoFixture, Fill)
 349 {
 350         FillTests();
 351 }
 352
 353 TEST_P(CLogDataVectorCBasicGitWithTestRepoBareFixture, Fill)
 354 {
 355         FillTests();
 356 }