kdenlive/tests/regressions.cpp

0001 /*
0002     SPDX-FileCopyrightText: 2017-2022 Jean-Baptiste Mardelle <jb@kdenlive.org>
0003     SPDX-FileCopyrightText: 2017-2019 Nicolas Carion <french.ebook.lover@gmail.com>
0004     SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
0005 */
0006
0007 #include "test_utils.hpp"
0008 // test specific headers
0009 #include "doc/kdenlivedoc.h"
0010
0011 TEST_CASE("Regression")
0012 {
0013     auto binModel = pCore->projectItemModel();
0014     binModel->clean();
0015     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
0016
0017     // Here we do some trickery to enable testing.
0018     // We mock the project class so that the undoStack function returns our undoStack
0019     KdenliveDoc document(undoStack);
0020     Mock<KdenliveDoc> docMock(document);
0021     KdenliveDoc &mockedDoc = docMock.get();
0022     Mock<ProjectManager> pmMock;
0023     When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
0024     When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
0025     When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
0026
0027     ProjectManager &mocked = pmMock.get();
0028     pCore->m_projectManager = &mocked;
0029
0030     // We also mock timeline object to spy few functions and mock others
0031     TimelineItemModel tim(mockedDoc.uuid(), undoStack);
0032     Mock<TimelineItemModel> timMock(tim);
0033     auto timeline = std::shared_ptr<TimelineItemModel>(&timMock.get(), [](...) {});
0034     TimelineItemModel::finishConstruct(timeline);
0035     pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline);
0036
0037     RESET(timMock);
0038     KdenliveDoc::next_id = 0;
0039     undoStack->undo();
0040     undoStack->redo();
0041     undoStack->redo();
0042     undoStack->undo();
0043     QString binId0 = createProducer(pCore->getProjectProfile(), "red", binModel);
0044     int c = ClipModel::construct(timeline, binId0, -1, PlaylistState::VideoOnly);
0045     timeline->m_allClips[c]->m_endlessResize = false;
0046     TrackModel::construct(timeline);
0047     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0048     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0049     REQUIRE(timeline->requestClipMove(0, 1, 0));
0050     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0051     REQUIRE(timeline->requestItemResize(0, 16, false));
0052     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0053     undoStack->undo();
0054     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0055     undoStack->redo();
0056     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0057     undoStack->undo();
0058     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0059     undoStack->redo();
0060     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0061     undoStack->undo();
0062     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0063     undoStack->redo();
0064     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0065     REQUIRE(timeline->requestItemResize(0, 0, false) == -1);
0066     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0067     TrackModel::construct(timeline);
0068     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0069     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0070     undoStack->undo();
0071     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0072     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0073     undoStack->redo();
0074     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0075     pCore->taskManager.slotCancelJobs();
0076     mockedDoc.closing = true;
0077     timeline.reset();
0078     binModel->clean();
0079 }
0080
0081 TEST_CASE("Regression2")
0082 {
0083     auto binModel = pCore->projectItemModel();
0084     binModel->clean();
0085     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
0086
0087     // Here we do some trickery to enable testing.
0088     // We mock the project class so that the undoStack function returns our undoStack
0089     KdenliveDoc document(undoStack);
0090     Mock<KdenliveDoc> docMock(document);
0091     KdenliveDoc &mockedDoc = docMock.get();
0092     Mock<ProjectManager> pmMock;
0093     When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
0094     When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
0095     When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
0096
0097     ProjectManager &mocked = pmMock.get();
0098     pCore->m_projectManager = &mocked;
0099
0100     // We also mock timeline object to spy few functions and mock others
0101     TimelineItemModel tim(mockedDoc.uuid(), undoStack);
0102     Mock<TimelineItemModel> timMock(tim);
0103     auto timeline = std::shared_ptr<TimelineItemModel>(&timMock.get(), [](...) {});
0104     TimelineItemModel::finishConstruct(timeline);
0105     pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline);
0106
0107     RESET(timMock);
0108     KdenliveDoc::next_id = 0;
0109     int dummy_id;
0110     undoStack->undo();
0111     undoStack->undo();
0112     undoStack->redo();
0113     TrackModel::construct(timeline);
0114     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0115     undoStack->undo();
0116     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0117     {
0118         QString binId0 = createProducer(pCore->getProjectProfile(), "red", binModel);
0119         bool ok = timeline->requestClipInsertion(binId0, 0, 10, dummy_id);
0120         timeline->m_allClips[dummy_id]->m_endlessResize = false;
0121         REQUIRE(ok);
0122     }
0123     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0124     undoStack->undo();
0125     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0126     undoStack->redo();
0127     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0128     TrackModel::construct(timeline);
0129     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0130     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0131     {
0132         QString binId0 = createProducer(pCore->getProjectProfile(), "red", binModel);
0133         bool ok = timeline->requestClipInsertion(binId0, 2, 10, dummy_id);
0134         timeline->m_allClips[3]->m_endlessResize = false;
0135         REQUIRE(ok);
0136     }
0137     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0138     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0139     {
0140         bool ok = timeline->requestClipMove(1, 0, 10);
0141         REQUIRE(ok);
0142     }
0143     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0144     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0145     undoStack->undo();
0146     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0147     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0148     undoStack->redo();
0149     timeline->m_allClips[3]->m_endlessResize = false;
0150     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0151     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0152     {
0153         REQUIRE(timeline->requestItemResize(3, 0, false) == -1);
0154     }
0155     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0156     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0157     TrackModel::construct(timeline);
0158     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0159     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0160     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0161     {
0162         QString binId0 = createProducer(pCore->getProjectProfile(), "red", binModel);
0163         int c = ClipModel::construct(timeline, binId0, -1, PlaylistState::VideoOnly);
0164         timeline->m_allClips[c]->m_endlessResize = false;
0165     }
0166     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0167     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0168     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0169     TrackModel::construct(timeline);
0170     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0171     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0172     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0173     REQUIRE(timeline->getTrackById(6)->checkConsistency());
0174     {
0175         REQUIRE(timeline->requestItemResize(3, 15, true) > -1);
0176     }
0177     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0178     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0179     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0180     REQUIRE(timeline->getTrackById(6)->checkConsistency());
0181     {
0182         bool ok = timeline->requestClipMove(3, 0, 0);
0183         REQUIRE_FALSE(ok);
0184     }
0185     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0186     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0187     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0188     REQUIRE(timeline->getTrackById(6)->checkConsistency());
0189     {
0190         REQUIRE(timeline->requestItemResize(3, 16, false) == -1);
0191     }
0192     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0193     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0194     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0195     REQUIRE(timeline->getTrackById(6)->checkConsistency());
0196     {
0197         REQUIRE(timeline->requestItemResize(3, 16, true) > -1);
0198     }
0199     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0200     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0201     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0202     REQUIRE(timeline->getTrackById(6)->checkConsistency());
0203     undoStack->undo();
0204     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0205     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0206     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0207     REQUIRE(timeline->getTrackById(6)->checkConsistency());
0208     undoStack->undo();
0209     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0210     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0211     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0212     REQUIRE(timeline->getTrackById(6)->checkConsistency());
0213     {
0214         QString binId0 = createProducer(pCore->getProjectProfile(), "red", binModel);
0215         bool ok = timeline->requestClipInsertion(binId0, 0, 1, dummy_id);
0216         REQUIRE_FALSE(ok);
0217     }
0218     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0219     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0220     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0221     REQUIRE(timeline->getTrackById(6)->checkConsistency());
0222     undoStack->undo();
0223     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0224     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0225     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0226     REQUIRE(timeline->getTrackById(6)->checkConsistency());
0227     undoStack->redo();
0228     REQUIRE(timeline->getTrackById(0)->checkConsistency());
0229     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0230     REQUIRE(timeline->getTrackById(4)->checkConsistency());
0231     REQUIRE(timeline->getTrackById(6)->checkConsistency());
0232     undoStack->redo();
0233     pCore->taskManager.slotCancelJobs();
0234     mockedDoc.closing = true;
0235     timeline.reset();
0236     binModel->clean();
0237 }
0238
0239 /*
0240 TEST_CASE("Regression 3")
0241 {
0242     Mlt::Profile profile;
0243     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
0244     std::shared_ptr<TimelineModel> timeline = TimelineItemModel::construct(new Mlt::Profile(), undoStack);
0245     KdenliveDoc::next_id = 0;
0246     int dummy_id;
0247     std::shared_ptr<Mlt::Producer> producer0 = std::make_shared<Mlt::Producer>(profile, "color", "red");
0248     producer0->set("length", 20);
0249     producer0->set("out", 19);
0250     ClipModel::construct(timeline, producer0 );
0251     {
0252         bool ok = timeline->requestTrackInsertion(-1, dummy_id);
0253         REQUIRE(ok);
0254     }
0255     TrackModel::construct(timeline);
0256     TrackModel::construct(timeline);
0257     std::shared_ptr<Mlt::Producer> producer1 = std::make_shared<Mlt::Producer>(profile, "color", "red");
0258     producer1->set("length", 20);
0259     producer1->set("out", 19);
0260     ClipModel::construct(timeline, producer1 );
0261     std::shared_ptr<Mlt::Producer> producer2 = std::make_shared<Mlt::Producer>(profile, "color", "red");
0262     producer2->set("length", 20);
0263     producer2->set("out", 19);
0264     ClipModel::construct(timeline, producer2 );
0265     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0266     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0267     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0268     std::shared_ptr<Mlt::Producer> producer3 = std::make_shared<Mlt::Producer>(profile, "color", "red");
0269     producer3->set("length", 20);
0270     producer3->set("out", 19);
0271     ClipModel::construct(timeline, producer3 );
0272     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0273     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0274     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0275     TrackModel::construct(timeline);
0276     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0277     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0278     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0279     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0280     TrackModel::construct(timeline);
0281     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0282     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0283     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0284     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0285     REQUIRE(timeline->getTrackById(8)->checkConsistency());
0286     TrackModel::construct(timeline);
0287     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0288     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0289     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0290     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0291     REQUIRE(timeline->getTrackById(8)->checkConsistency());
0292     REQUIRE(timeline->getTrackById(9)->checkConsistency());
0293     std::shared_ptr<Mlt::Producer> producer4 = std::make_shared<Mlt::Producer>(profile, "color", "red");
0294     producer4->set("length", 20);
0295     producer4->set("out", 19);
0296     ClipModel::construct(timeline, producer4 );
0297     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0298     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0299     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0300     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0301     REQUIRE(timeline->getTrackById(8)->checkConsistency());
0302     REQUIRE(timeline->getTrackById(9)->checkConsistency());
0303     std::shared_ptr<Mlt::Producer> producer5 = std::make_shared<Mlt::Producer>(profile, "color", "red");
0304     producer5->set("length", 20);
0305     producer5->set("out", 19);
0306     ClipModel::construct(timeline, producer5 );
0307     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0308     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0309     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0310     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0311     REQUIRE(timeline->getTrackById(8)->checkConsistency());
0312     REQUIRE(timeline->getTrackById(9)->checkConsistency());
0313     std::shared_ptr<Mlt::Producer> producer6 = std::make_shared<Mlt::Producer>(profile, "color", "red");
0314     producer6->set("length", 20);
0315     producer6->set("out", 19);
0316     ClipModel::construct(timeline, producer6 );
0317     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0318     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0319     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0320     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0321     REQUIRE(timeline->getTrackById(8)->checkConsistency());
0322     REQUIRE(timeline->getTrackById(9)->checkConsistency());
0323     {
0324         bool ok = timeline->requestClipMove(0,1 ,10 );
0325         REQUIRE(ok);
0326     }
0327     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0328     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0329     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0330     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0331     REQUIRE(timeline->getTrackById(8)->checkConsistency());
0332     REQUIRE(timeline->getTrackById(9)->checkConsistency());
0333     {
0334         bool ok = timeline->requestClipMove(4,2 ,12 );
0335         REQUIRE(ok);
0336     }
0337     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0338     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0339     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0340     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0341     REQUIRE(timeline->getTrackById(8)->checkConsistency());
0342     REQUIRE(timeline->getTrackById(9)->checkConsistency());
0343     {
0344         auto group = {4, 0};
0345         bool ok = timeline->requestClipsGroup(group);
0346         REQUIRE(ok);
0347     }
0348     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0349     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0350     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0351     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0352     REQUIRE(timeline->getTrackById(8)->checkConsistency());
0353     REQUIRE(timeline->getTrackById(9)->checkConsistency());
0354     {
0355         bool ok = timeline->requestClipMove(4,1 ,10 );
0356         REQUIRE_FALSE(ok);
0357     }
0358     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0359     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0360     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0361     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0362     REQUIRE(timeline->getTrackById(8)->checkConsistency());
0363     REQUIRE(timeline->getTrackById(9)->checkConsistency());
0364     {
0365         bool ok = timeline->requestClipMove(4,1 ,100 );
0366         REQUIRE_FALSE(ok);
0367     }
0368     REQUIRE(timeline->getTrackById(1)->checkConsistency());
0369     REQUIRE(timeline->getTrackById(2)->checkConsistency());
0370     REQUIRE(timeline->getTrackById(3)->checkConsistency());
0371     REQUIRE(timeline->getTrackById(7)->checkConsistency());
0372     REQUIRE(timeline->getTrackById(8)->checkConsistency());
0373     REQUIRE(timeline->getTrackById(9)->checkConsistency());
0374     {
0375         bool ok = timeline->requestClipMove(0,3 ,100 );
0376         REQUIRE(ok);
0377     }
0378     std::shared_ptr<Mlt::Producer> producer7 = std::make_shared<Mlt::Producer>(profile, "color", "red");
0379     producer7->set("length", 20);
0380     producer7->set("out", 19);
0381     ClipModel::construct(timeline, producer7 );
0382     {
0383         bool ok = timeline->requestTrackInsertion(-1, dummy_id);
0384         REQUIRE(ok);
0385     }
0386     undoStack->undo();
0387     {
0388         bool ok = timeline->requestClipMove(0,1 ,5 );
0389         REQUIRE(ok);
0390     }
0391     {
0392         bool ok = timeline->requestTrackDeletion(1);
0393         REQUIRE(ok);
0394     }
0395 }
0396
0397 TEST_CASE("Regression 4")
0398 {
0399     Mlt::Profile profile;
0400     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
0401     std::shared_ptr<TimelineModel> timeline = TimelineItemModel::construct(new Mlt::Profile(), undoStack);
0402     KdenliveDoc::next_id = 0;
0403     int dummy_id;
0404     timeline->requestTrackInsertion(-1, dummy_id );
0405     timeline->requestTrackInsertion(-1, dummy_id );
0406     timeline->requestTrackInsertion(-1, dummy_id );
0407     timeline->requestTrackInsertion(-1, dummy_id );
0408     timeline->requestTrackInsertion(-1, dummy_id );
0409     timeline->requestTrackInsertion(-1, dummy_id );
0410     timeline->requestTrackInsertion(-1, dummy_id );
0411     timeline->requestTrackInsertion(-1, dummy_id );
0412     timeline->requestTrackInsertion(-1, dummy_id );
0413     timeline->requestTrackInsertion(-1, dummy_id );
0414     timeline->requestTrackInsertion(-1, dummy_id );
0415     {
0416         std::shared_ptr<Mlt::Producer> producer = std::make_shared<Mlt::Producer>(profile, "color", "red");
0417         producer->set("length", 62);
0418         producer->set("out", 61);
0419         timeline->requestClipInsertion(producer,10 ,453, dummy_id );
0420     }
0421     timeline->requestClipMove(11,10 ,453, true, true );
0422     {
0423         std::shared_ptr<Mlt::Producer> producer = std::make_shared<Mlt::Producer>(profile, "color", "red");
0424         producer->set("length", 62);
0425         producer->set("out", 61);
0426         timeline->requestClipInsertion(producer,9 ,590, dummy_id );
0427     }
0428     timeline->requestItemResize(11,62 ,true, false, true );
0429     timeline->requestItemResize(11,62 ,true, true, true );
0430     timeline->requestClipMove(11,10 ,507, true, true );
0431     timeline->requestClipMove(12,10 ,583, false, false );
0432     timeline->requestClipMove(12,9 ,521, true, true );
0433 }
0434 */
0435
0436 TEST_CASE("FuzzBug1")
0437 {
0438     auto binModel = pCore->projectItemModel();
0439     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
0440     KdenliveDoc::next_id = 0;
0441     {
0442         KdenliveDoc document(undoStack);
0443         Mock<KdenliveDoc> docMock(document);
0444         KdenliveDoc &mockedDoc = docMock.get();
0445         Mock<ProjectManager> pmMock;
0446         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
0447         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
0448         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
0449
0450         ProjectManager &mocked = pmMock.get();
0451         pCore->m_projectManager = &mocked;
0452
0453         // We also mock timeline object to spy few functions and mock others
0454         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
0455         Mock<TimelineItemModel> timMock_0(tim);
0456         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
0457         TimelineItemModel::finishConstruct(timeline_0);
0458         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
0459         mocked.m_activeTimelineModel = timeline_0;
0460         Fake(Method(timMock_0, adjustAssetRange));
0461         REQUIRE(timeline_0->checkConsistency());
0462         undoStack->undo();
0463         REQUIRE(timeline_0->checkConsistency());
0464         undoStack->redo();
0465         REQUIRE(timeline_0->checkConsistency());
0466         TrackModel::construct(timeline_0, -1, -1, "", false);
0467         REQUIRE(timeline_0->checkConsistency());
0468         undoStack->undo();
0469         REQUIRE(timeline_0->checkConsistency());
0470         undoStack->redo();
0471         REQUIRE(timeline_0->checkConsistency());
0472         TrackModel::construct(timeline_0, -1, -1, "$$$", false);
0473         REQUIRE(timeline_0->checkConsistency());
0474         undoStack->undo();
0475         REQUIRE(timeline_0->checkConsistency());
0476         undoStack->redo();
0477         REQUIRE(timeline_0->checkConsistency());
0478         {
0479             bool res = timeline_0->requestTrackDeletion(2);
0480             REQUIRE(res == true);
0481         }
0482         REQUIRE(timeline_0->checkConsistency());
0483         undoStack->undo();
0484         REQUIRE(timeline_0->checkConsistency());
0485         undoStack->redo();
0486         REQUIRE(timeline_0->checkConsistency());
0487         {
0488             bool res = timeline_0->requestTrackDeletion(1);
0489             // Cannot delete last track
0490             REQUIRE(res == false);
0491         }
0492         REQUIRE(timeline_0->checkConsistency());
0493         undoStack->undo();
0494         REQUIRE(timeline_0->checkConsistency());
0495         undoStack->redo();
0496         REQUIRE(timeline_0->checkConsistency());
0497         {
0498             int dummy_1;
0499             bool res = timeline_0->requestTrackInsertion(-1, dummy_1, "", false);
0500             REQUIRE(res == true);
0501         }
0502         REQUIRE(timeline_0->checkConsistency());
0503         undoStack->undo();
0504         REQUIRE(timeline_0->checkConsistency());
0505         undoStack->redo();
0506         REQUIRE(timeline_0->checkConsistency());
0507         {
0508             int dummy_1;
0509             bool res = timeline_0->requestTrackInsertion(-1, dummy_1, "", false);
0510             REQUIRE(res == true);
0511         }
0512         REQUIRE(timeline_0->checkConsistency());
0513         undoStack->undo();
0514         REQUIRE(timeline_0->checkConsistency());
0515         undoStack->redo();
0516         REQUIRE(timeline_0->checkConsistency());
0517         createProducer(pCore->getProjectProfile(), "red", binModel, 20, true);
0518         REQUIRE(timeline_0->checkConsistency());
0519         undoStack->undo();
0520         REQUIRE(timeline_0->checkConsistency());
0521         undoStack->redo();
0522         REQUIRE(timeline_0->checkConsistency());
0523         {
0524             int dummy_3;
0525             bool res = timeline_0->requestClipInsertion("2", 3, 0, dummy_3, true, false, true);
0526             REQUIRE(res == true);
0527         }
0528         REQUIRE(timeline_0->checkConsistency());
0529         undoStack->undo();
0530         REQUIRE(timeline_0->checkConsistency());
0531         undoStack->redo();
0532         REQUIRE(timeline_0->checkConsistency());
0533         {
0534             int dummy_3;
0535             bool res = timeline_0->requestClipInsertion("2", 3, 20, dummy_3, true, false, true);
0536             REQUIRE(res == true);
0537         }
0538         REQUIRE(timeline_0->checkConsistency());
0539         undoStack->undo();
0540         REQUIRE(timeline_0->checkConsistency());
0541         undoStack->redo();
0542         REQUIRE(timeline_0->checkConsistency());
0543         {
0544             int dummy_3;
0545             bool res = timeline_0->requestClipInsertion("2", 3, 40, dummy_3, true, false, true);
0546             REQUIRE(res == true);
0547         }
0548         REQUIRE(timeline_0->checkConsistency());
0549         undoStack->undo();
0550         REQUIRE(timeline_0->checkConsistency());
0551         undoStack->redo();
0552         REQUIRE(timeline_0->checkConsistency());
0553         {
0554             int res = timeline_0->requestClipsGroup({5, 7}, true, GroupType::Normal);
0555             REQUIRE(res == 8);
0556         }
0557         REQUIRE(timeline_0->checkConsistency());
0558         undoStack->undo();
0559         REQUIRE(timeline_0->checkConsistency());
0560         undoStack->redo();
0561         REQUIRE(timeline_0->checkConsistency());
0562         {
0563             int res = timeline_0->requestClipsGroup({6, 7}, true, GroupType::Normal);
0564             REQUIRE(res == 9);
0565         }
0566         REQUIRE(timeline_0->checkConsistency());
0567         undoStack->undo();
0568         REQUIRE(timeline_0->checkConsistency());
0569         undoStack->redo();
0570         REQUIRE(timeline_0->checkConsistency());
0571         {
0572             int res = timeline_0->requestClipsGroup({6, 7}, false, GroupType::Normal);
0573             REQUIRE(res == 9);
0574         }
0575         REQUIRE(timeline_0->checkConsistency());
0576         undoStack->undo();
0577         REQUIRE(timeline_0->checkConsistency());
0578         undoStack->redo();
0579         REQUIRE(timeline_0->checkConsistency());
0580         pCore->taskManager.slotCancelJobs();
0581         mockedDoc.closing = true;
0582         timeline_0.reset();
0583         binModel->clean();
0584     }
0585 }
0586
0587 TEST_CASE("FuzzBug2")
0588 {
0589     auto binModel = pCore->projectItemModel();
0590     binModel->clean();
0591     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
0592     KdenliveDoc::next_id = 0;
0593     {
0594         KdenliveDoc document(undoStack);
0595         Mock<KdenliveDoc> docMock(document);
0596         KdenliveDoc &mockedDoc = docMock.get();
0597         Mock<ProjectManager> pmMock;
0598         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
0599         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
0600         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
0601
0602         ProjectManager &mocked = pmMock.get();
0603         pCore->m_projectManager = &mocked;
0604
0605         // We also mock timeline object to spy few functions and mock others
0606         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
0607         Mock<TimelineItemModel> timMock_0(tim);
0608         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
0609         TimelineItemModel::finishConstruct(timeline_0);
0610         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
0611
0612         mocked.m_activeTimelineModel = timeline_0;
0613         Fake(Method(timMock_0, adjustAssetRange));
0614         REQUIRE(timeline_0->checkConsistency());
0615         undoStack->undo();
0616         REQUIRE(timeline_0->checkConsistency());
0617         undoStack->redo();
0618         REQUIRE(timeline_0->checkConsistency());
0619         {
0620             int dummy_1;
0621             bool res = timeline_0->requestTrackInsertion(-1, dummy_1, "$", false);
0622             REQUIRE(res == true);
0623         }
0624         REQUIRE(timeline_0->checkConsistency());
0625         undoStack->undo();
0626         REQUIRE(timeline_0->checkConsistency());
0627         undoStack->redo();
0628         REQUIRE(timeline_0->checkConsistency());
0629         createProducer(pCore->getProjectProfile(), "d", binModel, 0, true);
0630         REQUIRE(timeline_0->checkConsistency());
0631         undoStack->undo();
0632         REQUIRE(timeline_0->checkConsistency());
0633         undoStack->redo();
0634         REQUIRE(timeline_0->checkConsistency());
0635         {
0636             int dummy_3;
0637             bool res = timeline_0->requestClipInsertion("2", 1, 0, dummy_3, true, false, true);
0638             REQUIRE(res == true);
0639         }
0640         REQUIRE(timeline_0->checkConsistency());
0641         undoStack->undo();
0642         REQUIRE(timeline_0->checkConsistency());
0643         undoStack->redo();
0644         REQUIRE(timeline_0->checkConsistency());
0645         {
0646             int dummy_3;
0647             bool res = timeline_0->requestClipInsertion("2", 1, 30, dummy_3, true, false, true);
0648             REQUIRE(res == true);
0649         }
0650         REQUIRE(timeline_0->checkConsistency());
0651         undoStack->undo();
0652         REQUIRE(timeline_0->checkConsistency());
0653         undoStack->redo();
0654         REQUIRE(timeline_0->checkConsistency());
0655         {
0656             int dummy_3;
0657             bool res = timeline_0->requestClipInsertion("2", 1, 60, dummy_3, true, false, true);
0658             REQUIRE(res == true);
0659         }
0660         REQUIRE(timeline_0->checkConsistency());
0661         undoStack->undo();
0662         REQUIRE(timeline_0->checkConsistency());
0663         undoStack->redo();
0664         REQUIRE(timeline_0->checkConsistency());
0665         {
0666             // Grouping 2 audio clips as AVSplit, this is now possible with multiple streams
0667             // int res = timeline_0->requestClipsGroup({3, 2}, true, GroupType::AVSplit);
0668             // REQUIRE(res == -1);
0669         }
0670         REQUIRE(timeline_0->checkConsistency());
0671         undoStack->undo();
0672         REQUIRE(timeline_0->checkConsistency());
0673         undoStack->redo();
0674         REQUIRE(timeline_0->checkConsistency());
0675         pCore->taskManager.slotCancelJobs();
0676         mockedDoc.closing = true;
0677         timeline_0.reset();
0678         binModel->clean();
0679     }
0680 }
0681
0682 TEST_CASE("FuzzBug3")
0683 {
0684     auto binModel = pCore->projectItemModel();
0685     binModel->clean();
0686     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
0687     KdenliveDoc::next_id = 0;
0688     {
0689         KdenliveDoc document(undoStack);
0690         Mock<KdenliveDoc> docMock(document);
0691         KdenliveDoc &mockedDoc = docMock.get();
0692         Mock<ProjectManager> pmMock;
0693         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
0694         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
0695         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
0696
0697         ProjectManager &mocked = pmMock.get();
0698         pCore->m_projectManager = &mocked;
0699
0700         // We also mock timeline object to spy few functions and mock others
0701         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
0702         Mock<TimelineItemModel> timMock_0(tim);
0703         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
0704         TimelineItemModel::finishConstruct(timeline_0);
0705         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
0706
0707         mocked.m_activeTimelineModel = timeline_0;
0708         Fake(Method(timMock_0, adjustAssetRange));
0709
0710         createProducerWithSound(pCore->getProjectProfile(), binModel);
0711         REQUIRE(timeline_0->checkConsistency());
0712         undoStack->undo();
0713         REQUIRE(timeline_0->checkConsistency());
0714         undoStack->redo();
0715         REQUIRE(timeline_0->checkConsistency());
0716         TrackModel::construct(timeline_0, -1, 0, "0", true);
0717         // Setup timeline audio drop info
0718         QMap<int, QString> audioInfo;
0719         audioInfo.insert(1, QStringLiteral("stream1"));
0720         timeline_0->m_binAudioTargets = audioInfo;
0721         REQUIRE(timeline_0->checkConsistency());
0722         undoStack->undo();
0723         REQUIRE(timeline_0->checkConsistency());
0724         undoStack->redo();
0725         REQUIRE(timeline_0->checkConsistency());
0726         {
0727             int dummy_3;
0728             bool res = timeline_0->requestClipInsertion("2", 1, 0, dummy_3, false, false, false);
0729             REQUIRE(res == true);
0730         }
0731         REQUIRE(timeline_0->checkConsistency());
0732         undoStack->undo();
0733         REQUIRE(timeline_0->checkConsistency());
0734         undoStack->redo();
0735         REQUIRE(timeline_0->checkConsistency());
0736         pCore->taskManager.slotCancelJobs();
0737         mockedDoc.closing = true;
0738         timeline_0.reset();
0739         binModel->clean();
0740     }
0741 }
0742
0743 TEST_CASE("FuzzBug4")
0744 {
0745     auto binModel = pCore->projectItemModel();
0746     binModel->clean();
0747     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
0748     KdenliveDoc::next_id = 0;
0749     {
0750         KdenliveDoc document(undoStack);
0751         Mock<KdenliveDoc> docMock(document);
0752         KdenliveDoc &mockedDoc = docMock.get();
0753         Mock<ProjectManager> pmMock;
0754         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
0755         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
0756         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
0757
0758         ProjectManager &mocked = pmMock.get();
0759         pCore->m_projectManager = &mocked;
0760
0761         // We also mock timeline object to spy few functions and mock others
0762         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
0763         Mock<TimelineItemModel> timMock_0(tim);
0764         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
0765         TimelineItemModel::finishConstruct(timeline_0);
0766         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
0767
0768         mocked.m_activeTimelineModel = timeline_0;
0769         Fake(Method(timMock_0, adjustAssetRange));
0770         REQUIRE(timeline_0->checkConsistency());
0771         undoStack->undo();
0772         REQUIRE(timeline_0->checkConsistency());
0773         undoStack->redo();
0774         REQUIRE(timeline_0->checkConsistency());
0775         createProducer(pCore->getProjectProfile(), "red", binModel, 2, true);
0776         REQUIRE(timeline_0->checkConsistency());
0777         undoStack->undo();
0778         REQUIRE(timeline_0->checkConsistency());
0779         undoStack->redo();
0780         REQUIRE(timeline_0->checkConsistency());
0781         createProducer(pCore->getProjectProfile(), "blue", binModel, 20, true);
0782         REQUIRE(timeline_0->checkConsistency());
0783         undoStack->undo();
0784         REQUIRE(timeline_0->checkConsistency());
0785         undoStack->redo();
0786         REQUIRE(timeline_0->checkConsistency());
0787         createProducer(pCore->getProjectProfile(), "gseen", binModel, 20, true);
0788         REQUIRE(timeline_0->checkConsistency());
0789         undoStack->undo();
0790         REQUIRE(timeline_0->checkConsistency());
0791         undoStack->redo();
0792         REQUIRE(timeline_0->checkConsistency());
0793         TrackModel::construct(timeline_0, -1, -1, "", false);
0794         REQUIRE(timeline_0->checkConsistency());
0795         undoStack->undo();
0796         REQUIRE(timeline_0->checkConsistency());
0797         undoStack->redo();
0798         REQUIRE(timeline_0->checkConsistency());
0799         createProducerWithSound(pCore->getProjectProfile(), binModel);
0800         REQUIRE(timeline_0->checkConsistency());
0801         undoStack->undo();
0802         REQUIRE(timeline_0->checkConsistency());
0803         undoStack->redo();
0804         REQUIRE(timeline_0->checkConsistency());
0805         {
0806             int dummy_3;
0807             bool res = timeline_0->requestClipInsertion("5", 1, 3, dummy_3, true, true, true);
0808             REQUIRE(res == true);
0809         }
0810         REQUIRE(timeline_0->checkConsistency());
0811         undoStack->undo();
0812         REQUIRE(timeline_0->checkConsistency());
0813         undoStack->redo();
0814         REQUIRE(timeline_0->checkConsistency());
0815         {
0816             timeline_0->requestGroupDeletion(2, false);
0817         }
0818         REQUIRE(timeline_0->checkConsistency());
0819         undoStack->undo();
0820         REQUIRE(timeline_0->checkConsistency());
0821         undoStack->redo();
0822         REQUIRE(timeline_0->checkConsistency());
0823         pCore->taskManager.slotCancelJobs();
0824         mockedDoc.closing = true;
0825         timeline_0.reset();
0826         binModel->clean();
0827     }
0828 }
0829
0830 TEST_CASE("FuzzBug5")
0831 {
0832     auto binModel = pCore->projectItemModel();
0833     binModel->clean();
0834     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
0835     KdenliveDoc::next_id = 0;
0836     {
0837         KdenliveDoc document(undoStack);
0838         Mock<KdenliveDoc> docMock(document);
0839         KdenliveDoc &mockedDoc = docMock.get();
0840         Mock<ProjectManager> pmMock;
0841         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
0842         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
0843         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
0844
0845         ProjectManager &mocked = pmMock.get();
0846         pCore->m_projectManager = &mocked;
0847
0848         // We also mock timeline object to spy few functions and mock others
0849         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
0850         Mock<TimelineItemModel> timMock_0(tim);
0851         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
0852         TimelineItemModel::finishConstruct(timeline_0);
0853         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
0854
0855         mocked.m_activeTimelineModel = timeline_0;
0856         Fake(Method(timMock_0, adjustAssetRange));
0857         REQUIRE(timeline_0->checkConsistency());
0858         undoStack->undo();
0859         REQUIRE(timeline_0->checkConsistency());
0860         undoStack->redo();
0861         REQUIRE(timeline_0->checkConsistency());
0862         TrackModel::construct(timeline_0, -1, 0, "", false);
0863         REQUIRE(timeline_0->checkConsistency());
0864         undoStack->undo();
0865         REQUIRE(timeline_0->checkConsistency());
0866         undoStack->redo();
0867         REQUIRE(timeline_0->checkConsistency());
0868         QUuid uuid2 = QUuid::createUuid();
0869         TimelineItemModel tim_1(uuid2, undoStack);
0870         Mock<TimelineItemModel> timMock_1(tim_1);
0871         auto timeline_1 = std::shared_ptr<TimelineItemModel>(&timMock_1.get(), [](...) {});
0872         TimelineItemModel::finishConstruct(timeline_1);
0873         Fake(Method(timMock_1, adjustAssetRange));
0874         REQUIRE(timeline_0->checkConsistency());
0875         mocked.m_activeTimelineModel = timeline_1;
0876         REQUIRE(timeline_1->checkConsistency());
0877         undoStack->undo();
0878         mocked.m_activeTimelineModel = timeline_0;
0879         REQUIRE(timeline_0->checkConsistency());
0880         mocked.m_activeTimelineModel = timeline_1;
0881         REQUIRE(timeline_1->checkConsistency());
0882         undoStack->redo();
0883         mocked.m_activeTimelineModel = timeline_0;
0884         REQUIRE(timeline_0->checkConsistency());
0885         mocked.m_activeTimelineModel = timeline_1;
0886         REQUIRE(timeline_1->checkConsistency());
0887         TrackModel::construct(timeline_0, -1, 0, "$", false);
0888         mocked.m_activeTimelineModel = timeline_0;
0889         REQUIRE(timeline_0->checkConsistency());
0890         mocked.m_activeTimelineModel = timeline_1;
0891         REQUIRE(timeline_1->checkConsistency());
0892         undoStack->undo();
0893         mocked.m_activeTimelineModel = timeline_0;
0894         REQUIRE(timeline_0->checkConsistency());
0895         mocked.m_activeTimelineModel = timeline_1;
0896         REQUIRE(timeline_1->checkConsistency());
0897         undoStack->redo();
0898         mocked.m_activeTimelineModel = timeline_0;
0899         REQUIRE(timeline_0->checkConsistency());
0900         mocked.m_activeTimelineModel = timeline_1;
0901         REQUIRE(timeline_1->checkConsistency());
0902         TrackModel::construct(timeline_1, -1, 0, "$", true);
0903         mocked.m_activeTimelineModel = timeline_0;
0904         REQUIRE(timeline_0->checkConsistency());
0905         mocked.m_activeTimelineModel = timeline_1;
0906         REQUIRE(timeline_1->checkConsistency());
0907         undoStack->undo();
0908         mocked.m_activeTimelineModel = timeline_0;
0909         REQUIRE(timeline_0->checkConsistency());
0910         mocked.m_activeTimelineModel = timeline_1;
0911         REQUIRE(timeline_1->checkConsistency());
0912         undoStack->redo();
0913         mocked.m_activeTimelineModel = timeline_0;
0914         REQUIRE(timeline_0->checkConsistency());
0915         mocked.m_activeTimelineModel = timeline_1;
0916         REQUIRE(timeline_1->checkConsistency());
0917         createProducerWithSound(pCore->getProjectProfile(), binModel);
0918         mocked.m_activeTimelineModel = timeline_0;
0919         REQUIRE(timeline_0->checkConsistency());
0920         mocked.m_activeTimelineModel = timeline_1;
0921         REQUIRE(timeline_1->checkConsistency());
0922         undoStack->undo();
0923         mocked.m_activeTimelineModel = timeline_0;
0924         REQUIRE(timeline_0->checkConsistency());
0925         mocked.m_activeTimelineModel = timeline_1;
0926         REQUIRE(timeline_1->checkConsistency());
0927         undoStack->redo();
0928         mocked.m_activeTimelineModel = timeline_0;
0929         REQUIRE(timeline_0->checkConsistency());
0930         mocked.m_activeTimelineModel = timeline_1;
0931         REQUIRE(timeline_1->checkConsistency());
0932         TrackModel::construct(timeline_1, -1, -1, "$", false);
0933         mocked.m_activeTimelineModel = timeline_0;
0934         REQUIRE(timeline_0->checkConsistency());
0935         mocked.m_activeTimelineModel = timeline_1;
0936         REQUIRE(timeline_1->checkConsistency());
0937         undoStack->undo();
0938         mocked.m_activeTimelineModel = timeline_0;
0939         REQUIRE(timeline_0->checkConsistency());
0940         mocked.m_activeTimelineModel = timeline_1;
0941         REQUIRE(timeline_1->checkConsistency());
0942         undoStack->redo();
0943         mocked.m_activeTimelineModel = timeline_0;
0944         REQUIRE(timeline_0->checkConsistency());
0945         mocked.m_activeTimelineModel = timeline_1;
0946         REQUIRE(timeline_1->checkConsistency());
0947         TrackModel::construct(timeline_1, -1, -1, "$", true);
0948         mocked.m_activeTimelineModel = timeline_0;
0949         REQUIRE(timeline_0->checkConsistency());
0950         mocked.m_activeTimelineModel = timeline_1;
0951         REQUIRE(timeline_1->checkConsistency());
0952         undoStack->undo();
0953         mocked.m_activeTimelineModel = timeline_0;
0954         REQUIRE(timeline_0->checkConsistency());
0955         mocked.m_activeTimelineModel = timeline_1;
0956         REQUIRE(timeline_1->checkConsistency());
0957         undoStack->redo();
0958
0959         // Setup timeline audio drop info
0960         QMap<int, QString> audioInfo;
0961         audioInfo.insert(1, QStringLiteral("stream1"));
0962         timeline_1->m_binAudioTargets = audioInfo;
0963         timeline_1->m_videoTarget = 5;
0964         QMap<int, int> audioTarget;
0965         audioTarget.insert(6, 1);
0966         timeline_1->m_audioTarget = audioTarget;
0967
0968         /*timeline_1->setTrackProperty(4, "kdenlive:timeline_active", QStringLiteral("1"));
0969         timeline_1->setTrackProperty(5, "kdenlive:timeline_active", QStringLiteral("1"));
0970         timeline_1->setTrackProperty(6, "kdenlive:timeline_active", QStringLiteral("1"));*/
0971
0972         mocked.m_activeTimelineModel = timeline_0;
0973         REQUIRE(timeline_0->checkConsistency());
0974         mocked.m_activeTimelineModel = timeline_1;
0975         REQUIRE(timeline_1->checkConsistency());
0976         {
0977             int dummy_3;
0978             bool res = timeline_1->requestClipInsertion("2", 5, 0, dummy_3, true, false, true);
0979             qDebug() << "==== INSERTED FIRST CLIP DURATION: " << timeline_1->getClipPlaytime(dummy_3);
0980             REQUIRE(res == true);
0981         }
0982         mocked.m_activeTimelineModel = timeline_0;
0983         REQUIRE(timeline_0->checkConsistency());
0984         mocked.m_activeTimelineModel = timeline_1;
0985         REQUIRE(timeline_1->checkConsistency());
0986         undoStack->undo();
0987         mocked.m_activeTimelineModel = timeline_0;
0988         REQUIRE(timeline_0->checkConsistency());
0989         mocked.m_activeTimelineModel = timeline_1;
0990         REQUIRE(timeline_1->checkConsistency());
0991         undoStack->redo();
0992         mocked.m_activeTimelineModel = timeline_0;
0993         REQUIRE(timeline_0->checkConsistency());
0994         mocked.m_activeTimelineModel = timeline_1;
0995         REQUIRE(timeline_1->checkConsistency());
0996         {
0997             int dummy_3;
0998             bool res = timeline_1->requestClipInsertion("2", 6, 20, dummy_3, true, false, true);
0999             REQUIRE(res == true);
1000         }
1001         mocked.m_activeTimelineModel = timeline_0;
1002         REQUIRE(timeline_0->checkConsistency());
1003         mocked.m_activeTimelineModel = timeline_1;
1004         REQUIRE(timeline_1->checkConsistency());
1005         undoStack->undo();
1006         mocked.m_activeTimelineModel = timeline_0;
1007         REQUIRE(timeline_0->checkConsistency());
1008         mocked.m_activeTimelineModel = timeline_1;
1009         REQUIRE(timeline_1->checkConsistency());
1010         undoStack->redo();
1011         mocked.m_activeTimelineModel = timeline_0;
1012         REQUIRE(timeline_0->checkConsistency());
1013         mocked.m_activeTimelineModel = timeline_1;
1014         REQUIRE(timeline_1->checkConsistency());
1015         {
1016             bool res = timeline_1->requestGroupMove(10, 9, 0, 0, true, false, false);
1017             REQUIRE(res == false);
1018         }
1019         mocked.m_activeTimelineModel = timeline_0;
1020         REQUIRE(timeline_0->checkConsistency());
1021         mocked.m_activeTimelineModel = timeline_1;
1022         REQUIRE(timeline_1->checkConsistency());
1023         undoStack->undo();
1024         mocked.m_activeTimelineModel = timeline_0;
1025         REQUIRE(timeline_0->checkConsistency());
1026         mocked.m_activeTimelineModel = timeline_1;
1027         REQUIRE(timeline_1->checkConsistency());
1028         undoStack->redo();
1029         mocked.m_activeTimelineModel = timeline_0;
1030         REQUIRE(timeline_0->checkConsistency());
1031         mocked.m_activeTimelineModel = timeline_1;
1032         REQUIRE(timeline_1->checkConsistency());
1033         pCore->taskManager.slotCancelJobs();
1034         mocked.m_activeTimelineModel.reset();
1035         undoStack->clear();
1036         mockedDoc.closing = true;
1037         binModel->clean();
1038         timeline_0.reset();
1039         timeline_1.reset();
1040     }
1041 }
1042
1043 TEST_CASE("FuzzBug6")
1044 {
1045     auto binModel = pCore->projectItemModel();
1046     binModel->clean();
1047     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
1048     KdenliveDoc::next_id = 0;
1049     {
1050         KdenliveDoc document(undoStack);
1051         Mock<KdenliveDoc> docMock(document);
1052         KdenliveDoc &mockedDoc = docMock.get();
1053         Mock<ProjectManager> pmMock;
1054         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
1055         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
1056         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
1057
1058         ProjectManager &mocked = pmMock.get();
1059         pCore->m_projectManager = &mocked;
1060
1061         // We also mock timeline object to spy few functions and mock others
1062         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
1063         Mock<TimelineItemModel> timMock_0(tim);
1064         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
1065         TimelineItemModel::finishConstruct(timeline_0);
1066         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
1067
1068         Fake(Method(timMock_0, adjustAssetRange));
1069         REQUIRE(timeline_0->checkConsistency());
1070         undoStack->undo();
1071         REQUIRE(timeline_0->checkConsistency());
1072         undoStack->redo();
1073         REQUIRE(timeline_0->checkConsistency());
1074         TrackModel::construct(timeline_0, -1, 0, "$", false);
1075         REQUIRE(timeline_0->checkConsistency());
1076         undoStack->undo();
1077         REQUIRE(timeline_0->checkConsistency());
1078         undoStack->redo();
1079         REQUIRE(timeline_0->checkConsistency());
1080         QUuid uuid2 = QUuid::createUuid();
1081         TimelineItemModel tim_1(uuid2, undoStack);
1082         Mock<TimelineItemModel> timMock_1(tim_1);
1083         auto timeline_1 = std::shared_ptr<TimelineItemModel>(&timMock_1.get(), [](...) {});
1084         TimelineItemModel::finishConstruct(timeline_1);
1085         Fake(Method(timMock_1, adjustAssetRange));
1086         mocked.m_activeTimelineModel = timeline_0;
1087         REQUIRE(timeline_0->checkConsistency());
1088         mocked.m_activeTimelineModel = timeline_1;
1089         REQUIRE(timeline_1->checkConsistency());
1090         undoStack->undo();
1091         mocked.m_activeTimelineModel = timeline_0;
1092         REQUIRE(timeline_0->checkConsistency());
1093         mocked.m_activeTimelineModel = timeline_1;
1094         REQUIRE(timeline_1->checkConsistency());
1095         undoStack->redo();
1096         mocked.m_activeTimelineModel = timeline_0;
1097         REQUIRE(timeline_0->checkConsistency());
1098         mocked.m_activeTimelineModel = timeline_1;
1099         REQUIRE(timeline_1->checkConsistency());
1100         createProducer(pCore->getProjectProfile(), "b", binModel, 20, true);
1101         mocked.m_activeTimelineModel = timeline_0;
1102         REQUIRE(timeline_0->checkConsistency());
1103         mocked.m_activeTimelineModel = timeline_1;
1104         REQUIRE(timeline_1->checkConsistency());
1105         undoStack->undo();
1106         mocked.m_activeTimelineModel = timeline_0;
1107         REQUIRE(timeline_0->checkConsistency());
1108         mocked.m_activeTimelineModel = timeline_1;
1109         REQUIRE(timeline_1->checkConsistency());
1110         undoStack->redo();
1111         mocked.m_activeTimelineModel = timeline_0;
1112         REQUIRE(timeline_0->checkConsistency());
1113         mocked.m_activeTimelineModel = timeline_1;
1114         REQUIRE(timeline_1->checkConsistency());
1115         {
1116             int dummy_3;
1117             bool res = timeline_0->requestClipInsertion("2", 1, -1, dummy_3, false, false, false);
1118             REQUIRE(res == false);
1119         }
1120         mocked.m_activeTimelineModel = timeline_0;
1121         REQUIRE(timeline_0->checkConsistency());
1122         mocked.m_activeTimelineModel = timeline_1;
1123         REQUIRE(timeline_1->checkConsistency());
1124         undoStack->undo();
1125         mocked.m_activeTimelineModel = timeline_0;
1126         REQUIRE(timeline_0->checkConsistency());
1127         mocked.m_activeTimelineModel = timeline_1;
1128         REQUIRE(timeline_1->checkConsistency());
1129         undoStack->redo();
1130         mocked.m_activeTimelineModel = timeline_0;
1131         REQUIRE(timeline_0->checkConsistency());
1132         mocked.m_activeTimelineModel = timeline_1;
1133         REQUIRE(timeline_1->checkConsistency());
1134         pCore->taskManager.slotCancelJobs();
1135         mockedDoc.closing = true;
1136         timeline_0.reset();
1137         timeline_1.reset();
1138         binModel->clean();
1139     }
1140 }
1141
1142 TEST_CASE("FuzzBug7")
1143 {
1144     auto binModel = pCore->projectItemModel();
1145     binModel->clean();
1146     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
1147     KdenliveDoc::next_id = 0;
1148     {
1149         KdenliveDoc document(undoStack);
1150         Mock<KdenliveDoc> docMock(document);
1151         KdenliveDoc &mockedDoc = docMock.get();
1152         Mock<ProjectManager> pmMock;
1153         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
1154         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
1155         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
1156
1157         ProjectManager &mocked = pmMock.get();
1158         pCore->m_projectManager = &mocked;
1159
1160         // We also mock timeline object to spy few functions and mock others
1161         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
1162         Mock<TimelineItemModel> timMock_0(tim);
1163         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
1164         TimelineItemModel::finishConstruct(timeline_0);
1165         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
1166
1167         mocked.m_activeTimelineModel = timeline_0;
1168         Fake(Method(timMock_0, adjustAssetRange));
1169         REQUIRE(timeline_0->checkConsistency());
1170         undoStack->undo();
1171         REQUIRE(timeline_0->checkConsistency());
1172         undoStack->redo();
1173         REQUIRE(timeline_0->checkConsistency());
1174         TrackModel::construct(timeline_0, -1, -1, "0", false);
1175         REQUIRE(timeline_0->checkConsistency());
1176         undoStack->undo();
1177         REQUIRE(timeline_0->checkConsistency());
1178         undoStack->redo();
1179         REQUIRE(timeline_0->checkConsistency());
1180         QUuid uuid2 = QUuid::createUuid();
1181         TimelineItemModel tim_1(uuid2, undoStack);
1182         Mock<TimelineItemModel> timMock_1(tim_1);
1183         auto timeline_1 = std::shared_ptr<TimelineItemModel>(&timMock_1.get(), [](...) {});
1184         TimelineItemModel::finishConstruct(timeline_1);
1185         Fake(Method(timMock_1, adjustAssetRange));
1186         mocked.m_activeTimelineModel = timeline_0;
1187         REQUIRE(timeline_0->checkConsistency());
1188         mocked.m_activeTimelineModel = timeline_1;
1189         REQUIRE(timeline_1->checkConsistency());
1190         undoStack->undo();
1191         mocked.m_activeTimelineModel = timeline_0;
1192         REQUIRE(timeline_0->checkConsistency());
1193         mocked.m_activeTimelineModel = timeline_1;
1194         REQUIRE(timeline_1->checkConsistency());
1195         undoStack->redo();
1196         mocked.m_activeTimelineModel = timeline_0;
1197         REQUIRE(timeline_0->checkConsistency());
1198         mocked.m_activeTimelineModel = timeline_1;
1199         REQUIRE(timeline_1->checkConsistency());
1200         createProducer(pCore->getProjectProfile(), "r5", binModel, 2, true);
1201         mocked.m_activeTimelineModel = timeline_0;
1202         REQUIRE(timeline_0->checkConsistency());
1203         mocked.m_activeTimelineModel = timeline_1;
1204         REQUIRE(timeline_1->checkConsistency());
1205         undoStack->undo();
1206         mocked.m_activeTimelineModel = timeline_0;
1207         REQUIRE(timeline_0->checkConsistency());
1208         mocked.m_activeTimelineModel = timeline_1;
1209         REQUIRE(timeline_1->checkConsistency());
1210         undoStack->redo();
1211         mocked.m_activeTimelineModel = timeline_0;
1212         REQUIRE(timeline_0->checkConsistency());
1213         mocked.m_activeTimelineModel = timeline_1;
1214         REQUIRE(timeline_1->checkConsistency());
1215         {
1216             int dummy_3;
1217             bool res = timeline_0->requestClipInsertion("2", 1, 0, dummy_3, true, false, true);
1218             REQUIRE(res == true);
1219         }
1220         mocked.m_activeTimelineModel = timeline_0;
1221         REQUIRE(timeline_0->checkConsistency());
1222         mocked.m_activeTimelineModel = timeline_1;
1223         REQUIRE(timeline_1->checkConsistency());
1224         mocked.m_activeTimelineModel = timeline_0;
1225         undoStack->undo();
1226         REQUIRE(timeline_0->checkConsistency());
1227         mocked.m_activeTimelineModel = timeline_1;
1228         REQUIRE(timeline_1->checkConsistency());
1229         undoStack->redo();
1230         mocked.m_activeTimelineModel = timeline_0;
1231         REQUIRE(timeline_0->checkConsistency());
1232         mocked.m_activeTimelineModel = timeline_1;
1233         REQUIRE(timeline_1->checkConsistency());
1234         {
1235             mocked.m_activeTimelineModel = timeline_0;
1236             int dummy_3;
1237             bool res = timeline_0->requestClipInsertion("2", 1, 20, dummy_3, true, false, true);
1238             REQUIRE(res == true);
1239         }
1240         REQUIRE(timeline_0->checkConsistency());
1241         mocked.m_activeTimelineModel = timeline_1;
1242         REQUIRE(timeline_1->checkConsistency());
1243         mocked.m_activeTimelineModel = timeline_0;
1244         undoStack->undo();
1245         REQUIRE(timeline_0->checkConsistency());
1246         mocked.m_activeTimelineModel = timeline_1;
1247         REQUIRE(timeline_1->checkConsistency());
1248         mocked.m_activeTimelineModel = timeline_0;
1249         undoStack->redo();
1250         REQUIRE(timeline_0->checkConsistency());
1251         mocked.m_activeTimelineModel = timeline_1;
1252         REQUIRE(timeline_1->checkConsistency());
1253         {
1254             mocked.m_activeTimelineModel = timeline_0;
1255             int dummy_3;
1256             bool res = timeline_0->requestClipInsertion("2", 1, 40, dummy_3, true, false, true);
1257             REQUIRE(res == true);
1258         }
1259         REQUIRE(timeline_0->checkConsistency());
1260         mocked.m_activeTimelineModel = timeline_1;
1261         REQUIRE(timeline_1->checkConsistency());
1262         mocked.m_activeTimelineModel = timeline_0;
1263         undoStack->undo();
1264         REQUIRE(timeline_0->checkConsistency());
1265         mocked.m_activeTimelineModel = timeline_1;
1266         REQUIRE(timeline_1->checkConsistency());
1267         mocked.m_activeTimelineModel = timeline_0;
1268         undoStack->redo();
1269         REQUIRE(timeline_0->checkConsistency());
1270         mocked.m_activeTimelineModel = timeline_1;
1271         REQUIRE(timeline_1->checkConsistency());
1272         {
1273             mocked.m_activeTimelineModel = timeline_0;
1274             int res = timeline_0->requestClipsGroup({4, 3}, true, GroupType::Selection);
1275             REQUIRE(res == -1);
1276         }
1277         REQUIRE(timeline_0->checkConsistency());
1278         mocked.m_activeTimelineModel = timeline_1;
1279         REQUIRE(timeline_1->checkConsistency());
1280         mocked.m_activeTimelineModel = timeline_0;
1281         undoStack->undo();
1282         REQUIRE(timeline_0->checkConsistency());
1283         mocked.m_activeTimelineModel = timeline_1;
1284         REQUIRE(timeline_1->checkConsistency());
1285         mocked.m_activeTimelineModel = timeline_0;
1286         undoStack->redo();
1287         REQUIRE(timeline_0->checkConsistency());
1288         mocked.m_activeTimelineModel = timeline_1;
1289         REQUIRE(timeline_1->checkConsistency());
1290         {
1291             mocked.m_activeTimelineModel = timeline_0;
1292             int res = timeline_0->requestClipsGroup({5, 3}, true, GroupType::Normal);
1293             REQUIRE(res == 6);
1294         }
1295         REQUIRE(timeline_0->checkConsistency());
1296         mocked.m_activeTimelineModel = timeline_1;
1297         REQUIRE(timeline_1->checkConsistency());
1298         mocked.m_activeTimelineModel = timeline_0;
1299         undoStack->undo();
1300         REQUIRE(timeline_0->checkConsistency());
1301         mocked.m_activeTimelineModel = timeline_1;
1302         REQUIRE(timeline_1->checkConsistency());
1303         mocked.m_activeTimelineModel = timeline_0;
1304         undoStack->redo();
1305         REQUIRE(timeline_0->checkConsistency());
1306         mocked.m_activeTimelineModel = timeline_1;
1307         REQUIRE(timeline_1->checkConsistency());
1308         pCore->taskManager.slotCancelJobs();
1309         mockedDoc.closing = true;
1310         timeline_0.reset();
1311         timeline_1.reset();
1312         binModel->clean();
1313     }
1314 }
1315
1316 TEST_CASE("FuzzBug8")
1317 {
1318     auto binModel = pCore->projectItemModel();
1319     binModel->clean();
1320     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
1321     KdenliveDoc::next_id = 0;
1322     {
1323         KdenliveDoc document(undoStack);
1324         Mock<KdenliveDoc> docMock(document);
1325         KdenliveDoc &mockedDoc = docMock.get();
1326         Mock<ProjectManager> pmMock;
1327         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
1328         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
1329         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
1330
1331         ProjectManager &mocked = pmMock.get();
1332         pCore->m_projectManager = &mocked;
1333
1334         // We also mock timeline object to spy few functions and mock others
1335         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
1336         Mock<TimelineItemModel> timMock_0(tim);
1337         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
1338         TimelineItemModel::finishConstruct(timeline_0);
1339         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
1340
1341         mocked.m_activeTimelineModel = timeline_0;
1342         Fake(Method(timMock_0, adjustAssetRange));
1343         REQUIRE(timeline_0->checkConsistency());
1344         undoStack->undo();
1345         REQUIRE(timeline_0->checkConsistency());
1346         undoStack->redo();
1347         REQUIRE(timeline_0->checkConsistency());
1348         {
1349             int dummy_1;
1350             bool res = timeline_0->requestTrackInsertion(-1, dummy_1, "", false);
1351             REQUIRE(res == true);
1352         }
1353         REQUIRE(timeline_0->checkConsistency());
1354         undoStack->undo();
1355         REQUIRE(timeline_0->checkConsistency());
1356         undoStack->redo();
1357         REQUIRE(timeline_0->checkConsistency());
1358         createProducer(pCore->getProjectProfile(), "red20", binModel, 1, true);
1359         REQUIRE(timeline_0->checkConsistency());
1360         undoStack->undo();
1361         REQUIRE(timeline_0->checkConsistency());
1362         undoStack->redo();
1363         REQUIRE(timeline_0->checkConsistency());
1364         {
1365             int dummy_3;
1366             bool res = timeline_0->requestClipInsertion("2", 1, 40, dummy_3, true, false, true);
1367             REQUIRE(res == true);
1368         }
1369         REQUIRE(timeline_0->checkConsistency());
1370         undoStack->undo();
1371         REQUIRE(timeline_0->checkConsistency());
1372         undoStack->redo();
1373         REQUIRE(timeline_0->checkConsistency());
1374         {
1375             int res = timeline_0->requestClipsGroup({2}, true, GroupType::Leaf);
1376             REQUIRE(res == -1);
1377         }
1378         REQUIRE(timeline_0->checkConsistency());
1379         undoStack->undo();
1380         REQUIRE(timeline_0->checkConsistency());
1381         undoStack->redo();
1382         REQUIRE(timeline_0->checkConsistency());
1383         pCore->taskManager.slotCancelJobs();
1384         mockedDoc.closing = true;
1385         timeline_0.reset();
1386         binModel->clean();
1387     }
1388 }
1389
1390 TEST_CASE("FuzzBug9")
1391 {
1392     auto binModel = pCore->projectItemModel();
1393     binModel->clean();
1394     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
1395     KdenliveDoc::next_id = 0;
1396     {
1397         KdenliveDoc document(undoStack);
1398         Mock<KdenliveDoc> docMock(document);
1399         KdenliveDoc &mockedDoc = docMock.get();
1400         Mock<ProjectManager> pmMock;
1401         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
1402         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
1403         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
1404
1405         ProjectManager &mocked = pmMock.get();
1406         pCore->m_projectManager = &mocked;
1407
1408         // We also mock timeline object to spy few functions and mock others
1409         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
1410         Mock<TimelineItemModel> timMock_0(tim);
1411         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
1412         TimelineItemModel::finishConstruct(timeline_0);
1413         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
1414
1415         mocked.m_activeTimelineModel = timeline_0;
1416         Fake(Method(timMock_0, adjustAssetRange));
1417         REQUIRE(timeline_0->checkConsistency());
1418         undoStack->undo();
1419         REQUIRE(timeline_0->checkConsistency());
1420         undoStack->redo();
1421         REQUIRE(timeline_0->checkConsistency());
1422         createProducer(pCore->getProjectProfile(), "60", binModel, 1, true);
1423         REQUIRE(timeline_0->checkConsistency());
1424         undoStack->undo();
1425         REQUIRE(timeline_0->checkConsistency());
1426         undoStack->redo();
1427         REQUIRE(timeline_0->checkConsistency());
1428         TrackModel::construct(timeline_0, -1, -1, "", false);
1429         REQUIRE(timeline_0->checkConsistency());
1430         undoStack->undo();
1431         REQUIRE(timeline_0->checkConsistency());
1432         undoStack->redo();
1433         REQUIRE(timeline_0->checkConsistency());
1434         ClipModel::construct(timeline_0, "2", 2, PlaylistState::Disabled, 1);
1435         REQUIRE(timeline_0->checkConsistency());
1436         undoStack->undo();
1437         REQUIRE(timeline_0->checkConsistency());
1438         undoStack->redo();
1439         REQUIRE(timeline_0->checkConsistency());
1440         {
1441             timeline_0->suggestClipMove(2, 1, -34, 0, 0);
1442         }
1443         REQUIRE(timeline_0->checkConsistency());
1444         undoStack->undo();
1445         REQUIRE(timeline_0->checkConsistency());
1446         undoStack->redo();
1447         REQUIRE(timeline_0->checkConsistency());
1448         pCore->taskManager.slotCancelJobs();
1449         mockedDoc.closing = true;
1450         timeline_0.reset();
1451         binModel->clean();
1452     }
1453 }
1454
1455 TEST_CASE("FuzzBug10")
1456 {
1457     auto binModel = pCore->projectItemModel();
1458     binModel->clean();
1459     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
1460     KdenliveDoc::next_id = 0;
1461     {
1462         KdenliveDoc document(undoStack);
1463         Mock<KdenliveDoc> docMock(document);
1464         KdenliveDoc &mockedDoc = docMock.get();
1465         Mock<ProjectManager> pmMock;
1466         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
1467         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
1468         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
1469
1470         ProjectManager &mocked = pmMock.get();
1471         pCore->m_projectManager = &mocked;
1472
1473         // We also mock timeline object to spy few functions and mock others
1474         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
1475         Mock<TimelineItemModel> timMock_0(tim);
1476         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
1477         TimelineItemModel::finishConstruct(timeline_0);
1478         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
1479
1480         mocked.m_activeTimelineModel = timeline_0;
1481         Fake(Method(timMock_0, adjustAssetRange));
1482         REQUIRE(timeline_0->checkConsistency());
1483         undoStack->undo();
1484         REQUIRE(timeline_0->checkConsistency());
1485         undoStack->redo();
1486         REQUIRE(timeline_0->checkConsistency());
1487         createProducer(pCore->getProjectProfile(), "red", binModel, 50, true);
1488         REQUIRE(timeline_0->checkConsistency());
1489         undoStack->undo();
1490         REQUIRE(timeline_0->checkConsistency());
1491         undoStack->redo();
1492         REQUIRE(timeline_0->checkConsistency());
1493         ClipModel::construct(timeline_0, "2", 1, PlaylistState::VideoOnly, -1);
1494         REQUIRE(timeline_0->checkConsistency());
1495         undoStack->undo();
1496         REQUIRE(timeline_0->checkConsistency());
1497         undoStack->redo();
1498         REQUIRE(timeline_0->checkConsistency());
1499         {
1500             timeline_0->requestItemResize(1, 12, false, true, 1, false);
1501         }
1502         REQUIRE(timeline_0->checkConsistency());
1503         undoStack->undo();
1504         REQUIRE(timeline_0->checkConsistency());
1505         undoStack->redo();
1506         REQUIRE(timeline_0->checkConsistency());
1507         pCore->taskManager.slotCancelJobs();
1508         mockedDoc.closing = true;
1509         timeline_0.reset();
1510         binModel->clean();
1511     }
1512 }
1513
1514 TEST_CASE("FuzzBug11")
1515 {
1516     auto binModel = pCore->projectItemModel();
1517     binModel->clean();
1518     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
1519     KdenliveDoc::next_id = 0;
1520     {
1521         KdenliveDoc document(undoStack);
1522         Mock<KdenliveDoc> docMock(document);
1523         KdenliveDoc &mockedDoc = docMock.get();
1524         Mock<ProjectManager> pmMock;
1525         When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
1526         When(Method(pmMock, cacheDir)).AlwaysReturn(QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
1527         When(Method(pmMock, current)).AlwaysReturn(&mockedDoc);
1528
1529         ProjectManager &mocked = pmMock.get();
1530         pCore->m_projectManager = &mocked;
1531
1532         // We also mock timeline object to spy few functions and mock others
1533         TimelineItemModel tim(mockedDoc.uuid(), undoStack);
1534         Mock<TimelineItemModel> timMock_0(tim);
1535         auto timeline_0 = std::shared_ptr<TimelineItemModel>(&timMock_0.get(), [](...) {});
1536         TimelineItemModel::finishConstruct(timeline_0);
1537         pCore->m_projectManager->testSetActiveDocument(&mockedDoc, timeline_0);
1538
1539         mocked.m_activeTimelineModel = timeline_0;
1540         Fake(Method(timMock_0, adjustAssetRange));
1541         REQUIRE(timeline_0->checkConsistency());
1542         undoStack->undo();
1543         REQUIRE(timeline_0->checkConsistency());
1544         undoStack->redo();
1545         REQUIRE(timeline_0->checkConsistency());
1546         createProducer(pCore->getProjectProfile(), "red", binModel, 20, true);
1547         REQUIRE(timeline_0->checkConsistency());
1548         undoStack->undo();
1549         REQUIRE(timeline_0->checkConsistency());
1550         undoStack->redo();
1551         REQUIRE(timeline_0->checkConsistency());
1552         createProducer(pCore->getProjectProfile(), "blue", binModel, 0, true);
1553         REQUIRE(timeline_0->checkConsistency());
1554         undoStack->undo();
1555         REQUIRE(timeline_0->checkConsistency());
1556         undoStack->redo();
1557         REQUIRE(timeline_0->checkConsistency());
1558         createProducer(pCore->getProjectProfile(), "green", binModel, 20, true);
1559         REQUIRE(timeline_0->checkConsistency());
1560         undoStack->undo();
1561         REQUIRE(timeline_0->checkConsistency());
1562         undoStack->redo();
1563         REQUIRE(timeline_0->checkConsistency());
1564         TrackModel::construct(timeline_0, -1, -1, "$", true);
1565         REQUIRE(timeline_0->checkConsistency());
1566         undoStack->undo();
1567         REQUIRE(timeline_0->checkConsistency());
1568         undoStack->redo();
1569         REQUIRE(timeline_0->checkConsistency());
1570         TrackModel::construct(timeline_0, -1, -1, "", false);
1571         REQUIRE(timeline_0->checkConsistency());
1572         undoStack->undo();
1573         REQUIRE(timeline_0->checkConsistency());
1574         undoStack->redo();
1575         REQUIRE(timeline_0->checkConsistency());
1576         createProducerWithSound(pCore->getProjectProfile(), binModel);
1577
1578         // Setup timeline audio drop info
1579         QMap<int, QString> audioInfo;
1580         audioInfo.insert(1, QStringLiteral("stream1"));
1581         timeline_0->m_binAudioTargets = audioInfo;
1582         REQUIRE(timeline_0->checkConsistency());
1583         undoStack->undo();
1584         REQUIRE(timeline_0->checkConsistency());
1585         undoStack->redo();
1586         REQUIRE(timeline_0->checkConsistency());
1587         {
1588             int dummy_3;
1589             bool res = timeline_0->requestClipInsertion("5", 2, 3, dummy_3, true, true, false);
1590             REQUIRE(res == true);
1591         }
1592         REQUIRE(timeline_0->checkConsistency());
1593         undoStack->undo();
1594         REQUIRE(timeline_0->checkConsistency());
1595         undoStack->redo();
1596         REQUIRE(timeline_0->checkConsistency());
1597         undoStack->undo();
1598         REQUIRE(timeline_0->checkConsistency());
1599         undoStack->redo();
1600         REQUIRE(timeline_0->checkConsistency());
1601         {
1602             timeline_0->requestSetSelection({4});
1603         }
1604         REQUIRE(timeline_0->checkConsistency());
1605         undoStack->undo();
1606         REQUIRE(timeline_0->checkConsistency());
1607         undoStack->redo();
1608         REQUIRE(timeline_0->checkConsistency());
1609         undoStack->undo();
1610         REQUIRE(timeline_0->checkConsistency());
1611         pCore->taskManager.slotCancelJobs();
1612         mockedDoc.closing = true;
1613         timeline_0.reset();
1614         binModel->clean();
1615     }
1616 }