Skip to content

Commit 0a0bc40

Browse files
ankaneankane
committed
Improved assertions
1 parent a2fae30 commit 0a0bc40

File tree

5 files changed

+69
-56
lines changed

5 files changed

+69
-56
lines changed

‎test/halfvec_test.cpp‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,19 @@
1-
#include <cassert>
21
#include <span>
32

43
#include <pgvector/halfvec.hpp>
54

5+
#include "helper.hpp"
6+
67
using pgvector::HalfVector;
78

89
static void test_constructor_vector() {
910
auto vec = HalfVector({1, 2, 3});
10-
assert(vec.dimensions() == 3);
11+
assert_equal(vec.dimensions(), static_cast<size_t>(3));
1112
}
1213

1314
static void test_constructor_span() {
1415
auto vec = HalfVector(std::span<const float>({1, 2, 3}));
15-
assert(vec.dimensions() == 3);
16+
assert_equal(vec.dimensions(), static_cast<size_t>(3));
1617
}
1718

1819
void test_halfvec() {

‎test/helper.hpp‎

Lines changed: 18 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,25 @@
11
#pragma once
22

3-
#include <cassert>
43
#include <functional>
54
#include <optional>
5+
#include <source_location>
6+
#include <sstream>
67
#include <string_view>
78

9+
template<typename T>
10+
void assert_equal(const T& left, const T& right, const std::source_location& loc = std::source_location::current()) {
11+
if (left != right) {
12+
std::ostringstream message;
13+
message << left << " != " << right;
14+
message << " in " << loc.function_name() << " " << loc.file_name() << ":" << loc.line();
15+
throw std::runtime_error(message.str());
16+
}
17+
}
18+
19+
inline void assert_true(bool condition, const std::source_location& loc = std::source_location::current()) {
20+
assert_equal(condition, true, loc);
21+
}
22+
823
template<typename T>
924
void assert_exception(std::function<void(void)> code, std::optional<std::string_view> message = std::nullopt) {
1025
bool exception = false;
@@ -13,8 +28,8 @@ void assert_exception(std::function<void(void)> code, std::optional<std::string_
1328
} catch (const T& e) {
1429
exception = true;
1530
if (message) {
16-
assert(std::string_view(e.what()) == *message);
31+
assert_equal(std::string_view(e.what()), *message);
1732
}
1833
}
19-
assert(exception);
34+
assert_true(exception);
2035
}

‎test/pqxx_test.cpp‎

Lines changed: 36 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
#include <cassert>
21
#include <optional>
32
#include <string>
43
#include <string_view>
@@ -34,48 +33,46 @@ void test_vector(pqxx::connection &conn) {
3433

3534
pqxx::nontransaction tx(conn);
3635
auto embedding = pgvector::Vector({1, 2, 3});
37-
assert(embedding.dimensions() == 3);
3836
float arr[] = {4, 5, 6};
3937
auto embedding2 = pgvector::Vector(std::span{arr, 3});
4038
tx.exec("INSERT INTO items (embedding) VALUES ($1), ($2), ($3)", {embedding, embedding2, std::nullopt});
4139

4240
pqxx::result res = tx.exec("SELECT embedding FROM items ORDER BY embedding <-> $1", {embedding2});
43-
assert(res.size() == 3);
44-
assert(res[0][0].as<pgvector::Vector>() == embedding2);
45-
assert(res[1][0].as<pgvector::Vector>() == embedding);
46-
assert(!res[2][0].as<std::optional<pgvector::Vector>>().has_value());
41+
assert_equal(res.size(), 3);
42+
assert_equal(res[0][0].as<pgvector::Vector>(), embedding2);
43+
assert_equal(res[1][0].as<pgvector::Vector>(), embedding);
44+
assert_true(!res[2][0].as<std::optional<pgvector::Vector>>().has_value());
4745
}
4846

4947
void test_halfvec(pqxx::connection &conn) {
5048
before_each(conn);
5149

5250
pqxx::nontransaction tx(conn);
5351
auto embedding = pgvector::HalfVector({1, 2, 3});
54-
assert(embedding.dimensions() == 3);
5552
float arr[] = {4, 5, 6};
5653
auto embedding2 = pgvector::HalfVector(std::span{arr, 3});
5754
tx.exec("INSERT INTO items (half_embedding) VALUES ($1), ($2), ($3)", {embedding, embedding2, std::nullopt});
5855

5956
pqxx::result res = tx.exec("SELECT half_embedding FROM items ORDER BY half_embedding <-> $1", {embedding2});
60-
assert(res.size() == 3);
61-
assert(res[0][0].as<pgvector::HalfVector>() == embedding2);
62-
assert(res[1][0].as<pgvector::HalfVector>() == embedding);
63-
assert(!res[2][0].as<std::optional<pgvector::HalfVector>>().has_value());
57+
assert_equal(res.size(), 3);
58+
assert_equal(res[0][0].as<pgvector::HalfVector>(), embedding2);
59+
assert_equal(res[1][0].as<pgvector::HalfVector>(), embedding);
60+
assert_true(!res[2][0].as<std::optional<pgvector::HalfVector>>().has_value());
6461
}
6562

6663
void test_bit(pqxx::connection &conn) {
6764
before_each(conn);
6865

6966
pqxx::nontransaction tx(conn);
70-
auto embedding = "101";
71-
auto embedding2 = "111";
67+
std::string embedding = "101";
68+
std::string embedding2 = "111";
7269
tx.exec("INSERT INTO items (binary_embedding) VALUES ($1), ($2), ($3)", {embedding, embedding2, std::nullopt});
7370

7471
pqxx::result res = tx.exec("SELECT binary_embedding FROM items ORDER BY binary_embedding <~> $1", pqxx::params{embedding2});
75-
assert(res.size() == 3);
76-
assert(res[0][0].as<std::string>() == embedding2);
77-
assert(res[1][0].as<std::string>() == embedding);
78-
assert(!res[2][0].as<std::optional<std::string>>().has_value());
72+
assert_equal(res.size(), 3);
73+
assert_equal(res[0][0].as<std::string>(), embedding2);
74+
assert_equal(res[1][0].as<std::string>(), embedding);
75+
assert_true(!res[2][0].as<std::optional<std::string>>().has_value());
7976
}
8077

8178
void test_sparsevec(pqxx::connection &conn) {
@@ -87,10 +84,10 @@ void test_sparsevec(pqxx::connection &conn) {
8784
tx.exec("INSERT INTO items (sparse_embedding) VALUES ($1), ($2), ($3)", {embedding, embedding2, std::nullopt});
8885

8986
pqxx::result res = tx.exec("SELECT sparse_embedding FROM items ORDER BY sparse_embedding <-> $1", {embedding2});
90-
assert(res.size() == 3);
91-
assert(res[0][0].as<pgvector::SparseVector>() == embedding2);
92-
assert(res[1][0].as<pgvector::SparseVector>() == embedding);
93-
assert(!res[2][0].as<std::optional<pgvector::SparseVector>>().has_value());
87+
assert_equal(res.size(), 3);
88+
assert_equal(res[0][0].as<pgvector::SparseVector>(), embedding2);
89+
assert_equal(res[1][0].as<pgvector::SparseVector>(), embedding);
90+
assert_true(!res[2][0].as<std::optional<pgvector::SparseVector>>().has_value());
9491
}
9592

9693
void test_sparsevec_nnz(pqxx::connection &conn) {
@@ -111,11 +108,11 @@ void test_stream(pqxx::connection &conn) {
111108
auto embedding = pgvector::Vector({1, 2, 3});
112109
tx.exec("INSERT INTO items (embedding) VALUES ($1)", {embedding});
113110
int count = 0;
114-
for (auto [id, embedding] : tx.stream<int, pgvector::Vector>("SELECT id, embedding FROM items WHERE embedding IS NOT NULL")) {
115-
assert(embedding.dimensions() == 3);
111+
for (auto [id, embedding2] : tx.stream<int, pgvector::Vector>("SELECT id, embedding FROM items WHERE embedding IS NOT NULL")) {
112+
assert_equal(embedding2, embedding);
116113
count++;
117114
}
118-
assert(count == 1);
115+
assert_equal(count, 1);
119116
}
120117

121118
void test_stream_to(pqxx::connection &conn) {
@@ -127,8 +124,8 @@ void test_stream_to(pqxx::connection &conn) {
127124
stream.write_values(pgvector::Vector({4, 5, 6}));
128125
stream.complete();
129126
pqxx::result res = tx.exec("SELECT embedding FROM items ORDER BY id");
130-
assert(res[0][0].as<std::string>() == "[1,2,3]");
131-
assert(res[1][0].as<std::string>() == "[4,5,6]");
127+
assert_true(res[0][0].as<std::string>() == "[1,2,3]");
128+
assert_true(res[1][0].as<std::string>() == "[4,5,6]");
132129
}
133130

134131
void test_precision(pqxx::connection &conn) {
@@ -139,21 +136,21 @@ void test_precision(pqxx::connection &conn) {
139136
tx.exec("INSERT INTO items (embedding) VALUES ($1)", {embedding});
140137
tx.exec("SET extra_float_digits = 3");
141138
pqxx::result res = tx.exec("SELECT embedding FROM items ORDER BY id DESC LIMIT 1");
142-
assert(res[0][0].as<pgvector::Vector>() == embedding);
139+
assert_equal(res[0][0].as<pgvector::Vector>(), embedding);
143140
}
144141

145142
void test_vector_to_string() {
146-
assert(pqxx::to_string(pgvector::Vector({1, 2, 3})) == "[1,2,3]");
147-
assert(pqxx::to_string(pgvector::Vector({-1.234567890123})) == "[-1.2345679]");
143+
assert_true(pqxx::to_string(pgvector::Vector({1, 2, 3})) == "[1,2,3]");
144+
assert_true(pqxx::to_string(pgvector::Vector({-1.234567890123})) == "[-1.2345679]");
148145

149146
assert_exception<pqxx::conversion_overrun>([] {
150147
auto unused = pqxx::to_string(pgvector::Vector(std::vector<float>(16001)));
151148
}, "vector cannot have more than 16000 dimensions");
152149
}
153150

154151
void test_vector_from_string() {
155-
assert(pqxx::from_string<pgvector::Vector>("[1,2,3]") == pgvector::Vector({1, 2, 3}));
156-
assert(pqxx::from_string<pgvector::Vector>("[]") == pgvector::Vector(std::vector<float>{}));
152+
assert_equal(pqxx::from_string<pgvector::Vector>("[1,2,3]"), pgvector::Vector({1, 2, 3}));
153+
assert_equal(pqxx::from_string<pgvector::Vector>("[]"), pgvector::Vector(std::vector<float>{}));
157154

158155
assert_exception<pqxx::conversion_error>([] {
159156
auto unused = pqxx::from_string<pgvector::Vector>("");
@@ -181,17 +178,17 @@ void test_vector_from_string() {
181178
}
182179

183180
void test_halfvec_to_string() {
184-
assert(pqxx::to_string(pgvector::HalfVector({1, 2, 3})) == "[1,2,3]");
185-
assert(pqxx::to_string(pgvector::HalfVector({-1.234567890123})) == "[-1.2345679]");
181+
assert_true(pqxx::to_string(pgvector::HalfVector({1, 2, 3})) == "[1,2,3]");
182+
assert_true(pqxx::to_string(pgvector::HalfVector({-1.234567890123})) == "[-1.2345679]");
186183

187184
assert_exception<pqxx::conversion_overrun>([] {
188185
auto unused = pqxx::to_string(pgvector::HalfVector(std::vector<float>(16001)));
189186
}, "halfvec cannot have more than 16000 dimensions");
190187
}
191188

192189
void test_halfvec_from_string() {
193-
assert(pqxx::from_string<pgvector::HalfVector>("[1,2,3]") == pgvector::HalfVector({1, 2, 3}));
194-
assert(pqxx::from_string<pgvector::HalfVector>("[]") == pgvector::HalfVector(std::vector<float>{}));
190+
assert_equal(pqxx::from_string<pgvector::HalfVector>("[1,2,3]"), pgvector::HalfVector({1, 2, 3}));
191+
assert_equal(pqxx::from_string<pgvector::HalfVector>("[]"), pgvector::HalfVector(std::vector<float>{}));
195192

196193
assert_exception<pqxx::conversion_error>([] {
197194
auto unused = pqxx::from_string<pgvector::HalfVector>("");
@@ -219,14 +216,14 @@ void test_halfvec_from_string() {
219216
}
220217

221218
void test_sparsevec_to_string() {
222-
assert(pqxx::to_string(pgvector::SparseVector({1, 0, 2, 0, 3, 0})) == "{1:1,3:2,5:3}/6");
219+
assert_true(pqxx::to_string(pgvector::SparseVector({1, 0, 2, 0, 3, 0})) == "{1:1,3:2,5:3}/6");
223220
std::unordered_map<int, float> map = {{999999999, -1.234567890123}};
224-
assert(pqxx::to_string(pgvector::SparseVector(map, 1000000000)) == "{1000000000:-1.2345679}/1000000000");
221+
assert_true(pqxx::to_string(pgvector::SparseVector(map, 1000000000)) == "{1000000000:-1.2345679}/1000000000");
225222
}
226223

227224
void test_sparsevec_from_string() {
228-
assert(pqxx::from_string<pgvector::SparseVector>("{1:1,3:2,5:3}/6") == pgvector::SparseVector({1, 0, 2, 0, 3, 0}));
229-
assert(pqxx::from_string<pgvector::SparseVector>("{}/6") == pgvector::SparseVector({0, 0, 0, 0, 0, 0}));
225+
assert_equal(pqxx::from_string<pgvector::SparseVector>("{1:1,3:2,5:3}/6"), pgvector::SparseVector({1, 0, 2, 0, 3, 0}));
226+
assert_equal(pqxx::from_string<pgvector::SparseVector>("{}/6"), pgvector::SparseVector({0, 0, 0, 0, 0, 0}));
230227

231228
assert_exception<pqxx::conversion_error>([] {
232229
auto unused = pqxx::from_string<pgvector::SparseVector>("");

‎test/sparsevec_test.cpp‎

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
#include <cassert>
21
#include <span>
32
#include <unordered_map>
43

@@ -10,22 +9,22 @@ using pgvector::SparseVector;
109

1110
static void test_constructor_vector() {
1211
auto vec = SparseVector({1, 0, 2, 0, 3, 0});
13-
assert(vec.dimensions() == 6);
14-
assert(vec.indices() == (std::vector<int>{0, 2, 4}));
15-
assert(vec.values() == (std::vector<float>{1, 2, 3}));
12+
assert_equal(vec.dimensions(), 6);
13+
assert_true(vec.indices() == (std::vector<int>{0, 2, 4}));
14+
assert_true(vec.values() == (std::vector<float>{1, 2, 3}));
1615
}
1716

1817
static void test_constructor_span() {
1918
auto vec = SparseVector(std::span<const float>({1, 0, 2, 0, 3, 0}));
20-
assert(vec.dimensions() == 6);
19+
assert_equal(vec.dimensions(), 6);
2120
}
2221

2322
static void test_constructor_map() {
2423
std::unordered_map<int, float> map = {{2, 2}, {4, 3}, {3, 0}, {0, 1}};
2524
auto vec = SparseVector(map, 6);
26-
assert(vec.dimensions() == 6);
27-
assert(vec.indices() == (std::vector<int>{0, 2, 4}));
28-
assert(vec.values() == (std::vector<float>{1, 2, 3}));
25+
assert_equal(vec.dimensions(), 6);
26+
assert_true(vec.indices() == (std::vector<int>{0, 2, 4}));
27+
assert_true(vec.values() == (std::vector<float>{1, 2, 3}));
2928

3029
assert_exception<std::invalid_argument>([&]{
3130
auto unused = SparseVector(map, 0);

‎test/vector_test.cpp‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,19 @@
1-
#include <cassert>
21
#include <span>
32

43
#include <pgvector/vector.hpp>
54

5+
#include "helper.hpp"
6+
67
using pgvector::Vector;
78

89
static void test_constructor_vector() {
910
auto vec = Vector({1, 2, 3});
10-
assert(vec.dimensions() == 3);
11+
assert_equal(vec.dimensions(), static_cast<size_t>(3));
1112
}
1213

1314
static void test_constructor_span() {
1415
auto vec = Vector(std::span<const float>({1, 2, 3}));
15-
assert(vec.dimensions() == 3);
16+
assert_equal(vec.dimensions(), static_cast<size_t>(3));
1617
}
1718

1819
void test_vector() {

0 commit comments

Comments
 (0)