tests/plugins/Unity/filtersbindingstest.cpp · unity8

git.iko.soy/unity8

on ec6ad0c help sign in

unity8/tests/plugins/Unity/filtersbindingstest.cpp

346 lines 13 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 QVariant optvar = options->data(options->index(0));

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

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

249

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

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

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

253

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

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

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

257

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

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

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

261

262 // test active property changes

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

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

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

266

267 opt0->setActive(true);

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

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

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

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

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

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

274

275 opt1->setActive(true);

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

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

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

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

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

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

282

283 delete check_filter;

284 }

285}

286

287void FiltersBindingsTest::testRadioOptionFilter()

288{

289 auto model = createFilterModel();

290

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

292

293 // create filter out of 1st row

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

295 {

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

297 QVERIFY(core_filter != nullptr);

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

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

300 QVERIFY(radio_filter != nullptr);

301 auto options = radio_filter->options();

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

303

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

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

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

307

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

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

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

311

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

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

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

315

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

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

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

319

320 // test active property changes

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

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

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

324

325 opt0->setActive(true);

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

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

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

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

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

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

332

333 opt1->setActive(true);

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

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

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

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

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

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

340

341 delete radio_filter;

342 }

343

344}

345

346QTEST_MAIN(FiltersBindingsTest)