tests/plugins/Unity/filtersbindingstest.cpp · unity8

git.iko.soy/unity8

on c3f467b help sign in

unity8/tests/plugins/Unity/filtersbindingstest.cpp

356 lines 14 kB history raw

1/*

4* Authors:

5* Pawel Stolowski <pawel.stolowski@canonical.com>

7* This program is free software; you can redistribute it and/or modify

8* it under the terms of the GNU General Public License as published by

9* the Free Software Foundation; version 3.

10*

11* This program is distributed in the hope that it will be useful,

12* but WITHOUT ANY WARRANTY; without even the implied warranty of

13* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14* GNU General Public License for more details.

15*

16* You should have received a copy of the GNU General Public License

17* along with this program. If not, see <http://www.gnu.org/licenses/>.

18*/

20#include "filtersbindingstest.h"

22// libunity-core

23#include <UnityCore/Filter.h>

24#include <UnityCore/MultiRangeFilter.h>

26// Qt

27#include <QTest>

28#include <QSignalSpy>

30// libunity

31#include <unity.h>

33// local

34#include "filter.h"

35#include "multirangefilter.h"

36#include "combinedfilteroption.h"

37#include "checkoptionfilter.h"

38#include "radiooptionfilter.h"

40void FiltersBindingsTest::initTestCase()

41{

42}

44GVariant* FiltersBindingsTest::createOptions(int numOfOptions)

45{

46 auto vtype = g_variant_type_new("a(sssb)");

47 auto vb = g_variant_builder_new(vtype);

48 for (int i = 0; i<numOfOptions; i++) {

49 const std::string optId = "opt" + std::to_string(i);

50 const std::string optName = "Option " + std::to_string(i);

51 g_variant_builder_add(vb, "(sssb)", optId.c_str(), optName.c_str(), "", false);

52 }

53 return g_variant_builder_end(vb);

54}

56DeeModel* FiltersBindingsTest::createFilterModel()

57{

58 const char* filter_schema[8] = {"s", "s", "s", "s", "a{sv}", "b", "b", "b"};

59 auto model = dee_sequence_model_new();

60 dee_model_set_schema_full (DEE_MODEL(model), filter_schema, 8);

61 return model;

62}

64void FiltersBindingsTest::createMultiRangeFilter(DeeModel *model, const std::string &id, const std::string &name, int optionCount)

65{

66 createFilter(model, "filter-multirange", id, name, optionCount);

67}

69void FiltersBindingsTest::createRadioOptionFilter(DeeModel *model, const std::string &id, const std::string &name, int optionCount)

70{

71 createFilter(model, "filter-radiooption", id, name, optionCount);

72}

74void FiltersBindingsTest::createCheckOptionFilter(DeeModel *model, const std::string &id, const std::string &name, int optionCount)

75{

76 createFilter(model, "filter-checkoption", id, name, optionCount);

77}

79void FiltersBindingsTest::createFilter(DeeModel *model, const std::string &renderer, const std::string &id, const std::string &name, int optionCount)

80{

81 GVariant* row[8];

83 row[0] = g_variant_new_string(id.c_str());

84 row[1] = g_variant_new_string(name.c_str());

85 row[2] = g_variant_new_string(""); // icon hint

86 row[3] = g_variant_new_string(renderer.c_str()); // renderer

88 GVariant *children[2];

89 GVariant *key1 = g_variant_new_string("show-all-button");

90 GVariant *key2 = g_variant_new_string("options");

91 children[0] = g_variant_new_dict_entry(key1, g_variant_new_variant(g_variant_new_boolean(false)));

92 children[1] = g_variant_new_dict_entry(key2, g_variant_new_variant(createOptions(optionCount)));

93 auto fhints = g_variant_new_array(G_VARIANT_TYPE("{sv}"), children, 2);

95 row[4] = fhints;

96 row[5] = g_variant_new_boolean(true); // visible

97 row[6] = g_variant_new_boolean(false); // collapsed

98 row[7] = g_variant_new_boolean(false); // filtering

100 dee_model_append_row(model, row);

101}

102

103void FiltersBindingsTest::testMultiRangeFilter()

104{

105 auto model = createFilterModel();

106

107 createMultiRangeFilter(model, "f1", "Filter1", 1);

108 createMultiRangeFilter(model, "f2", "Filter2", 2);

109 createMultiRangeFilter(model, "f3", "Filter3", 3);

110

111 // create filter out of 1st row

112 auto iter = dee_model_get_first_iter(DEE_MODEL(model));

113 {

114 auto core_filter = unity::dash::Filter::FilterFromIter(model, iter);

115 QVERIFY(core_filter != nullptr);

116 auto bind_filter = Filter::newFromUnityFilter(core_filter);

117 auto multi_filter = dynamic_cast<MultiRangeFilter*>(bind_filter);

118 QVERIFY(multi_filter != nullptr);

119 auto options = multi_filter->options();

120 QCOMPARE(options->rowCount(), 1);

121

122 QVariant optvar = options->data(options->index(0));

123 CombinedFilterOption* opt1 = optvar.value<CombinedFilterOption*>();

124 QCOMPARE(opt1->id(), QString("opt0"));

125

126 delete multi_filter;

127 }

128

129 // create filter out of 2nd row

130 iter = dee_model_next(DEE_MODEL(model), iter);

131 {

132 auto core_filter = unity::dash::Filter::FilterFromIter(model, iter);

133 QVERIFY(core_filter != nullptr);

134 auto bind_filter = Filter::newFromUnityFilter(core_filter);

135 auto multi_filter = dynamic_cast<MultiRangeFilter*>(bind_filter);

136 QVERIFY(multi_filter != nullptr);

137 auto options = multi_filter->options();

138 QCOMPARE(options->rowCount(), 2);

139

140 QVariant optvar = options->data(options->index(0));

141 CombinedFilterOption* opt1 = optvar.value<CombinedFilterOption*>();

142 QCOMPARE(opt1->id(), QString("opt0-opt1"));

143

144 optvar = options->data(options->index(1));

145 CombinedFilterOption* opt2 = optvar.value<CombinedFilterOption*>();

146 QCOMPARE(opt2->id(), QString("opt1"));

147

148 delete multi_filter;

149 }

150

151 // create filter out of 3nd row

152 iter = dee_model_next(DEE_MODEL(model), iter);

153 {

154 auto core_filter = unity::dash::Filter::FilterFromIter(model, iter);

155 QVERIFY(core_filter != nullptr);

156 auto bind_filter = Filter::newFromUnityFilter(core_filter);

157 auto multi_filter = dynamic_cast<MultiRangeFilter*>(bind_filter);

158 QVERIFY(multi_filter != nullptr);

159 auto options = multi_filter->options();

160 QCOMPARE(options->rowCount(), 3);

161

162 QVariant optvar = options->data(options->index(0));

163 CombinedFilterOption* opt0 = optvar.value<CombinedFilterOption*>();

164 QCOMPARE(opt0->id(), QString("opt0-opt1"));

165

166 optvar = options->data(options->index(1));

167 CombinedFilterOption* opt1 = optvar.value<CombinedFilterOption*>();

168 QCOMPARE(opt1->id(), QString("opt1-opt2"));

169

170 optvar = options->data(options->index(2));

171 CombinedFilterOption* opt2 = optvar.value<CombinedFilterOption*>();

172 QCOMPARE(opt2->id(), QString("opt2"));

173

174 // verify combined filter options are bound to correct underlying unity options

175 auto core_multi_filter = std::dynamic_pointer_cast<unity::dash::MultiRangeFilter>(core_filter);

176 QCOMPARE(QString::fromStdString(core_multi_filter->options()[0]->id()), QString("opt0"));

177 QCOMPARE(QString::fromStdString(core_multi_filter->options()[1]->id()), QString("opt1"));

178 QCOMPARE(QString::fromStdString(core_multi_filter->options()[2]->id()), QString("opt2"));

179

180 QSignalSpy opt0spy(opt0, SIGNAL(activeChanged(bool)));

181 QSignalSpy opt1spy(opt1, SIGNAL(activeChanged(bool)));

182 QSignalSpy opt2spy(opt2, SIGNAL(activeChanged(bool)));

183

184 // test active property changes

185 QCOMPARE(opt0->active(), false);

186

187 opt0->setActive(true); // activate 1st combined option

188 QCOMPARE(opt0spy.count(), 1);

189 QCOMPARE(opt1spy.count(), 0);

190 QCOMPARE(opt2spy.count(), 0);

191 QCOMPARE(opt0->active(), true);

192 QCOMPARE(opt1->active(), false);

193 QCOMPARE(core_multi_filter->options()[0]->active(), true);

194 QCOMPARE(core_multi_filter->options()[1]->active(), true);

195 QCOMPARE(core_multi_filter->options()[2]->active(), false);

196

197 opt1->setActive(true); // activate another combined option

198 QCOMPARE(opt0spy.count(), 2);

199 QCOMPARE(opt1spy.count(), 1);

200 QCOMPARE(opt2spy.count(), 0);

201 QCOMPARE(opt0->active(), false); //1st combined option gets deactivated

202 QCOMPARE(opt1->active(), true);

203 QCOMPARE(core_multi_filter->options()[0]->active(), false);

204 QCOMPARE(core_multi_filter->options()[1]->active(), true); // shared option, stays active

205 QCOMPARE(core_multi_filter->options()[2]->active(), true);

206

207 opt1->setActive(false); // and de-activate it

208 QCOMPARE(opt0spy.count(), 2);

209 QCOMPARE(opt1spy.count(), 2);

210 QCOMPARE(opt2spy.count(), 0);

211 QCOMPARE(opt0->active(), false);

212 QCOMPARE(opt1->active(), false);

213 QCOMPARE(core_multi_filter->options()[0]->active(), false);

214 QCOMPARE(core_multi_filter->options()[1]->active(), false);

215 QCOMPARE(core_multi_filter->options()[2]->active(), false);

216

217 opt2->setActive(true); // activate another combined option

218 QCOMPARE(opt0spy.count(), 2);

219 QCOMPARE(opt1spy.count(), 2);

220 QCOMPARE(opt2spy.count(), 1);

221 QCOMPARE(opt0->active(), false);

222 QCOMPARE(opt1->active(), false);

223 QCOMPARE(opt2->active(), true);

224 QCOMPARE(core_multi_filter->options()[0]->active(), false);

225 QCOMPARE(core_multi_filter->options()[1]->active(), false);

226 QCOMPARE(core_multi_filter->options()[2]->active(), true);

227

228 delete multi_filter;

229 }

230}

231

232void FiltersBindingsTest::testCheckOptionFilter()

233{

234 auto model = createFilterModel();

235

236 createCheckOptionFilter(model, "f1", "Filter1", 3);

237

238 // create filter out of 1st row

239 auto iter = dee_model_get_first_iter(DEE_MODEL(model));

240 {

241 auto core_filter = unity::dash::Filter::FilterFromIter(model, iter);

242 QVERIFY(core_filter != nullptr);

243 auto bind_filter = Filter::newFromUnityFilter(core_filter);

244 auto check_filter = dynamic_cast<CheckOptionFilter*>(bind_filter);

245 QVERIFY(check_filter != nullptr);

246 auto options = check_filter->options();

247 QCOMPARE(options->rowCount(), 3);

248

249 QCOMPARE(check_filter->id(), QString("f1"));

250 QCOMPARE(check_filter->name(), QString("Filter1"));

251 QCOMPARE(check_filter->iconHint(), QString(""));

252 QCOMPARE(check_filter->rendererName(), QString("filter-checkoption"));

253 QCOMPARE(check_filter->visible(), true);

254 QCOMPARE(check_filter->collapsed(), false);

255 QCOMPARE(check_filter->filtering(), false);

256

257 QVariant optvar = options->data(options->index(0));

258 FilterOption* opt0 = optvar.value<FilterOption*>();

259 QCOMPARE(opt0->id(), QString("opt0"));

260

261 optvar = options->data(options->index(1));

262 FilterOption* opt1 = optvar.value<FilterOption*>();

263 QCOMPARE(opt1->id(), QString("opt1"));

264

265 optvar = options->data(options->index(2));

266 FilterOption* opt2 = optvar.value<FilterOption*>();

267 QCOMPARE(opt2->id(), QString("opt2"));

268

269 QSignalSpy opt0spy(opt0, SIGNAL(activeChanged(bool)));

270 QSignalSpy opt1spy(opt1, SIGNAL(activeChanged(bool)));

271 QSignalSpy opt2spy(opt2, SIGNAL(activeChanged(bool)));

272

273 // test active property changes

274 QCOMPARE(opt0->active(), false);

275 QCOMPARE(opt1->active(), false);

276 QCOMPARE(opt2->active(), false);

277

278 opt0->setActive(true);

279 QCOMPARE(opt0spy.count(), 1);

280 QCOMPARE(opt1spy.count(), 0);

281 QCOMPARE(opt2spy.count(), 0);

282 QCOMPARE(opt0->active(), true);

283 QCOMPARE(opt1->active(), false);

284 QCOMPARE(opt2->active(), false);

285

286 opt1->setActive(true);

287 QCOMPARE(opt0spy.count(), 2);

288 QCOMPARE(opt1spy.count(), 1);

289 QCOMPARE(opt2spy.count(), 0);

290 QCOMPARE(opt0->active(), false);

291 QCOMPARE(opt1->active(), true);

292 QCOMPARE(opt2->active(), false);

293

294 delete check_filter;

295 }

296}

297

298void FiltersBindingsTest::testRadioOptionFilter()

299{

300 auto model = createFilterModel();

301

302 createRadioOptionFilter(model, "f1", "Filter1", 3);

303

304 // create filter out of 1st row

305 auto iter = dee_model_get_first_iter(DEE_MODEL(model));

306 {

307 auto core_filter = unity::dash::Filter::FilterFromIter(model, iter);

308 QVERIFY(core_filter != nullptr);

309 auto bind_filter = Filter::newFromUnityFilter(core_filter);

310 auto radio_filter = dynamic_cast<RadioOptionFilter*>(bind_filter);

311 QVERIFY(radio_filter != nullptr);

312 auto options = radio_filter->options();

313 QCOMPARE(options->rowCount(), 3);

314

315 QVariant optvar = options->data(options->index(0));

316 FilterOption* opt0 = optvar.value<FilterOption*>();

317 QCOMPARE(opt0->id(), QString("opt0"));

318

319 optvar = options->data(options->index(1));

320 FilterOption* opt1 = optvar.value<FilterOption*>();

321 QCOMPARE(opt1->id(), QString("opt1"));

322

323 optvar = options->data(options->index(2));

324 FilterOption* opt2 = optvar.value<FilterOption*>();

325 QCOMPARE(opt2->id(), QString("opt2"));

326

327 QSignalSpy opt0spy(opt0, SIGNAL(activeChanged(bool)));

328 QSignalSpy opt1spy(opt1, SIGNAL(activeChanged(bool)));

329 QSignalSpy opt2spy(opt2, SIGNAL(activeChanged(bool)));

330

331 // test active property changes

332 QCOMPARE(opt0->active(), false);

333 QCOMPARE(opt1->active(), false);

334 QCOMPARE(opt2->active(), false);

335

336 opt0->setActive(true);

337 QCOMPARE(opt0spy.count(), 1);

338 QCOMPARE(opt1spy.count(), 0);

339 QCOMPARE(opt2spy.count(), 0);

340 QCOMPARE(opt0->active(), true);

341 QCOMPARE(opt1->active(), false);

342 QCOMPARE(opt2->active(), false);

343

344 opt1->setActive(true);

345 QCOMPARE(opt0spy.count(), 2);

346 QCOMPARE(opt1spy.count(), 1);

347 QCOMPARE(opt2spy.count(), 0);

348 QCOMPARE(opt0->active(), false);

349 QCOMPARE(opt1->active(), true);

350 QCOMPARE(opt2->active(), false);

351

352 delete radio_filter;

353 }

354}

355

356QTEST_MAIN(FiltersBindingsTest)