tests/plugins/Unity/filtersbindingstest.cpp · unity8

git.iko.soy/unity8

on f2191cb help sign in

unity8/tests/plugins/Unity/filtersbindingstest.cpp

353 lines 14 kB history raw

1/*

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

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

6* the Free Software Foundation; version 3.

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

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

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

11* GNU General Public License for more details.

12*

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

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

15*/

17#include "filtersbindingstest.h"

19// libunity-core

20#include <UnityCore/Filter.h>

21#include <UnityCore/MultiRangeFilter.h>

23// Qt

24#include <QTest>

25#include <QSignalSpy>

27// libunity

28#include <unity.h>

30// local

31#include "filter.h"

32#include "multirangefilter.h"

33#include "combinedfilteroption.h"

34#include "checkoptionfilter.h"

35#include "radiooptionfilter.h"

37void FiltersBindingsTest::initTestCase()

38{

39}

41GVariant* FiltersBindingsTest::createOptions(int numOfOptions)

42{

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

44 auto vb = g_variant_builder_new(vtype);

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

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

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

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

49 }

50 return g_variant_builder_end(vb);

51}

53DeeModel* FiltersBindingsTest::createFilterModel()

54{

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

56 auto model = dee_sequence_model_new();

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

58 return model;

59}

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

62{

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

64}

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

67{

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

69}

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

72{

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

74}

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

77{

78 GVariant* row[8];

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

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

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

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

85 GVariant *children[2];

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

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

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

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

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

92 row[4] = fhints;

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

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

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

97 dee_model_append_row(model, row);

98}

100void FiltersBindingsTest::testMultiRangeFilter()

101{

102 auto model = createFilterModel();

103

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

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

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

107

108 // create filter out of 1st row

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

110 {

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

112 QVERIFY(core_filter != nullptr);

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

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

115 QVERIFY(multi_filter != nullptr);

116 auto options = multi_filter->options();

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

118

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

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

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

122

123 delete multi_filter;

124 }

125

126 // create filter out of 2nd row

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

128 {

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

130 QVERIFY(core_filter != nullptr);

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

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

133 QVERIFY(multi_filter != nullptr);

134 auto options = multi_filter->options();

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

136

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

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

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

140

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

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

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

144

145 delete multi_filter;

146 }

147

148 // create filter out of 3nd row

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

150 {

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

152 QVERIFY(core_filter != nullptr);

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

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

155 QVERIFY(multi_filter != nullptr);

156 auto options = multi_filter->options();

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

158

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

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

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

162

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

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

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

166

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

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

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

170

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

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

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

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

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

176

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

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

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

180

181 // test active property changes

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

183

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

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

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

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

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

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

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

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

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

193

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

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

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

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

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

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

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

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

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

203

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

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

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

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

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

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

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

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

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

213

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

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

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

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

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

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

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

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

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

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

224

225 delete multi_filter;

226 }

227}

228

229void FiltersBindingsTest::testCheckOptionFilter()

230{

231 auto model = createFilterModel();

232

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

234

235 // create filter out of 1st row

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

237 {

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

239 QVERIFY(core_filter != nullptr);

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

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

242 QVERIFY(check_filter != nullptr);

243 auto options = check_filter->options();

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

245

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

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

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

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

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

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

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

253

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

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

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

257

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

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

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

261

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

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

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

265

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

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

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

269

270 // test active property changes

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

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

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

274

275 opt0->setActive(true);

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

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

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

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

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

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

282

283 opt1->setActive(true);

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

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

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

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

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

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

290

291 delete check_filter;

292 }

293}

294

295void FiltersBindingsTest::testRadioOptionFilter()

296{

297 auto model = createFilterModel();

298

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

300

301 // create filter out of 1st row

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

303 {

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

305 QVERIFY(core_filter != nullptr);

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

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

308 QVERIFY(radio_filter != nullptr);

309 auto options = radio_filter->options();

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

311

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

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

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

315

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

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

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

319

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

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

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

323

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

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

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

327

328 // test active property changes

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

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

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

332

333 opt0->setActive(true);

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

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

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

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

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

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

340

341 opt1->setActive(true);

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

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

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

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

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

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

348

349 delete radio_filter;

350 }

351}

352

353QTEST_MAIN(FiltersBindingsTest)