1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Contact: https://www.qt.io/licensing/
5 **
6 ** This file is part of Qt Creator.
7 **
8 ** Commercial License Usage
9 ** Licensees holding valid commercial Qt licenses may use this file in
10 ** accordance with the commercial license agreement provided with the
11 ** Software or, alternatively, in accordance with the terms contained in
12 ** a written agreement between you and The Qt Company. For licensing terms
13 ** and conditions see https://www.qt.io/terms-conditions. For further
14 ** information use the contact form at https://www.qt.io/contact-us.
15 **
16 ** GNU General Public License Usage
17 ** Alternatively, this file may be used under the terms of the GNU
18 ** General Public License version 3 as published by the Free Software
19 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
20 ** included in the packaging of this file. Please review the following
21 ** information to ensure the GNU General Public License requirements will
22 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
23 **
24 ****************************************************************************/
25
26 #include "googletest.h"
27
28 #include "dummyclangipcclient.h"
29 #include "processevents-utilities.h"
30
31 #include <clangbackend_global.h>
32 #include <clangdocuments.h>
33 #include <clangexceptions.h>
34 #include <clangsupportivetranslationunitinitializer.h>
35 #include <clangtranslationunit.h>
36 #include <clangtranslationunits.h>
37 #include <utf8string.h>
38
39 #include <clang-c/Index.h>
40
41 #include <memory>
42
43 using namespace ClangBackEnd;
44
45 using testing::Eq;
46
47 namespace {
48
49 class SupportiveTranslationUnitInitializer : public ::testing::Test
50 {
51 protected:
52 void SetUp() override;
53 void parse();
54 Jobs::RunningJob createRunningJob(JobRequest::Type type) const;
55
56 void assertNoJobIsRunningAndEmptyQueue();
57 void assertSingleJobRunningAndEmptyQueue();
58
59 bool waitUntilJobChainFinished(int timeOutInMs = 10000) const;
60
61 protected:
62 Utf8String filePath{Utf8StringLiteral(TESTDATA_DIR"/translationunits.cpp")};
63
64 UnsavedFiles unsavedFiles;
65 const QVector<FileContainer> fileContainer{FileContainer(filePath)};
66 Documents documents{unsavedFiles};
67 Document document{documents.create(fileContainer).front()};
68 DummyIpcClient dummyClientInterface;
69
70 Jobs jobs{documents, unsavedFiles, dummyClientInterface};
71
72 ClangBackEnd::SupportiveTranslationUnitInitializer initializer{document, jobs};
73 };
74
75 using SupportiveTranslationUnitInitializerSlowTest = SupportiveTranslationUnitInitializer;
76
TEST_F(SupportiveTranslationUnitInitializer,HasInitiallyNotInitializedState)77 TEST_F(SupportiveTranslationUnitInitializer, HasInitiallyNotInitializedState)
78 {
79 ASSERT_THAT(initializer.state(), Eq(ClangBackEnd::SupportiveTranslationUnitInitializer::State::NotInitialized));
80 }
81
TEST_F(SupportiveTranslationUnitInitializer,StartInitializingAbortsIfDocumentIsClosed)82 TEST_F(SupportiveTranslationUnitInitializer, StartInitializingAbortsIfDocumentIsClosed)
83 {
84 documents.remove({FileContainer(filePath)});
85
86 initializer.startInitializing();
87
88 assertNoJobIsRunningAndEmptyQueue();
89 ASSERT_THAT(initializer.state(), Eq(ClangBackEnd::SupportiveTranslationUnitInitializer::State::Aborted));
90 }
91
TEST_F(SupportiveTranslationUnitInitializerSlowTest,StartInitializingAddsTranslationUnit)92 TEST_F(SupportiveTranslationUnitInitializerSlowTest, StartInitializingAddsTranslationUnit)
93 {
94 initializer.startInitializing();
95
96 ASSERT_THAT(document.translationUnits().size(), Eq(2));
97 ASSERT_FALSE(document.translationUnits().areAllTranslationUnitsParsed());
98 }
99
TEST_F(SupportiveTranslationUnitInitializerSlowTest,StartInitializingStartsJob)100 TEST_F(SupportiveTranslationUnitInitializerSlowTest, StartInitializingStartsJob)
101 {
102 initializer.startInitializing();
103
104 assertSingleJobRunningAndEmptyQueue();
105 const Jobs::RunningJob runningJob = jobs.runningJobs().first();
106 ASSERT_THAT(runningJob.jobRequest.type, JobRequest::Type::ParseSupportiveTranslationUnit);
107 }
108
TEST_F(SupportiveTranslationUnitInitializerSlowTest,Abort)109 TEST_F(SupportiveTranslationUnitInitializerSlowTest, Abort)
110 {
111 initializer.startInitializing();
112 assertSingleJobRunningAndEmptyQueue();
113
114 initializer.abort();
115
116 ASSERT_THAT(initializer.state(),
117 Eq(ClangBackEnd::SupportiveTranslationUnitInitializer::State::Aborted));
118 ASSERT_FALSE(jobs.jobFinishedCallback());
119 }
120
TEST_F(SupportiveTranslationUnitInitializer,CheckIfParseJobFinishedAbortsIfDocumentIsClosed)121 TEST_F(SupportiveTranslationUnitInitializer, CheckIfParseJobFinishedAbortsIfDocumentIsClosed)
122 {
123 documents.remove({FileContainer(filePath)});
124 initializer.setState(ClangBackEnd::SupportiveTranslationUnitInitializer::State::WaitingForParseJob);
125 const Jobs::RunningJob runningJob = createRunningJob(JobRequest::Type::ParseSupportiveTranslationUnit);
126
127 initializer.checkIfParseJobFinished(runningJob);
128
129 assertNoJobIsRunningAndEmptyQueue();
130 ASSERT_THAT(initializer.state(), Eq(ClangBackEnd::SupportiveTranslationUnitInitializer::State::Aborted));
131 }
132
TEST_F(SupportiveTranslationUnitInitializerSlowTest,CheckIfParseJobFinishedStartsJob)133 TEST_F(SupportiveTranslationUnitInitializerSlowTest, CheckIfParseJobFinishedStartsJob)
134 {
135 parse();
136 initializer.setState(ClangBackEnd::SupportiveTranslationUnitInitializer::State::WaitingForParseJob);
137 Jobs::RunningJob runningJob = createRunningJob(JobRequest::Type::ParseSupportiveTranslationUnit);
138
139 initializer.checkIfParseJobFinished(runningJob);
140 jobs.process();
141
142 ASSERT_THAT(jobs.runningJobs(), IsEmpty());
143 ASSERT_THAT(jobs.queue(), IsEmpty());
144 }
145
TEST_F(SupportiveTranslationUnitInitializerSlowTest,FullRun)146 TEST_F(SupportiveTranslationUnitInitializerSlowTest, FullRun)
147 {
148 parse();
149 initializer.startInitializing();
150
151 waitUntilJobChainFinished();
152 ASSERT_THAT(initializer.state(), Eq(ClangBackEnd::SupportiveTranslationUnitInitializer::State::Initialized));
153 }
154
SetUp()155 void SupportiveTranslationUnitInitializer::SetUp()
156 {
157 documents.setVisibleInEditors({filePath});
158 documents.setUsedByCurrentEditor(filePath);
159
160 const auto isDocumentClosed = [this](const Utf8String &filePath) {
161 return !documents.hasDocument(filePath);
162 };
163 initializer.setIsDocumentClosedChecker(isDocumentClosed);
164 }
165
parse()166 void SupportiveTranslationUnitInitializer::parse()
167 {
168 document.parse();
169 }
170
createRunningJob(JobRequest::Type type) const171 Jobs::RunningJob SupportiveTranslationUnitInitializer::createRunningJob(JobRequest::Type type) const
172 {
173 const JobRequest jobRequest = jobs.createJobRequest(document,
174 type,
175 PreferredTranslationUnit::LastUninitialized);
176 return Jobs::RunningJob{jobRequest, Utf8String(), QFuture<void>()};
177 }
178
assertNoJobIsRunningAndEmptyQueue()179 void SupportiveTranslationUnitInitializer::assertNoJobIsRunningAndEmptyQueue()
180 {
181 ASSERT_TRUE(jobs.runningJobs().isEmpty());
182 ASSERT_TRUE(jobs.queue().isEmpty());
183 }
184
assertSingleJobRunningAndEmptyQueue()185 void SupportiveTranslationUnitInitializer::assertSingleJobRunningAndEmptyQueue()
186 {
187 ASSERT_THAT(jobs.runningJobs().size(), Eq(1));
188 ASSERT_TRUE(jobs.queue().isEmpty());
189 }
190
waitUntilJobChainFinished(int timeOutInMs) const191 bool SupportiveTranslationUnitInitializer::waitUntilJobChainFinished(int timeOutInMs) const
192 {
193 const auto noJobsRunningAnymore = [this]() {
194 return jobs.runningJobs().isEmpty() && jobs.queue().isEmpty();
195 };
196
197 return ProcessEventUtilities::processEventsUntilTrue(noJobsRunningAnymore, timeOutInMs);
198 }
199
200 } // anonymous namespace
201