Skip to content

Commit 9a6facb

Browse files
ankaneankane
committed
Added assert_exception function
1 parent fd096e2 commit 9a6facb

File tree

1 file changed

+60
-115
lines changed

1 file changed

+60
-115
lines changed

‎test/pqxx_test.cpp‎

Lines changed: 60 additions & 115 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,20 @@ void before_each(pqxx::connection &conn) {
1919
tx.exec("TRUNCATE items");
2020
}
2121

22+
template<typename T>
23+
void assert_exception(std::function<void(void)> code, std::optional<std::string_view> message = std::nullopt) {
24+
bool exception = false;
25+
try {
26+
code();
27+
} catch (const T& e) {
28+
exception = true;
29+
if (message) {
30+
assert(std::string_view(e.what()) == *message);
31+
}
32+
}
33+
assert(exception);
34+
}
35+
2236
void test_vector(pqxx::connection &conn) {
2337
before_each(conn);
2438

@@ -89,12 +103,9 @@ void test_sparsevec_nnz(pqxx::connection &conn) {
89103
pqxx::nontransaction tx(conn);
90104
std::vector<float> vec(16001, 1);
91105
auto embedding = pgvector::SparseVector(vec);
92-
try {
106+
assert_exception<pqxx::conversion_overrun>([&] {
93107
tx.exec("INSERT INTO items (sparse_embedding) VALUES ($1)", {embedding});
94-
assert(false);
95-
} catch (const pqxx::conversion_overrun& e) {
96-
assert(std::string_view(e.what()) == "sparsevec cannot have more than 16000 dimensions");
97-
}
108+
}, "sparsevec cannot have more than 16000 dimensions");
98109
}
99110

100111
void test_stream(pqxx::connection &conn) {
@@ -138,82 +149,55 @@ void test_precision(pqxx::connection &conn) {
138149
void test_vector_to_string() {
139150
assert(pqxx::to_string(pgvector::Vector({1, 2, 3})) == "[1,2,3]");
140151

141-
try {
152+
assert_exception<pqxx::conversion_overrun>([] {
142153
auto unused = pqxx::to_string(pgvector::Vector(std::vector<float>(16001)));
143-
assert(false);
144-
} catch (const pqxx::conversion_overrun& e) {
145-
assert(std::string_view(e.what()) == "vector cannot have more than 16000 dimensions");
146-
}
154+
}, "vector cannot have more than 16000 dimensions");
147155
}
148156

149157
void test_vector_from_string() {
150158
assert(pqxx::from_string<pgvector::Vector>("[1,2,3]") == pgvector::Vector({1, 2, 3}));
151159
assert(pqxx::from_string<pgvector::Vector>("[]") == pgvector::Vector(std::vector<float>{}));
152160

153-
try {
161+
assert_exception<pqxx::conversion_error>([] {
154162
auto unused = pqxx::from_string<pgvector::Vector>("");
155-
assert(false);
156-
} catch (const pqxx::conversion_error& e) {
157-
assert(std::string_view(e.what()) == "Malformed vector literal");
158-
}
163+
}, "Malformed vector literal");
159164

160-
try {
165+
assert_exception<pqxx::conversion_error>([] {
161166
auto unused = pqxx::from_string<pgvector::Vector>("[");
162-
assert(false);
163-
} catch (const pqxx::conversion_error& e) {
164-
assert(std::string_view(e.what()) == "Malformed vector literal");
165-
}
167+
}, "Malformed vector literal");
166168

167-
try {
169+
assert_exception<pqxx::conversion_error>([] {
168170
auto unused = pqxx::from_string<pgvector::Vector>("[hello]");
169-
assert(false);
170-
} catch (const pqxx::conversion_error& e) {
171-
assert(true);
172-
}
171+
});
173172

174-
try {
173+
assert_exception<pqxx::conversion_error>([] {
175174
auto unused = pqxx::from_string<pgvector::Vector>("[4e38]");
176-
assert(false);
177-
} catch (const pqxx::conversion_error& e) {
178-
assert(true);
179-
}
175+
});
180176
}
181177

182178
void test_halfvec_to_string() {
183179
assert(pqxx::to_string(pgvector::HalfVector({1, 2, 3})) == "[1,2,3]");
184180

185-
try {
181+
assert_exception<pqxx::conversion_overrun>([] {
186182
auto unused = pqxx::to_string(pgvector::HalfVector(std::vector<float>(16001)));
187-
assert(false);
188-
} catch (const pqxx::conversion_overrun& e) {
189-
assert(std::string_view(e.what()) == "halfvec cannot have more than 16000 dimensions");
190-
}
183+
}, "halfvec cannot have more than 16000 dimensions");
191184
}
192185

193186
void test_halfvec_from_string() {
194187
assert(pqxx::from_string<pgvector::HalfVector>("[1,2,3]") == pgvector::HalfVector({1, 2, 3}));
195188
assert(pqxx::from_string<pgvector::HalfVector>("[]") == pgvector::HalfVector(std::vector<float>{}));
196189

197-
try {
190+
assert_exception<pqxx::conversion_error>([] {
198191
auto unused = pqxx::from_string<pgvector::HalfVector>("");
199-
assert(false);
200-
} catch (const pqxx::conversion_error& e) {
201-
assert(std::string_view(e.what()) == "Malformed halfvec literal");
202-
}
192+
}, "Malformed halfvec literal");
203193

204-
try {
194+
assert_exception<pqxx::conversion_error>([] {
205195
auto unused = pqxx::from_string<pgvector::HalfVector>("[");
206-
assert(false);
207-
} catch (const pqxx::conversion_error& e) {
208-
assert(std::string_view(e.what()) == "Malformed halfvec literal");
209-
}
196+
}, "Malformed halfvec literal");
210197

211-
try {
198+
assert_exception<pqxx::conversion_error>([] {
212199
auto unused = pqxx::from_string<pgvector::HalfVector>("[hello]");
213-
assert(false);
214-
} catch (const pqxx::conversion_error& e) {
215-
assert(true);
216-
}
200+
});
217201
}
218202

219203
void test_sparsevec_to_string() {
@@ -224,96 +208,57 @@ void test_sparsevec_from_string() {
224208
assert(pqxx::from_string<pgvector::SparseVector>("{1:1,3:2,5:3}/6") == pgvector::SparseVector({1, 0, 2, 0, 3, 0}));
225209
assert(pqxx::from_string<pgvector::SparseVector>("{}/6") == pgvector::SparseVector({0, 0, 0, 0, 0, 0}));
226210

227-
try {
211+
assert_exception<pqxx::conversion_error>([] {
228212
auto unused = pqxx::from_string<pgvector::SparseVector>("");
229-
assert(false);
230-
} catch (const pqxx::conversion_error& e) {
231-
assert(std::string_view(e.what()) == "Malformed sparsevec literal");
232-
}
213+
}, "Malformed sparsevec literal");
233214

234-
try {
215+
assert_exception<pqxx::conversion_error>([] {
235216
auto unused = pqxx::from_string<pgvector::SparseVector>("{");
236-
assert(false);
237-
} catch (const pqxx::conversion_error& e) {
238-
assert(std::string_view(e.what()) == "Malformed sparsevec literal");
239-
}
217+
}, "Malformed sparsevec literal");
240218

241-
try {
219+
assert_exception<pqxx::conversion_error>([] {
242220
auto unused = pqxx::from_string<pgvector::SparseVector>("{ }/");
243-
assert(false);
244-
} catch (const pqxx::conversion_error& e) {
245-
assert(std::string_view(e.what()) == "Could not convert '' to int: Invalid argument.");
246-
}
221+
}, "Could not convert '' to int: Invalid argument.");
247222

248-
try {
223+
assert_exception<pqxx::conversion_error>([] {
249224
auto unused = pqxx::from_string<pgvector::SparseVector>("{}/-1");
250-
assert(false);
251-
} catch (const pqxx::conversion_error& e) {
252-
assert(std::string_view(e.what()) == "Dimensions cannot be negative");
253-
}
225+
}, "Dimensions cannot be negative");
254226

255-
try {
227+
assert_exception<pqxx::conversion_error>([] {
256228
auto unused = pqxx::from_string<pgvector::SparseVector>("{:}/1");
257-
assert(false);
258-
} catch (const pqxx::conversion_error& e) {
259-
assert(std::string_view(e.what()) == "Could not convert '' to int: Invalid argument.");
260-
}
229+
}, "Could not convert '' to int: Invalid argument.");
261230

262-
try {
231+
assert_exception<pqxx::conversion_error>([] {
263232
auto unused = pqxx::from_string<pgvector::SparseVector>("{,}/1");
264-
assert(false);
265-
} catch (const pqxx::conversion_error& e) {
266-
assert(std::string_view(e.what()) == "Malformed sparsevec literal");
267-
}
233+
}, "Malformed sparsevec literal");
268234

269-
try {
235+
assert_exception<pqxx::conversion_error>([] {
270236
auto unused = pqxx::from_string<pgvector::SparseVector>("{0:1}/1");
271-
assert(false);
272-
} catch (const pqxx::conversion_error& e) {
273-
assert(std::string_view(e.what()) == "Index out of bounds");
274-
}
237+
}, "Index out of bounds");
275238

276-
try {
239+
assert_exception<pqxx::conversion_error>([] {
277240
auto unused = pqxx::from_string<pgvector::SparseVector>("{-2147483648:1}/1");
278-
assert(false);
279-
} catch (const pqxx::conversion_error& e) {
280-
assert(std::string_view(e.what()) == "Index out of bounds");
281-
}
241+
}, "Index out of bounds");
282242

283-
try {
243+
assert_exception<pqxx::conversion_error>([] {
284244
auto unused = pqxx::from_string<pgvector::SparseVector>("{1:4e38}/1");
285-
assert(false);
286-
} catch (const pqxx::conversion_error& e) {
287-
assert(std::string_view(e.what()) == "Could not convert string to numeric value: '4e38'." || std::string_view(e.what()) == "Could not convert '4e38' to float" || std::string_view(e.what()) == "Could not convert '4e38' to float: Value out of range.");
288-
}
245+
});
289246

290-
try {
247+
assert_exception<pqxx::conversion_error>([] {
291248
auto unused = pqxx::from_string<pgvector::SparseVector>("{a:1}/1");
292-
assert(false);
293-
} catch (const pqxx::conversion_error& e) {
294-
assert(std::string_view(e.what()) == "Could not convert 'a' to int: Invalid argument.");
295-
}
249+
}, "Could not convert 'a' to int: Invalid argument.");
296250

297-
try {
251+
assert_exception<pqxx::conversion_error>([] {
298252
auto unused = pqxx::from_string<pgvector::SparseVector>("{1:a}/1");
299-
assert(false);
300-
} catch (const pqxx::conversion_error& e) {
301-
assert(std::string_view(e.what()) == "Could not convert string to numeric value: 'a'." || std::string_view(e.what()) == "Could not convert 'a' to float" || std::string_view(e.what()) == "Could not convert 'a' to float: Invalid argument.");
302-
}
253+
});
303254

304-
try {
255+
assert_exception<pqxx::conversion_error>([] {
305256
auto unused = pqxx::from_string<pgvector::SparseVector>("{}/a");
306-
assert(false);
307-
} catch (const pqxx::conversion_error& e) {
308-
assert(std::string_view(e.what()) == "Could not convert 'a' to int: Invalid argument.");
309-
}
257+
}, "Could not convert 'a' to int: Invalid argument.");
310258

311-
try {
259+
assert_exception<pqxx::conversion_overrun>([] {
312260
auto unused = pqxx::to_string(pgvector::SparseVector(std::vector<float>(16001, 1)));
313-
assert(false);
314-
} catch (const pqxx::conversion_overrun& e) {
315-
assert(std::string_view(e.what()) == "sparsevec cannot have more than 16000 dimensions");
316-
}
261+
}, "sparsevec cannot have more than 16000 dimensions");
317262
}
318263

319264
void test_pqxx() {

0 commit comments

Comments
 (0)