LeechCraft  0.6.70-16373-g319c272718
Modular cross-platform feature rich live environment.
oraltest_simplerecord.cpp
Go to the documentation of this file.
1 /**********************************************************************
2  * LeechCraft - modular cross-platform feature rich internet client.
3  * Copyright (C) 2006-2014 Georg Rudoy
4  *
5  * Distributed under the Boost Software License, Version 1.0.
6  * (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
7  **********************************************************************/
8 
10 #include "common.h"
11 #include "simplerecord.h"
12 
13 QTEST_GUILESS_MAIN (LC::Util::OralTest_SimpleRecord)
14 
15 namespace LC
16 {
17 namespace Util
18 {
19  namespace sph = oral::sph;
20 
21  void OralTest_SimpleRecord::testSimpleRecordInsertSelect ()
22  {
23  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
24  const auto& list = adapted->Select ();
25  QCOMPARE (list, (QList<SimpleRecord> { { 0, "0" }, { 1, "1" }, { 2, "2" } }));
26  }
27 
28  void OralTest_SimpleRecord::testSimpleRecordInsertReplaceSelect ()
29  {
30  auto db = MakeDatabase ();
31 
32  auto adapted = Util::oral::AdaptPtr<SimpleRecord, OralFactory> (db);
33  for (int i = 0; i < 3; ++i)
34  adapted->Insert (OralFactory {}, { 0, QString::number (i) }, lco::InsertAction::Replace::PKey);
35 
36  const auto& list = adapted->Select ();
37  QCOMPARE (list, (QList<SimpleRecord> { { 0, "2" } }));
38  }
39 
40  void OralTest_SimpleRecord::testSimpleRecordInsertIgnoreSelect ()
41  {
42  auto db = MakeDatabase ();
43 
44  auto adapted = Util::oral::AdaptPtr<SimpleRecord, OralFactory> (db);
45  for (int i = 0; i < 3; ++i)
46  adapted->Insert (OralFactory {}, { 0, QString::number (i) }, lco::InsertAction::Ignore);
47 
48  const auto& list = adapted->Select ();
49  QCOMPARE (list, (QList<SimpleRecord> { { 0, "0" } }));
50  }
51 
52  void OralTest_SimpleRecord::testSimpleRecordInsertSelectByPos ()
53  {
54  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
55  const auto& list = adapted->Select (sph::f<&SimpleRecord::ID_> == 1);
56  QCOMPARE (list, (QList<SimpleRecord> { { 1, "1" } }));
57  }
58 
59  void OralTest_SimpleRecord::testSimpleRecordInsertSelectByPos2 ()
60  {
61  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
62  const auto& list = adapted->Select (sph::f<&SimpleRecord::ID_> < 2);
63  QCOMPARE (list, (QList<SimpleRecord> { { 0, "0" }, { 1, "1" } }));
64  }
65 
66  void OralTest_SimpleRecord::testSimpleRecordInsertSelectByPos3 ()
67  {
68  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
69  const auto& list = adapted->Select (sph::f<&SimpleRecord::ID_> < 2 && sph::f<&SimpleRecord::Value_> == QString { "1" });
70  QCOMPARE (list, (QList<SimpleRecord> { { 1, "1" } }));
71  }
72 
73  void OralTest_SimpleRecord::testSimpleRecordInsertSelectOneByPos ()
74  {
75  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
76  const auto& single = adapted->SelectOne (sph::f<&SimpleRecord::ID_> == 1);
77  QCOMPARE (single, (std::optional<SimpleRecord> { { 1, "1" } }));
78  }
79 
80  void OralTest_SimpleRecord::testSimpleRecordInsertSelectByFields ()
81  {
82  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
83  const auto& list = adapted->Select (sph::f<&SimpleRecord::ID_> == 1);
84  QCOMPARE (list, (QList<SimpleRecord> { { 1, "1" } }));
85  }
86 
87  void OralTest_SimpleRecord::testSimpleRecordInsertSelectByFields2 ()
88  {
89  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
90  const auto& list = adapted->Select (sph::f<&SimpleRecord::ID_> < 2);
91  QCOMPARE (list, (QList<SimpleRecord> { { 0, "0" }, { 1, "1" } }));
92  }
93 
94  void OralTest_SimpleRecord::testSimpleRecordInsertSelectByFields3 ()
95  {
96  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
97  const auto& list = adapted->Select (sph::f<&SimpleRecord::ID_> < 2 && sph::f<&SimpleRecord::Value_> == QString { "1" });
98  QCOMPARE (list, (QList<SimpleRecord> { { 1, "1" } }));
99  }
100 
101  void OralTest_SimpleRecord::testSimpleRecordInsertSelectOneByFields ()
102  {
103  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
104  const auto& single = adapted->SelectOne (sph::f<&SimpleRecord::ID_> == 1);
105  QCOMPARE (single, (std::optional<SimpleRecord> { { 1, "1" } }));
106  }
107 
108  void OralTest_SimpleRecord::testSimpleRecordInsertSelectSingleFieldByFields ()
109  {
110  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
111  const auto& list = adapted->Select (sph::fields<&SimpleRecord::Value_>, sph::f<&SimpleRecord::ID_> < 2);
112  QCOMPARE (list, (QList<QString> { "0", "1" }));
113  }
114 
115  void OralTest_SimpleRecord::testSimpleRecordInsertSelectFieldsByFields ()
116  {
117  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
118  const auto& list = adapted->Select (sph::fields<&SimpleRecord::ID_, &SimpleRecord::Value_>, sph::f<&SimpleRecord::ID_> < 2);
119  QCOMPARE (list, (QList<std::tuple<int, QString>> { { 0, "0" }, { 1, "1" } }));
120  }
121 
122  void OralTest_SimpleRecord::testSimpleRecordInsertSelectFieldsByFieldsOrderAsc ()
123  {
124  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
125  const auto& list = adapted->Select (sph::fields<&SimpleRecord::ID_, &SimpleRecord::Value_>,
126  sph::f<&SimpleRecord::ID_> < 2,
127  oral::OrderBy<sph::asc<&SimpleRecord::Value_>>);
128  QCOMPARE (list, (QList<std::tuple<int, QString>> { { 0, "0" }, { 1, "1" } }));
129  }
130 
131  void OralTest_SimpleRecord::testSimpleRecordInsertSelectFieldsByFieldsOrderDesc ()
132  {
133  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
134  const auto& list = adapted->Select (sph::fields<&SimpleRecord::ID_, &SimpleRecord::Value_>,
135  sph::f<&SimpleRecord::ID_> < 2,
136  oral::OrderBy<sph::desc<&SimpleRecord::Value_>>);
137  QCOMPARE (list, (QList<std::tuple<int, QString>> { { 1, "1" }, { 0, "0" } }));
138  }
139 
140  void OralTest_SimpleRecord::testSimpleRecordInsertSelectFieldsByFieldsOrderManyAsc ()
141  {
142  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
143  const auto& list = adapted->Select (sph::fields<&SimpleRecord::ID_, &SimpleRecord::Value_>,
144  sph::f<&SimpleRecord::ID_> < 2,
145  oral::OrderBy<sph::asc<&SimpleRecord::Value_>, sph::desc<&SimpleRecord::ID_>>);
146  QCOMPARE (list, (QList<std::tuple<int, QString>> { { 0, "0" }, { 1, "1" } }));
147  }
148 
149  void OralTest_SimpleRecord::testSimpleRecordInsertSelectFieldsByFieldsOrderManyDesc ()
150  {
151  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
152  const auto& list = adapted->Select (sph::fields<&SimpleRecord::ID_, &SimpleRecord::Value_>,
153  sph::f<&SimpleRecord::ID_> < 2,
154  oral::OrderBy<sph::desc<&SimpleRecord::Value_>, sph::asc<&SimpleRecord::ID_>>);
155  QCOMPARE (list, (QList<std::tuple<int, QString>> { { 1, "1" }, { 0, "0" } }));
156  }
157 
158  void OralTest_SimpleRecord::testSimpleRecordInsertSelectNoOffsetLimit ()
159  {
160  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase (), 10);
161  const auto& list = adapted->Select.Build ().Limit (2) ();
162  QCOMPARE (list, (QList<SimpleRecord> { { 0, "0" }, { 1, "1" } }));
163  }
164 
165  /*
166  void OralTest_SimpleRecord::testSimpleRecordInsertSelectOffsetNoLimit ()
167  {
168  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase (), 10);
169  const auto& list = adapted->Select.Build ().Offset ({ 8 }) ();
170  QCOMPARE (list, (QList<SimpleRecord> { { 8, "8" }, { 9, "9" } }));
171  }
172  */
173 
174  void OralTest_SimpleRecord::testSimpleRecordInsertSelectOffsetLimit ()
175  {
176  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase (), 10);
177  const auto& list = adapted->Select.Build ().Offset (5).Limit (2) ();
178  QCOMPARE (list, (QList<SimpleRecord> { { 5, "5" }, { 6, "6" } }));
179  }
180 
181  void OralTest_SimpleRecord::testSimpleRecordInsertSelectCount ()
182  {
183  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
184  const auto count = adapted->Select (sph::count<>);
185  QCOMPARE (count, 3);
186  }
187 
188  void OralTest_SimpleRecord::testSimpleRecordInsertSelectCountByFields ()
189  {
190  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
191  const auto count = adapted->Select (sph::count<>, sph::f<&SimpleRecord::ID_> < 2);
192  QCOMPARE (count, 2);
193  }
194 
195  void OralTest_SimpleRecord::testSimpleRecordInsertSelectMin ()
196  {
197  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
198  const auto min = adapted->Select (sph::min<&SimpleRecord::ID_>);
199  QCOMPARE (min, 0);
200  }
201 
202  void OralTest_SimpleRecord::testSimpleRecordInsertSelectMax ()
203  {
204  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
205  const auto max = adapted->Select (sph::max<&SimpleRecord::ID_>);
206  QCOMPARE (max, 2);
207  }
208 
209  void OralTest_SimpleRecord::testSimpleRecordInsertSelectMinPlusMax ()
210  {
211  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
212  const auto minMax = adapted->Select (sph::min<&SimpleRecord::ID_> + sph::max<&SimpleRecord::ID_>);
213  QCOMPARE (minMax, (std::tuple { 0, 2 }));
214  }
215 
216  void OralTest_SimpleRecord::testSimpleRecordInsertSelectValuePlusMinPlusMax ()
217  {
218  auto adapted = oral::AdaptPtr<SimpleRecord, OralFactory> (MakeDatabase ());
219  for (int i = 0; i < 3; ++i)
220  adapted->Insert ({ i, "0" });
221  for (int i = 3; i < 6; ++i)
222  adapted->Insert ({ i, "1" });
223 
224  const auto allMinMax = adapted->Select.Build ()
225  .Select (sph::fields<&SimpleRecord::Value_> + sph::min<&SimpleRecord::ID_> + sph::max<&SimpleRecord::ID_>)
226  .Group (oral::GroupBy<&SimpleRecord::Value_>)
227  ();
228  QCOMPARE (allMinMax, (QList<std::tuple<QString, int, int>> { { { "0" }, 0, 2 }, { { "1" }, 3, 5 } }));
229  }
230 
231  void OralTest_SimpleRecord::testSimpleRecordInsertSelectAllPlusMinPlusMax ()
232  {
233  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase (), 2);
234  const auto allMinMax = adapted->Select.Build ()
235  .Select (sph::all + sph::min<&SimpleRecord::ID_> + sph::max<&SimpleRecord::ID_>)
237  ();
238  QCOMPARE (allMinMax, (QList<std::tuple<SimpleRecord, int, int>> { { { 0, "0" }, 0, 0 }, { { 1, "1" }, 1, 1 } }));
239  }
240 
241  void OralTest_SimpleRecord::testSimpleRecordInsertSelectLike ()
242  {
243  using namespace oral::infix;
244 
245  auto adapted = Util::oral::AdaptPtr<SimpleRecord, OralFactory> (MakeDatabase ());
246  adapted->Insert ({ 0, "foo" });
247  adapted->Insert ({ 1, "bar" });
248  adapted->Insert ({ 2, "foobar" });
249  const auto& list = adapted->Select (sph::f<&SimpleRecord::Value_> |like| QString { "%oo%" });
250  QCOMPARE (list, (QList<SimpleRecord> { { 0, "foo" }, { 2, "foobar" } }));
251  }
252 
253  void OralTest_SimpleRecord::testSimpleRecordUpdate ()
254  {
255  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
256  adapted->Update ({ 0, "meh" });
257  const auto updated = adapted->Select (sph::f<&SimpleRecord::ID_> == 0);
258  QCOMPARE (updated, (QList<SimpleRecord> { { 0, "meh" } }));
259  }
260 
261  void OralTest_SimpleRecord::testSimpleRecordUpdateExprTree ()
262  {
263  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
264  adapted->Update (sph::f<&SimpleRecord::Value_> = QString { "meh" }, sph::f<&SimpleRecord::ID_> == 0);
265  const auto updated = adapted->Select (sph::f<&SimpleRecord::ID_> == 0);
266  QCOMPARE (updated, (QList<SimpleRecord> { { 0, "meh" } }));
267  }
268 
269  void OralTest_SimpleRecord::testSimpleRecordUpdateMultiExprTree ()
270  {
271  auto adapted = PrepareRecords<SimpleRecord> (MakeDatabase ());
272  adapted->Update ((sph::f<&SimpleRecord::Value_> = QString { "meh" }, sph::f<&SimpleRecord::ID_> = 10),
273  sph::f<&SimpleRecord::ID_> == 0);
274  const auto updated = adapted->Select (sph::f<&SimpleRecord::ID_> == 10);
275  QCOMPARE (updated, (QList<SimpleRecord> { { 10, "meh" } }));
276  }
277 }
278 }
lco::PKey< int, lco::NoAutogen > ID_
Definition: simplerecord.h:17
constexpr detail::AggregateType< detail::AggregateFunction::Count, Ptr > count
Definition: oral.h:965
constexpr detail::OrderBy< Orders... > OrderBy
Definition: oral.h:975
constexpr detail::AggregateType< detail::AggregateFunction::Max, Ptr > max
Definition: oral.h:971
static constexpr struct LC::Util::oral::InsertAction::IgnoreTag Ignore
QString Value_
Definition: simplerecord.h:18
QSqlDatabase MakeDatabase(const QString &name=":memory:")
Definition: common.h:73
constexpr detail::InfixBinary< detail::ExprType::Like > like
Definition: oral.h:854
constexpr detail::AggregateType< detail::AggregateFunction::Min, Ptr > min
Definition: oral.h:968
constexpr detail::SelectWhole all
Definition: oral.h:956