Merge pull request #5419 from harfbuzz/tiny-fix

Fix build with `-DNDEBUG`
This commit is contained in:
Behdad Esfahbod authored and GitHub committed 2025-07-25 03:51:23 -06:00
commit cb4cc445a2
31 files changed
+739 -728

No files matched your search

+33 -33
View File
@@ -38,7 +38,7 @@ static unsigned actual_class_def_size(It glyph_and_class) {
hb_serialize_context_t serializer(buffer, 100);
OT::ClassDef_serialize (&serializer, glyph_and_class);
serializer.end_serialize ();
assert(!serializer.in_error());
hb_always_assert(!serializer.in_error());
hb_blob_t* blob = serializer.copy_blob();
unsigned size = hb_blob_get_length(blob);
@@ -66,7 +66,7 @@ static unsigned actual_coverage_size(It glyphs) {
hb_serialize_context_t serializer(buffer, 100);
OT::Layout::Common::Coverage_serialize (&serializer, glyphs);
serializer.end_serialize ();
assert(!serializer.in_error());
hb_always_assert(!serializer.in_error());
hb_blob_t* blob = serializer.copy_blob();
unsigned size = hb_blob_get_length(blob);
@@ -101,9 +101,9 @@ static bool check_coverage_size(graph::class_def_size_estimator_t& estimator,
return true;
}
static bool check_add_class_def_size(graph::class_def_size_estimator_t& estimator,
const gid_and_class_list_t& map,
unsigned klass, hb_vector_t<unsigned> klasses)
static HB_UNUSED bool check_add_class_def_size(graph::class_def_size_estimator_t& estimator,
const gid_and_class_list_t& map,
unsigned klass, hb_vector_t<unsigned> klasses)
{
unsigned result = estimator.add_class_def_size(klass);
unsigned expected = actual_class_def_size(map, klasses);
@@ -115,7 +115,7 @@ static bool check_add_class_def_size(graph::class_def_size_estimator_t& estimato
return check_coverage_size(estimator, map, klasses);
}
static bool check_add_class_def_size (const gid_and_class_list_t& list, unsigned klass)
static HB_UNUSED bool check_add_class_def_size (const gid_and_class_list_t& list, unsigned klass)
{
graph::class_def_size_estimator_t estimator (list.iter ());
@@ -149,13 +149,13 @@ static void test_class_and_coverage_size_estimates ()
{
gid_and_class_list_t empty = {
};
assert (check_add_class_def_size (empty, 0));
assert (check_add_class_def_size (empty, 1));
hb_always_assert (check_add_class_def_size (empty, 0));
hb_always_assert (check_add_class_def_size (empty, 1));
gid_and_class_list_t class_zero = {
{5, 0},
};
assert (check_add_class_def_size (class_zero, 0));
hb_always_assert (check_add_class_def_size (class_zero, 0));
gid_and_class_list_t consecutive = {
{4, 0},
@@ -169,9 +169,9 @@ static void test_class_and_coverage_size_estimates ()
{10, 2},
{11, 2},
};
assert (check_add_class_def_size (consecutive, 0));
assert (check_add_class_def_size (consecutive, 1));
assert (check_add_class_def_size (consecutive, 2));
hb_always_assert (check_add_class_def_size (consecutive, 0));
hb_always_assert (check_add_class_def_size (consecutive, 1));
hb_always_assert (check_add_class_def_size (consecutive, 2));
gid_and_class_list_t non_consecutive = {
{4, 0},
@@ -185,9 +185,9 @@ static void test_class_and_coverage_size_estimates ()
{11, 2},
{13, 2},
};
assert (check_add_class_def_size (non_consecutive, 0));
assert (check_add_class_def_size (non_consecutive, 1));
assert (check_add_class_def_size (non_consecutive, 2));
hb_always_assert (check_add_class_def_size (non_consecutive, 0));
hb_always_assert (check_add_class_def_size (non_consecutive, 1));
hb_always_assert (check_add_class_def_size (non_consecutive, 2));
gid_and_class_list_t multiple_ranges = {
{4, 0},
@@ -202,8 +202,8 @@ static void test_class_and_coverage_size_estimates ()
{12, 1},
{13, 1},
};
assert (check_add_class_def_size (multiple_ranges, 0));
assert (check_add_class_def_size (multiple_ranges, 1));
hb_always_assert (check_add_class_def_size (multiple_ranges, 0));
hb_always_assert (check_add_class_def_size (multiple_ranges, 1));
}
static void test_running_class_and_coverage_size_estimates () {
@@ -229,14 +229,14 @@ static void test_running_class_and_coverage_size_estimates () {
};
graph::class_def_size_estimator_t estimator1(consecutive_map.iter());
assert(check_add_class_def_size(estimator1, consecutive_map, 1, {1}));
assert(check_add_class_def_size(estimator1, consecutive_map, 2, {1, 2}));
assert(check_add_class_def_size(estimator1, consecutive_map, 2, {1, 2})); // check that adding the same class again works
assert(check_add_class_def_size(estimator1, consecutive_map, 3, {1, 2, 3}));
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 1, {1}));
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 2, {1, 2}));
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 2, {1, 2})); // check that adding the same class again works
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 3, {1, 2, 3}));
estimator1.reset();
assert(check_add_class_def_size(estimator1, consecutive_map, 2, {2}));
assert(check_add_class_def_size(estimator1, consecutive_map, 3, {2, 3}));
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 2, {2}));
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 3, {2, 3}));
// #### With non-consecutive gids: always uses format 2 ###
gid_and_class_list_t non_consecutive_map = {
@@ -261,13 +261,13 @@ static void test_running_class_and_coverage_size_estimates () {
};
graph::class_def_size_estimator_t estimator2(non_consecutive_map.iter());
assert(check_add_class_def_size(estimator2, non_consecutive_map, 1, {1}));
assert(check_add_class_def_size(estimator2, non_consecutive_map, 2, {1, 2}));
assert(check_add_class_def_size(estimator2, non_consecutive_map, 3, {1, 2, 3}));
hb_always_assert(check_add_class_def_size(estimator2, non_consecutive_map, 1, {1}));
hb_always_assert(check_add_class_def_size(estimator2, non_consecutive_map, 2, {1, 2}));
hb_always_assert(check_add_class_def_size(estimator2, non_consecutive_map, 3, {1, 2, 3}));
estimator2.reset();
assert(check_add_class_def_size(estimator2, non_consecutive_map, 2, {2}));
assert(check_add_class_def_size(estimator2, non_consecutive_map, 3, {2, 3}));
hb_always_assert(check_add_class_def_size(estimator2, non_consecutive_map, 2, {2}));
hb_always_assert(check_add_class_def_size(estimator2, non_consecutive_map, 3, {2, 3}));
}
static void test_running_class_size_estimates_with_locally_consecutive_glyphs () {
@@ -278,13 +278,13 @@ static void test_running_class_size_estimates_with_locally_consecutive_glyphs ()
};
graph::class_def_size_estimator_t estimator(map.iter());
assert(check_add_class_def_size(estimator, map, 1, {1}));
assert(check_add_class_def_size(estimator, map, 2, {1, 2}));
assert(check_add_class_def_size(estimator, map, 3, {1, 2, 3}));
hb_always_assert(check_add_class_def_size(estimator, map, 1, {1}));
hb_always_assert(check_add_class_def_size(estimator, map, 2, {1, 2}));
hb_always_assert(check_add_class_def_size(estimator, map, 3, {1, 2, 3}));
estimator.reset();
assert(check_add_class_def_size(estimator, map, 2, {2}));
assert(check_add_class_def_size(estimator, map, 3, {2, 3}));
hb_always_assert(check_add_class_def_size(estimator, map, 2, {2}));
hb_always_assert(check_add_class_def_size(estimator, map, 3, {2, 3}));
}
int
+4 -4
View File
@@ -32,7 +32,7 @@
#include "hb.hh"
#line 33 "hb-buffer-deserialize-json.hh"
#line 36 "hb-buffer-deserialize-json.hh"
static const unsigned char _deserialize_json_trans_keys[] = {
0u, 0u, 9u, 34u, 97u, 121u, 120u, 121u, 34u, 34u, 9u, 58u, 9u, 57u, 48u, 57u,
9u, 125u, 9u, 125u, 9u, 93u, 9u, 125u, 34u, 34u, 9u, 58u, 9u, 57u, 48u, 57u,
@@ -597,12 +597,12 @@ _hb_buffer_deserialize_json (hb_buffer_t *buffer,
hb_glyph_info_t info = {0};
hb_glyph_position_t pos = {0};
#line 594 "hb-buffer-deserialize-json.hh"
#line 601 "hb-buffer-deserialize-json.hh"
{
cs = deserialize_json_start;
}
#line 597 "hb-buffer-deserialize-json.hh"
#line 606 "hb-buffer-deserialize-json.hh"
{
int _slen;
int _trans;
@@ -712,7 +712,7 @@ _resume:
#line 56 "hb-buffer-deserialize-json.rl"
{ if (unlikely (!buffer->ensure_unicode ())) return false; }
break;
#line 689 "hb-buffer-deserialize-json.hh"
#line 716 "hb-buffer-deserialize-json.hh"
}
_again:
+5 -5
View File
@@ -32,7 +32,7 @@
#include "hb.hh"
#line 33 "hb-buffer-deserialize-text-glyphs.hh"
#line 36 "hb-buffer-deserialize-text-glyphs.hh"
static const unsigned char _deserialize_text_glyphs_trans_keys[] = {
0u, 0u, 35u, 124u, 48u, 57u, 60u, 124u, 45u, 57u, 48u, 57u, 44u, 44u, 45u, 57u,
48u, 57u, 44u, 44u, 45u, 57u, 48u, 57u, 44u, 44u, 45u, 57u, 48u, 57u, 62u, 62u,
@@ -389,12 +389,12 @@ _hb_buffer_deserialize_text_glyphs (hb_buffer_t *buffer,
hb_glyph_info_t info = {0};
hb_glyph_position_t pos = {0};
#line 386 "hb-buffer-deserialize-text-glyphs.hh"
#line 393 "hb-buffer-deserialize-text-glyphs.hh"
{
cs = deserialize_text_glyphs_start;
}
#line 389 "hb-buffer-deserialize-text-glyphs.hh"
#line 398 "hb-buffer-deserialize-text-glyphs.hh"
{
int _slen;
int _trans;
@@ -552,7 +552,7 @@ _resume:
return false;
}
break;
#line 523 "hb-buffer-deserialize-text-glyphs.hh"
#line 556 "hb-buffer-deserialize-text-glyphs.hh"
}
_again:
@@ -573,7 +573,7 @@ _again:
*end_ptr = p;
}
break;
#line 542 "hb-buffer-deserialize-text-glyphs.hh"
#line 577 "hb-buffer-deserialize-text-glyphs.hh"
}
}
+2 -1
View File
@@ -199,6 +199,7 @@ hb_shape (hb_font_t *font,
#ifdef HB_EXPERIMENTAL_API
#ifndef HB_NO_VAR
static float
buffer_advance (hb_buffer_t *buffer)
@@ -440,7 +441,7 @@ hb_shape_justify (hb_font_t *font,
return true;
}
#endif
#endif
+3 -1
View File
@@ -40,6 +40,7 @@ bool _hb_subset_table_cff (hb_subset_plan_t *plan, hb_vector_t<char> &buf, hb_t
#ifdef HB_EXPERIMENTAL_API
#ifndef HB_NO_CFF
template<typename accel_t>
static hb_blob_t* get_charstrings_data(accel_t& accel, hb_codepoint_t glyph_index) {
@@ -111,7 +112,7 @@ HB_EXTERN hb_blob_t*
hb_subset_cff_get_charstrings_index (hb_face_t* face) {
return get_charstrings_index (*face->table.cff1);
}
/**
* hb_subset_cff2_get_charstring_data:
* @face: A face object
@@ -139,3 +140,4 @@ hb_subset_cff2_get_charstrings_index (hb_face_t* face) {
return get_charstrings_index (*face->table.cff2);
}
#endif
#endif
+1 -1
View File
@@ -110,7 +110,7 @@ _hb_subset_estimate_table_size (hb_subset_plan_t *plan,
/*
* Repack the serialization buffer if any offset overflows exist.
*/
static hb_blob_t*
static HB_UNUSED hb_blob_t*
_hb_subset_repack (hb_tag_t tag, const hb_serialize_context_t& c)
{
if (!c.offset_overflow ())
+9
View File
@@ -559,4 +559,13 @@ extern "C" void hb_free_impl(void *ptr);
#include "hb-vector.hh" // Requires: hb-array hb-null
#include "hb-object.hh" // Requires: hb-atomic hb-mutex hb-vector
/* Our src/test-*.cc use hb_assert(), such that it's not compiled out under NDEBUG.
* https://github.com/harfbuzz/harfbuzz/issues/5418 */
#define hb_always_assert(x) \
HB_STMT_START { \
if (!(x)) { fprintf(stderr, "Assertion failed: %s, at %s:%d\n", #x, __FILE__, __LINE__); abort(); } \
} HB_STMT_END
#endif /* HB_HH */
-1
View File
@@ -767,7 +767,6 @@ if get_option('tests').enabled()
foreach name, source : noinst_programs
executable(name, source,
include_directories: incconfig,
cpp_args: cpp_args + ['-UNDEBUG'],
dependencies: libharfbuzz_dep,
install: false,
)
+23 -23
View File
@@ -47,24 +47,24 @@ main (int argc, char **argv)
auto p = hb_pair (1, i);
p.second = 2;
assert (i == 2);
hb_always_assert (i == 2);
const int c = 3;
auto pc = hb_pair (1, c);
assert (pc.second == 3);
hb_always_assert (pc.second == 3);
auto q = p;
assert (&q != &p);
hb_always_assert (&q != &p);
q.second = 4;
assert (i == 4);
hb_always_assert (i == 4);
hb_invoke (test_func, 0, nullptr);
A a;
hb_invoke (&A::a, a);
assert (1 == hb_min (8, 1));
assert (8 == hb_max (8, 1));
hb_always_assert (1 == hb_min (8, 1));
hb_always_assert (8 == hb_max (8, 1));
int x = 1, y = 2;
hb_min (x, 3);
@@ -72,39 +72,39 @@ main (int argc, char **argv)
hb_min (x, 4 + 3);
int &z = hb_min (x, y);
z = 3;
assert (x == 3);
hb_always_assert (x == 3);
hb_pair_t<const int*, int> xp = hb_pair_t<int *, long> (nullptr, 0);
xp = hb_pair_t<int *, double> (nullptr, 1);
xp = hb_pair_t<const int*, int> (nullptr, 1);
assert (3 == hb_partial (hb_min, 3) (4));
assert (3 == hb_partial<1> (hb_min, 4) (3));
hb_always_assert (3 == hb_partial (hb_min, 3) (4));
hb_always_assert (3 == hb_partial<1> (hb_min, 4) (3));
auto M0 = hb_partial<2> (hb_max, 0);
assert (M0 (-2) == 0);
assert (M0 (+2) == 2);
hb_always_assert (M0 (-2) == 0);
hb_always_assert (M0 (+2) == 2);
assert (hb_add (2) (5) == 7);
assert (hb_add (5) (2) == 7);
hb_always_assert (hb_add (2) (5) == 7);
hb_always_assert (hb_add (5) (2) == 7);
x = 1;
assert (++hb_inc (x) == 3);
assert (x == 3);
hb_always_assert (++hb_inc (x) == 3);
hb_always_assert (x == 3);
hb_set_t set1 {1};
hb_set_t set2 {2};
assert (hb_hash (set1) != hb_hash (set2));
assert (hb_hash (set1) == hb_hash (hb_set_t {1}));
assert (hb_hash (set1) != hb_hash (hb_set_t {}));
assert (hb_hash (set1) != hb_hash (hb_set_t {2}));
assert (hb_hash (set2) == hb_hash (hb_set_t {2}));
hb_always_assert (hb_hash (set1) != hb_hash (set2));
hb_always_assert (hb_hash (set1) == hb_hash (hb_set_t {1}));
hb_always_assert (hb_hash (set1) != hb_hash (hb_set_t {}));
hb_always_assert (hb_hash (set1) != hb_hash (hb_set_t {2}));
hb_always_assert (hb_hash (set2) == hb_hash (hb_set_t {2}));
/* hb_hash, unlike std::hash, dereferences pointers. */
assert (hb_hash (set1) == hb_hash (&set1));
assert (hb_hash (set1) == hb_hash (hb::shared_ptr<hb_set_t> {hb_set_reference (&set1)}));
assert (hb_hash (set1) == hb_hash (hb::unique_ptr<hb_set_t> {hb_set_reference (&set1)}));
hb_always_assert (hb_hash (set1) == hb_hash (&set1));
hb_always_assert (hb_hash (set1) == hb_hash (hb::shared_ptr<hb_set_t> {hb_set_reference (&set1)}));
hb_always_assert (hb_hash (set1) == hb_hash (hb::unique_ptr<hb_set_t> {hb_set_reference (&set1)}));
return 0;
}
+4 -4
View File
@@ -36,7 +36,7 @@ test_reverse ()
int expected_values[] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
hb_array_t<int> expected (expected_values, 9);
assert (a == expected);
hb_always_assert (a == expected);
}
static void
@@ -48,7 +48,7 @@ test_reverse_range ()
int expected_values[] = {1, 2, 6, 5, 4, 3, 7, 8, 9};
hb_array_t<int> expected (expected_values, 9);
assert (a == expected);
hb_always_assert (a == expected);
}
static void
@@ -64,14 +64,14 @@ test_reverse_invalid ()
int expected_values[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
hb_array_t<int> expected (expected_values, 9);
assert (a == expected);
hb_always_assert (a == expected);
}
int
main (int argc, char **argv)
{
/* The following fails on MSVC. */
// assert (sizeof (hb_array_t<int>) == sizeof (hb_sorted_array_t<int>));
// hb_always_assert (sizeof (hb_array_t<int>) == sizeof (hb_sorted_array_t<int>));
test_reverse ();
test_reverse_range ();
+27 -27
View File
@@ -32,45 +32,45 @@ main (int argc, char **argv)
{
hb_bimap_t bm;
assert (bm.is_empty () == true);
hb_always_assert (bm.is_empty () == true);
bm.set (1, 4);
bm.set (2, 5);
bm.set (3, 6);
assert (bm.get_population () == 3);
assert (bm.has (1) == true);
assert (bm.has (4) == false);
assert (bm[2] == 5);
assert (bm.backward (6) == 3);
hb_always_assert (bm.get_population () == 3);
hb_always_assert (bm.has (1) == true);
hb_always_assert (bm.has (4) == false);
hb_always_assert (bm[2] == 5);
hb_always_assert (bm.backward (6) == 3);
bm.del (1);
assert (bm.has (1) == false);
assert (bm.has (3) == true);
hb_always_assert (bm.has (1) == false);
hb_always_assert (bm.has (3) == true);
bm.clear ();
assert (bm.get_population () == 0);
hb_always_assert (bm.get_population () == 0);
hb_inc_bimap_t ibm;
assert (ibm.add (13) == 0);
assert (ibm.add (8) == 1);
assert (ibm.add (10) == 2);
assert (ibm.add (8) == 1);
assert (ibm.add (7) == 3);
assert (ibm.get_population () == 4);
assert (ibm[7] == 3);
hb_always_assert (ibm.add (13) == 0);
hb_always_assert (ibm.add (8) == 1);
hb_always_assert (ibm.add (10) == 2);
hb_always_assert (ibm.add (8) == 1);
hb_always_assert (ibm.add (7) == 3);
hb_always_assert (ibm.get_population () == 4);
hb_always_assert (ibm[7] == 3);
ibm.sort ();
assert (ibm.get_population () == 4);
assert (ibm[7] == 0);
assert (ibm[13] == 3);
hb_always_assert (ibm.get_population () == 4);
hb_always_assert (ibm[7] == 0);
hb_always_assert (ibm[13] == 3);
ibm.identity (3);
assert (ibm.get_population () == 3);
assert (ibm[0] == 0);
assert (ibm[1] == 1);
assert (ibm[2] == 2);
assert (ibm.backward (0) == 0);
assert (ibm.backward (1) == 1);
assert (ibm.backward (2) == 2);
assert (ibm.has (4) == false);
hb_always_assert (ibm.get_population () == 3);
hb_always_assert (ibm[0] == 0);
hb_always_assert (ibm[1] == 1);
hb_always_assert (ibm[2] == 2);
hb_always_assert (ibm.backward (0) == 0);
hb_always_assert (ibm.backward (1) == 1);
hb_always_assert (ibm.backward (2) == 2);
hb_always_assert (ibm.has (4) == false);
return 0;
}
+1 -1
View File
@@ -64,7 +64,7 @@ main (int argc, char **argv)
argv[1] = (char *) "/dev/null";
hb_blob_t *blob = hb_blob_create_from_file_or_fail (argv[1]);
assert (blob);
hb_always_assert (blob);
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
hb_blob_destroy (blob);
blob = nullptr;
+2 -2
View File
@@ -64,9 +64,9 @@ main (int argc, char **argv)
struct num_tp_test num_tp_test = num_tp_tests[t];
number.set_real (num_tp_test.input);
encoder.encode_num_tp (number);
assert (buff.length == num_tp_test.length);
hb_always_assert (buff.length == num_tp_test.length);
for (unsigned i = 0; i < buff.length; i++)
assert (buff[i] == num_tp_test.output[i]);
hb_always_assert (buff[i] == num_tp_test.output[i]);
encoder.reset ();
}
}
+3 -3
View File
@@ -38,7 +38,7 @@ tree_recurse_binary (unsigned value,
hb_decycler_node_t node (decycler);
bool ret = node.visit (value);
assert (ret);
hb_always_assert (ret);
tree_recurse_binary (value * 2 + 1, max_value, decycler);
tree_recurse_binary (value * 2 + 2, max_value, decycler);
@@ -63,7 +63,7 @@ tree_recurse_tertiary (unsigned value,
for (unsigned i = 1; i <= 3; i++)
{
bool ret = node.visit (value + i);
assert (ret);
hb_always_assert (ret);
tree_recurse_tertiary (value + i, max_value, decycler);
}
@@ -82,7 +82,7 @@ cycle_recurse (signed value,
signed cycle_length,
hb_decycler_t &decycler)
{
assert (cycle_length > 0);
hb_always_assert (cycle_length > 0);
hb_decycler_node_t node (decycler);
+1 -1
View File
@@ -43,7 +43,7 @@ main (int argc, char **argv)
/* Create the face */
hb_blob_t *blob = hb_blob_create_from_file_or_fail (argv[1]);
assert (blob);
hb_always_assert (blob);
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
hb_blob_destroy (blob);
blob = nullptr;
+1 -1
View File
@@ -47,7 +47,7 @@ main (int argc, char **argv)
/* Create the face */
hb_blob_t *blob = hb_blob_create_from_file_or_fail (argv[1]);
assert (blob);
hb_always_assert (blob);
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
hb_blob_destroy (blob);
blob = nullptr;
+4 -4
View File
@@ -43,7 +43,7 @@ test_item_variations ()
const OT::ItemVariationStore& src_var_store = hvar_table+(hvar_table->varStore);
bool result = item_vars.create_from_item_varstore (src_var_store, axis_idx_tag_map);
assert (result);
hb_always_assert (result);
/* partial instancing wght=300:800 */
hb_hashmap_t<hb_tag_t, Triple> normalized_axes_location;
@@ -53,10 +53,10 @@ test_item_variations ()
axes_triple_distances.set (axis_tag, TripleDistances (200.0, 500.0));
result = item_vars.instantiate_tuple_vars (normalized_axes_location, axes_triple_distances);
assert (result);
hb_always_assert (result);
result = item_vars.as_item_varstore (false);
assert (result);
assert (item_vars.get_region_list().length == 8);
hb_always_assert (result);
hb_always_assert (item_vars.get_region_list().length == 8);
}
int
+48 -48
View File
@@ -84,7 +84,7 @@ test_iterator_non_default_constructable (Iter it)
it = it + 10;
it = 10 + it;
assert (*it == it[0]);
hb_always_assert (*it == it[0]);
static_assert (true || it.is_random_access_iterator, "");
static_assert (true || it.is_sorted_iterator, "");
@@ -96,7 +96,7 @@ static void
test_iterator (Iter it)
{
Iter default_constructed;
assert (!default_constructed);
hb_always_assert (!default_constructed);
test_iterator_non_default_constructable (it);
}
@@ -118,7 +118,7 @@ static void check_sequential (It it)
{
int i = 1;
for (int v : +it) {
assert (v == i++);
hb_always_assert (v == i++);
}
}
@@ -131,16 +131,16 @@ static void test_concat ()
hb_vector_t<int> d = {1, 2, 3, 4, 5};
auto it1 = hb_concat (a, b);
assert (it1.len () == 5);
assert (it1.is_random_access_iterator);
hb_always_assert (it1.len () == 5);
hb_always_assert (it1.is_random_access_iterator);
auto it2 = hb_concat (c, d);
assert (it2.len () == 5);
hb_always_assert (it2.len () == 5);
auto it3 = hb_concat (d, c);
assert (it3.len () == 5);
hb_always_assert (it3.len () == 5);
for (int i = 0; i < 5; i++) {
assert(it1[i] == i + 1);
assert(it2[i] == i + 1);
assert(it3[i] == i + 1);
hb_always_assert(it1[i] == i + 1);
hb_always_assert(it2[i] == i + 1);
hb_always_assert(it3[i] == i + 1);
}
check_sequential (it1);
@@ -149,40 +149,40 @@ static void test_concat ()
auto it4 = +it1;
it4 += 0;
assert (*it4 == 1);
hb_always_assert (*it4 == 1);
it4 += 2;
assert (*it4 == 3);
assert (it4);
assert (it4.len () == 3);
hb_always_assert (*it4 == 3);
hb_always_assert (it4);
hb_always_assert (it4.len () == 3);
it4 += 2;
assert (*it4 == 5);
assert (it4);
assert (it4.len () == 1);
hb_always_assert (*it4 == 5);
hb_always_assert (it4);
hb_always_assert (it4.len () == 1);
it4++;
assert (!it4);
assert (it4.len () == 0);
hb_always_assert (!it4);
hb_always_assert (it4.len () == 0);
auto it5 = +it1;
it5 += 3;
assert (*it5 == 4);
hb_always_assert (*it5 == 4);
hb_set_t s_a = {1, 2, 3};
hb_set_t s_b = {4, 5};
auto it6 = hb_concat (s_a, s_b);
assert (!it6.is_random_access_iterator);
hb_always_assert (!it6.is_random_access_iterator);
check_sequential (it6);
assert (it6.len () == 5);
hb_always_assert (it6.len () == 5);
it6 += 0;
assert (*it6 == 1);
hb_always_assert (*it6 == 1);
it6 += 3;
assert (*it6 == 4);
assert (it6);
assert (it6.len () == 2);
hb_always_assert (*it6 == 4);
hb_always_assert (it6);
hb_always_assert (it6.len () == 2);
}
int
@@ -235,16 +235,16 @@ main (int argc, char **argv)
test_iterator_non_default_constructable (hb_iter (st) | hb_filter ());
test_iterator_non_default_constructable (hb_iter (st) | hb_map (hb_lidentity));
assert (true == hb_all (st));
assert (false == hb_all (st, 42u));
assert (true == hb_any (st));
assert (false == hb_any (st, 14u));
assert (true == hb_any (st, 14u, [] (unsigned _) { return _ - 1u; }));
assert (true == hb_any (st, [] (unsigned _) { return _ == 15u; }));
assert (true == hb_any (st, 15u));
assert (false == hb_none (st));
assert (false == hb_none (st, 15u));
assert (true == hb_none (st, 17u));
hb_always_assert (true == hb_all (st));
hb_always_assert (false == hb_all (st, 42u));
hb_always_assert (true == hb_any (st));
hb_always_assert (false == hb_any (st, 14u));
hb_always_assert (true == hb_any (st, 14u, [] (unsigned _) { return _ - 1u; }));
hb_always_assert (true == hb_any (st, [] (unsigned _) { return _ == 15u; }));
hb_always_assert (true == hb_any (st, 15u));
hb_always_assert (false == hb_none (st));
hb_always_assert (false == hb_none (st, 15u));
hb_always_assert (true == hb_none (st, 17u));
hb_array_t<hb_vector_t<int>> pa;
pa->as_array ();
@@ -318,7 +318,7 @@ main (int argc, char **argv)
}, hb_map_create ())
;
/* The result should be something like 0->10, 1->11, ..., 9->19 */
assert (hb_map_get (result, 9) == 19);
hb_always_assert (hb_map_get (result, 9) == 19);
hb_map_destroy (result);
/* Like above, but passing hb_set_t instead of hb_set_t * */
@@ -341,7 +341,7 @@ main (int argc, char **argv)
}, hb_map_create ())
;
/* The result should be something like 0->10, 1->11, ..., 9->19 */
assert (hb_map_get (result, 9) == 19);
hb_always_assert (hb_map_get (result, 9) == 19);
hb_map_destroy (result);
unsigned int temp3 = 0;
@@ -361,20 +361,20 @@ main (int argc, char **argv)
hb_iota ();
hb_iota (3);
hb_iota (3, 2);
assert ((&vl) + 1 == *++hb_iota (&vl, hb_inc));
hb_always_assert ((&vl) + 1 == *++hb_iota (&vl, hb_inc));
hb_range ();
hb_repeat (7u);
hb_repeat (nullptr);
hb_repeat (vl) | hb_chop (3);
assert (hb_len (hb_range (10) | hb_take (3)) == 3);
assert (hb_range (9).len () == 9);
assert (hb_range (2, 9).len () == 7);
assert (hb_range (2, 9, 3).len () == 3);
assert (hb_range (2, 8, 3).len () == 2);
assert (hb_range (2, 7, 3).len () == 2);
assert (hb_range (-2, -9, -3).len () == 3);
assert (hb_range (-2, -8, -3).len () == 2);
assert (hb_range (-2, -7, -3).len () == 2);
hb_always_assert (hb_len (hb_range (10) | hb_take (3)) == 3);
hb_always_assert (hb_range (9).len () == 9);
hb_always_assert (hb_range (2, 9).len () == 7);
hb_always_assert (hb_range (2, 9, 3).len () == 3);
hb_always_assert (hb_range (2, 8, 3).len () == 2);
hb_always_assert (hb_range (2, 7, 3).len () == 2);
hb_always_assert (hb_range (-2, -9, -3).len () == 3);
hb_always_assert (hb_range (-2, -8, -3).len () == 2);
hb_always_assert (hb_range (-2, -7, -3).len () == 2);
test_concat ();
+59 -59
View File
@@ -36,10 +36,10 @@ main (int argc, char **argv)
hb_map_t v1;
v1.set (1, 2);
hb_map_t v2 {v1};
assert (v1.get_population () == 1);
assert (v2.get_population () == 1);
assert (v1[1] == 2);
assert (v2[1] == 2);
hb_always_assert (v1.get_population () == 1);
hb_always_assert (v2.get_population () == 1);
hb_always_assert (v1[1] == 2);
hb_always_assert (v2[1] == 2);
}
/* Test copy assignment. */
@@ -47,10 +47,10 @@ main (int argc, char **argv)
hb_map_t v1;
v1.set (1, 2);
hb_map_t v2 = v1;
assert (v1.get_population () == 1);
assert (v2.get_population () == 1);
assert (v1[1] == 2);
assert (v2[1] == 2);
hb_always_assert (v1.get_population () == 1);
hb_always_assert (v2.get_population () == 1);
hb_always_assert (v1[1] == 2);
hb_always_assert (v2[1] == 2);
}
/* Test move constructor. */
@@ -58,8 +58,8 @@ main (int argc, char **argv)
hb_map_t s {};
s.set (1, 2);
hb_map_t v (std::move (s));
assert (s.get_population () == 0);
assert (v.get_population () == 1);
hb_always_assert (s.get_population () == 0);
hb_always_assert (v.get_population () == 1);
}
/* Test move assignment. */
@@ -68,8 +68,8 @@ main (int argc, char **argv)
s.set (1, 2);
hb_map_t v;
v = std::move (s);
assert (s.get_population () == 0);
assert (v.get_population () == 1);
hb_always_assert (s.get_population () == 0);
hb_always_assert (v.get_population () == 1);
}
/* Test initializing from iterable. */
@@ -84,10 +84,10 @@ main (int argc, char **argv)
hb_map_t v1 (s);
hb_map_t v2 (std::move (s));
assert (s.get_population () == 0);
assert (v0.get_population () == 2);
assert (v1.get_population () == 2);
assert (v2.get_population () == 2);
hb_always_assert (s.get_population () == 0);
hb_always_assert (v0.get_population () == 2);
hb_always_assert (v1.get_population () == 2);
hb_always_assert (v2.get_population () == 2);
}
/* Test call fini() twice. */
@@ -107,7 +107,7 @@ main (int argc, char **argv)
hb_map_t v (hb_iter (s));
assert (v.get_population () == 2);
hb_always_assert (v.get_population () == 2);
}
/* Test initializing from initializer list and swapping. */
@@ -116,8 +116,8 @@ main (int argc, char **argv)
hb_map_t v1 {pair_t{1,2}, pair_t{4,5}};
hb_map_t v2 {pair_t{3,4}};
hb_swap (v1, v2);
assert (v1.get_population () == 1);
assert (v2.get_population () == 2);
hb_always_assert (v1.get_population () == 1);
hb_always_assert (v2.get_population () == 2);
}
/* Test class key / value types. */
@@ -125,9 +125,9 @@ main (int argc, char **argv)
hb_hashmap_t<hb_bytes_t, int> m1;
hb_hashmap_t<int, hb_bytes_t> m2;
hb_hashmap_t<hb_bytes_t, hb_bytes_t> m3;
assert (m1.get_population () == 0);
assert (m2.get_population () == 0);
assert (m3.get_population () == 0);
hb_always_assert (m1.get_population () == 0);
hb_always_assert (m2.get_population () == 0);
hb_always_assert (m3.get_population () == 0);
}
{
@@ -157,8 +157,8 @@ main (int argc, char **argv)
m1.set (hb_map_t (), hb_map_t {pair (1u, 2u)});
m1.set (hb_map_t {pair (1u, 2u)}, hb_map_t {pair (2u, 3u)});
assert (m1.get (hb_map_t ()) == hb_map_t {pair (1u, 2u)});
assert (m1.get (hb_map_t {pair (1u, 2u)}) == hb_map_t {pair (2u, 3u)});
hb_always_assert (m1.get (hb_map_t ()) == hb_map_t {pair (1u, 2u)});
hb_always_assert (m1.get (hb_map_t {pair (1u, 2u)}) == hb_map_t {pair (2u, 3u)});
}
/* Test hashing sets. */
@@ -169,8 +169,8 @@ main (int argc, char **argv)
m1.set (hb_set_t (), hb_set_t {1});
m1.set (hb_set_t {1, 1000}, hb_set_t {2});
assert (m1.get (hb_set_t ()) == hb_set_t {1});
assert (m1.get (hb_set_t {1000, 1}) == hb_set_t {2});
hb_always_assert (m1.get (hb_set_t ()) == hb_set_t {1});
hb_always_assert (m1.get (hb_set_t {1000, 1}) == hb_set_t {2});
}
/* Test hashing vectors. */
@@ -184,8 +184,8 @@ main (int argc, char **argv)
m1 << hb_pair_t<vector_t, vector_t> {vector_t {2}, vector_t ()};
assert (m1.get (vector_t ()) == vector_t {1});
assert (m1.get (vector_t {1}) == vector_t {2});
hb_always_assert (m1.get (vector_t ()) == vector_t {1});
hb_always_assert (m1.get (vector_t {1}) == vector_t {2});
}
/* Test moving values */
@@ -194,20 +194,20 @@ main (int argc, char **argv)
hb_hashmap_t<vector_t, vector_t> m1;
vector_t v {3};
assert (v.length == 1);
hb_always_assert (v.length == 1);
m1 << hb_pair_t<vector_t, vector_t> {vector_t {3}, v};
assert (v.length == 1);
hb_always_assert (v.length == 1);
m1 << hb_pair_t<vector_t, vector_t&&> {vector_t {4}, std::move (v)};
assert (v.length == 0);
hb_always_assert (v.length == 0);
m1 << hb_pair_t<vector_t&&, vector_t> {vector_t {4}, vector_t {5}};
m1 << hb_pair_t<vector_t&&, vector_t&&> {vector_t {4}, vector_t {5}};
hb_hashmap_t<vector_t, vector_t> m2;
vector_t v2 {3};
m2.set (vector_t {4}, v2);
assert (v2.length == 1);
hb_always_assert (v2.length == 1);
m2.set (vector_t {5}, std::move (v2));
assert (v2.length == 0);
hb_always_assert (v2.length == 0);
}
/* Test hb::shared_ptr. */
@@ -250,10 +250,10 @@ main (int argc, char **argv)
hb::shared_ptr<hb_map_t> p2 {m2};
m.set (p1,1);
assert (m.has (p2));
hb_always_assert (m.has (p2));
m1->set (2,4);
assert (!m.has (p2));
hb_always_assert (!m.has (p2));
}
/* Test value type with hb_bytes_t. */
{
@@ -262,8 +262,8 @@ main (int argc, char **argv)
hb_bytes_t bytes (c_str);
m.set (1, bytes);
assert (m.has (1));
assert (m.get (1) == hb_bytes_t {"Test"});
hb_always_assert (m.has (1));
hb_always_assert (m.get (1) == hb_bytes_t {"Test"});
}
/* Test operators. */
{
@@ -275,16 +275,16 @@ main (int argc, char **argv)
m3.set (1, 3);
m3.set (3, 5);
assert (m1 == m2);
assert (m1 != m3);
assert (!(m2 == m3));
hb_always_assert (m1 == m2);
hb_always_assert (m1 != m3);
hb_always_assert (!(m2 == m3));
m2 = m3;
assert (m2.has (1));
assert (!m2.has (2));
assert (m2.has (3));
hb_always_assert (m2.has (1));
hb_always_assert (!m2.has (2));
hb_always_assert (m2.has (3));
assert (m3.has (3));
hb_always_assert (m3.has (3));
}
/* Test reset. */
{
@@ -309,15 +309,15 @@ main (int argc, char **argv)
m.next (&i, &k, &v);)
{
pop++;
if (k == 1) assert (v == 1);
else if (k == 2) assert (v == 1);
else if (k == 3) assert (v == 2);
else if (k == 4) assert (v == 3);
else if (k == 5) assert (v == 5);
else if (k == 6) assert (v == 8);
else assert (false);
if (k == 1) hb_always_assert (v == 1);
else if (k == 2) hb_always_assert (v == 1);
else if (k == 3) hb_always_assert (v == 2);
else if (k == 4) hb_always_assert (v == 3);
else if (k == 5) hb_always_assert (v == 5);
else if (k == 6) hb_always_assert (v == 8);
else hb_always_assert (false);
}
assert (pop == m.get_population ());
hb_always_assert (pop == m.get_population ());
}
/* Test update */
{
@@ -327,9 +327,9 @@ main (int argc, char **argv)
m2.set (1, 3);
m1.update (m2);
assert (m1.get_population () == 2);
assert (m1[1] == 3);
assert (m1[2] == 4);
hb_always_assert (m1.get_population () == 2);
hb_always_assert (m1[1] == 3);
hb_always_assert (m1[2] == 4);
}
/* Test keys / values */
{
@@ -347,11 +347,11 @@ main (int argc, char **argv)
hb_copy (m.keys (), keys);
hb_copy (m.values (), values);
assert (keys.is_equal (hb_set_t ({1, 2, 3, 4, 5, 6})));
assert (values.is_equal (hb_set_t ({1, 1, 2, 3, 5, 8})));
hb_always_assert (keys.is_equal (hb_set_t ({1, 2, 3, 4, 5, 6})));
hb_always_assert (values.is_equal (hb_set_t ({1, 1, 2, 3, 5, 8})));
assert (keys.is_equal (hb_set_t (m.keys ())));
assert (values.is_equal (hb_set_t (m.values ())));
hb_always_assert (keys.is_equal (hb_set_t (m.keys ())));
hb_always_assert (values.is_equal (hb_set_t (m.values ())));
}
return 0;
+16 -16
View File
@@ -30,30 +30,30 @@ main (int argc, char **argv)
{
hb_multimap_t m;
assert (m.get (10).length == 0);
hb_always_assert (m.get (10).length == 0);
m.add (10, 11);
assert (m.get (10).length == 1);
hb_always_assert (m.get (10).length == 1);
m.add (10, 12);
assert (m.get (10).length == 2);
hb_always_assert (m.get (10).length == 2);
m.add (10, 13);
assert (m.get (10).length == 3);
assert (m.get (10)[0] == 11);
assert (m.get (10)[1] == 12);
assert (m.get (10)[2] == 13);
hb_always_assert (m.get (10).length == 3);
hb_always_assert (m.get (10)[0] == 11);
hb_always_assert (m.get (10)[1] == 12);
hb_always_assert (m.get (10)[2] == 13);
assert (m.get (11).length == 0);
hb_always_assert (m.get (11).length == 0);
m.add (11, 14);
assert (m.get (10).length == 3);
assert (m.get (11).length == 1);
assert (m.get (12).length == 0);
assert (m.get (10)[0] == 11);
assert (m.get (10)[1] == 12);
assert (m.get (10)[2] == 13);
assert (m.get (11)[0] == 14);
assert (m.get (12)[0] == 0); // Array fallback value
hb_always_assert (m.get (10).length == 3);
hb_always_assert (m.get (11).length == 1);
hb_always_assert (m.get (12).length == 0);
hb_always_assert (m.get (10)[0] == 11);
hb_always_assert (m.get (10)[1] == 12);
hb_always_assert (m.get (10)[2] == 13);
hb_always_assert (m.get (11)[0] == 14);
hb_always_assert (m.get (12)[0] == 0); // Array fallback value
return 0;
}
+69 -69
View File
@@ -36,11 +36,11 @@ main (int argc, char **argv)
const char *end = str + 3;
int pv;
assert (hb_parse_int (&pp, end, &pv));
assert (pv == 123);
assert (pp - str == 3);
assert (end - pp == 0);
assert (!*end);
hb_always_assert (hb_parse_int (&pp, end, &pv));
hb_always_assert (pv == 123);
hb_always_assert (pp - str == 3);
hb_always_assert (end - pp == 0);
hb_always_assert (!*end);
}
{
@@ -49,11 +49,11 @@ main (int argc, char **argv)
const char *end = str + strlen (str);
unsigned int pv;
assert (hb_parse_uint (&pp, end, &pv));
assert (pv == 123);
assert (pp - str == 3);
assert (end - pp == 0);
assert (!*end);
hb_always_assert (hb_parse_uint (&pp, end, &pv));
hb_always_assert (pv == 123);
hb_always_assert (pp - str == 3);
hb_always_assert (end - pp == 0);
hb_always_assert (!*end);
}
{
@@ -62,11 +62,11 @@ main (int argc, char **argv)
const char *end = str + 3;
unsigned int pv;
assert (hb_parse_uint (&pp, end, &pv, true, 16));
assert (pv == 0x12F);
assert (pp - str == 3);
assert (end - pp == 0);
assert (!*end);
hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16));
hb_always_assert (pv == 0x12F);
hb_always_assert (pp - str == 3);
hb_always_assert (end - pp == 0);
hb_always_assert (!*end);
}
{
@@ -75,12 +75,12 @@ main (int argc, char **argv)
const char *end = str + 4;
unsigned int pv;
assert (!hb_parse_uint (&pp, end, &pv, true, 16));
assert (hb_parse_uint (&pp, end, &pv, false, 16));
assert (pv == 0x12F);
assert (pp - str == 3);
assert (end - pp == 1);
assert (!*end);
hb_always_assert (!hb_parse_uint (&pp, end, &pv, true, 16));
hb_always_assert (hb_parse_uint (&pp, end, &pv, false, 16));
hb_always_assert (pv == 0x12F);
hb_always_assert (pp - str == 3);
hb_always_assert (end - pp == 1);
hb_always_assert (!*end);
}
{
@@ -89,50 +89,50 @@ main (int argc, char **argv)
const char *end = str + 4;
int pv;
assert (hb_parse_int (&pp, end, &pv));
assert (pv == -123);
assert (pp - str == 4);
assert (end - pp == 0);
assert (!*end);
hb_always_assert (hb_parse_int (&pp, end, &pv));
hb_always_assert (pv == -123);
hb_always_assert (pp - str == 4);
hb_always_assert (end - pp == 0);
hb_always_assert (!*end);
}
{
const char str[] = "123";
const char *pp = str;
assert (ARRAY_LENGTH (str) == 4);
hb_always_assert (ARRAY_LENGTH (str) == 4);
const char *end = str + ARRAY_LENGTH (str);
unsigned int pv;
assert (hb_parse_uint (&pp, end, &pv));
assert (pv == 123);
assert (pp - str == 3);
assert (end - pp == 1);
hb_always_assert (hb_parse_uint (&pp, end, &pv));
hb_always_assert (pv == 123);
hb_always_assert (pp - str == 3);
hb_always_assert (end - pp == 1);
}
{
const char str[] = "123\0";
const char *pp = str;
assert (ARRAY_LENGTH (str) == 5);
hb_always_assert (ARRAY_LENGTH (str) == 5);
const char *end = str + ARRAY_LENGTH (str);
unsigned int pv;
assert (hb_parse_uint (&pp, end, &pv));
assert (pv == 123);
assert (pp - str == 3);
assert (end - pp == 2);
hb_always_assert (hb_parse_uint (&pp, end, &pv));
hb_always_assert (pv == 123);
hb_always_assert (pp - str == 3);
hb_always_assert (end - pp == 2);
}
{
const char str[] = "123V";
const char *pp = str;
assert (ARRAY_LENGTH (str) == 5);
hb_always_assert (ARRAY_LENGTH (str) == 5);
const char *end = str + ARRAY_LENGTH (str);
unsigned int pv;
assert (hb_parse_uint (&pp, end, &pv));
assert (pv == 123);
assert (pp - str == 3);
assert (end - pp == 2);
hb_always_assert (hb_parse_uint (&pp, end, &pv));
hb_always_assert (pv == 123);
hb_always_assert (pp - str == 3);
hb_always_assert (end - pp == 2);
}
{
@@ -141,10 +141,10 @@ main (int argc, char **argv)
const char *end = str + ARRAY_LENGTH (str);
double pv;
assert (hb_parse_double (&pp, end, &pv));
assert ((int) roundf (pv * 1000.) == 123);
assert (pp - str == 4);
assert (end - pp == 1);
hb_always_assert (hb_parse_double (&pp, end, &pv));
hb_always_assert ((int) roundf (pv * 1000.) == 123);
hb_always_assert (pp - str == 4);
hb_always_assert (end - pp == 1);
}
{
@@ -153,10 +153,10 @@ main (int argc, char **argv)
const char *end = str + ARRAY_LENGTH (str) - 1;
double pv;
assert (hb_parse_double (&pp, end, &pv));
assert ((int) roundf (pv * 1000.) == 123);
assert (pp - str == 5);
assert (end - pp == 0);
hb_always_assert (hb_parse_double (&pp, end, &pv));
hb_always_assert ((int) roundf (pv * 1000.) == 123);
hb_always_assert (pp - str == 5);
hb_always_assert (end - pp == 0);
}
{
@@ -165,10 +165,10 @@ main (int argc, char **argv)
const char *end = str + ARRAY_LENGTH (str) - 1;
double pv;
assert (hb_parse_double (&pp, end, &pv));
assert ((int) roundf (pv * 1000.) == 123);
assert (pp - str == 7);
assert (end - pp == 0);
hb_always_assert (hb_parse_double (&pp, end, &pv));
hb_always_assert ((int) roundf (pv * 1000.) == 123);
hb_always_assert (pp - str == 7);
hb_always_assert (end - pp == 0);
}
{
@@ -177,10 +177,10 @@ main (int argc, char **argv)
const char *end = str + ARRAY_LENGTH (str) - 1;
double pv;
assert (hb_parse_double (&pp, end, &pv));
assert ((int) roundf (pv * 1000.) == 123);
assert (pp - str == 6);
assert (end - pp == 0);
hb_always_assert (hb_parse_double (&pp, end, &pv));
hb_always_assert ((int) roundf (pv * 1000.) == 123);
hb_always_assert (pp - str == 6);
hb_always_assert (end - pp == 0);
}
{
@@ -189,10 +189,10 @@ main (int argc, char **argv)
const char *end = str + ARRAY_LENGTH (str) - 1;
double pv;
assert (hb_parse_double (&pp, end, &pv));
assert ((int) roundf (pv * 1000.) == 123);
assert (pp - str == 10);
assert (end - pp == 0);
hb_always_assert (hb_parse_double (&pp, end, &pv));
hb_always_assert ((int) roundf (pv * 1000.) == 123);
hb_always_assert (pp - str == 10);
hb_always_assert (end - pp == 0);
}
{
@@ -201,10 +201,10 @@ main (int argc, char **argv)
const char *end = str + ARRAY_LENGTH (str) - 1;
double pv;
assert (hb_parse_double (&pp, end, &pv));
assert ((int) roundf (pv * 1000.) == -123);
assert (pp - str == 13);
assert (end - pp == 0);
hb_always_assert (hb_parse_double (&pp, end, &pv));
hb_always_assert ((int) roundf (pv * 1000.) == -123);
hb_always_assert (pp - str == 13);
hb_always_assert (end - pp == 0);
}
@@ -214,10 +214,10 @@ main (int argc, char **argv)
const char *end = str + ARRAY_LENGTH (str) - 1;
double pv;
assert (hb_parse_double (&pp, end, &pv));
assert ((int) roundf (pv * 1000.) == -123);
assert (pp - str == 8);
assert (end - pp == 0);
hb_always_assert (hb_parse_double (&pp, end, &pv));
hb_always_assert ((int) roundf (pv * 1000.) == -123);
hb_always_assert (pp - str == 8);
hb_always_assert (end - pp == 0);
}
return 0;
+1 -1
View File
@@ -40,7 +40,7 @@ main (int argc, char **argv)
}
hb_blob_t *blob = hb_blob_create_from_file_or_fail (argv[1]);
assert (blob);
hb_always_assert (blob);
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
hb_font_t *font = hb_font_create (face);
hb_blob_destroy (blob);
+1 -1
View File
@@ -38,7 +38,7 @@ main (int argc, char **argv)
}
hb_blob_t *blob = hb_blob_create_from_file_or_fail (argv[1]);
assert (blob);
hb_always_assert (blob);
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
hb_blob_destroy (blob);
blob = nullptr;
+1 -1
View File
@@ -40,7 +40,7 @@ main (int argc, char **argv)
}
hb_blob_t *blob = hb_blob_create_from_file_or_fail (argv[1]);
assert (blob);
hb_always_assert (blob);
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
hb_blob_destroy (blob);
blob = nullptr;
+11 -11
View File
@@ -31,23 +31,23 @@ static void
test_insert ()
{
hb_priority_queue_t<int64_t> queue;
assert (queue.is_empty ());
hb_always_assert (queue.is_empty ());
queue.insert (10, 0);
assert (!queue.is_empty ());
assert (queue.minimum () == hb_pair (10, 0));
hb_always_assert (!queue.is_empty ());
hb_always_assert (queue.minimum () == hb_pair (10, 0));
queue.insert (20, 1);
assert (queue.minimum () == hb_pair (10, 0));
hb_always_assert (queue.minimum () == hb_pair (10, 0));
queue.insert (5, 2);
assert (queue.minimum () == hb_pair (5, 2));
hb_always_assert (queue.minimum () == hb_pair (5, 2));
queue.insert (15, 3);
assert (queue.minimum () == hb_pair (5, 2));
hb_always_assert (queue.minimum () == hb_pair (5, 2));
queue.insert (1, 4);
assert (queue.minimum () == hb_pair (1, 4));
hb_always_assert (queue.minimum () == hb_pair (1, 4));
}
static void
@@ -65,12 +65,12 @@ test_extract ()
for (int i = 0; i < 8; i++)
{
assert (!queue.is_empty ());
assert (queue.minimum () == hb_pair (i * 10, i));
assert (queue.pop_minimum () == hb_pair (i * 10, i));
hb_always_assert (!queue.is_empty ());
hb_always_assert (queue.minimum () == hb_pair (i * 10, i));
hb_always_assert (queue.pop_minimum () == hb_pair (i * 10, i));
}
assert (queue.is_empty ());
hb_always_assert (queue.is_empty ());
}
int
+117 -117
View File
@@ -488,24 +488,24 @@ static void run_resolve_overflow_test (const char* name,
{
if (check_binary_equivalence) {
printf("when binary equivalence checking is enabled, the expected graph cannot overflow.");
assert(!check_binary_equivalence);
hb_always_assert(!check_binary_equivalence);
}
expected_graph.assign_spaces ();
expected_graph.sort_shortest_distance ();
}
// Check that overflow resolution succeeds
assert (overflowing.offset_overflow ());
assert (hb_resolve_graph_overflows (tag,
hb_always_assert (overflowing.offset_overflow ());
hb_always_assert (hb_resolve_graph_overflows (tag,
num_iterations,
recalculate_extensions,
graph));
// Check the graphs can be serialized.
hb_blob_t* out1 = graph::serialize (graph);
assert (out1);
hb_always_assert (out1);
hb_blob_t* out2 = graph::serialize (expected_graph);
assert (out2);
hb_always_assert (out2);
if (check_binary_equivalence) {
unsigned l1, l2;
const char* d1 = hb_blob_get_data(out1, &l1);
@@ -517,7 +517,7 @@ static void run_resolve_overflow_test (const char* name,
graph.print();
printf("## Expected:\n");
expected_graph.print();
assert(match);
hb_always_assert(match);
}
}
@@ -533,7 +533,7 @@ static void run_resolve_overflow_test (const char* name,
printf("## Result:\n");
graph.print();
}
assert (graph == expected_graph);
hb_always_assert (graph == expected_graph);
}
static void add_virtual_offset (unsigned id,
@@ -888,7 +888,7 @@ populate_serializer_with_repack_last (hb_serialize_context_t* c, bool with_overf
unsigned obj_d = c->pop_pack(false);
add_offset(obj_d, c);
assert(c->last_added_child_index() == obj_d);
hb_always_assert(c->last_added_child_index() == obj_d);
if (!with_overflow) {
obj_e_1 = add_object("a", 1, c);
@@ -1804,27 +1804,27 @@ static void test_sort_shortest ()
graph_t graph (c.object_graph ());
graph.sort_shortest_distance ();
assert (!graph.in_error ());
hb_always_assert (!graph.in_error ());
assert(strncmp (graph.object (4).head, "abc", 3) == 0);
assert(graph.object (4).real_links.length == 3);
assert(graph.object (4).real_links[0].objidx == 2);
assert(graph.object (4).real_links[1].objidx == 0);
assert(graph.object (4).real_links[2].objidx == 3);
hb_always_assert(strncmp (graph.object (4).head, "abc", 3) == 0);
hb_always_assert(graph.object (4).real_links.length == 3);
hb_always_assert(graph.object (4).real_links[0].objidx == 2);
hb_always_assert(graph.object (4).real_links[1].objidx == 0);
hb_always_assert(graph.object (4).real_links[2].objidx == 3);
assert(strncmp (graph.object (3).head, "mn", 2) == 0);
assert(graph.object (3).real_links.length == 0);
hb_always_assert(strncmp (graph.object (3).head, "mn", 2) == 0);
hb_always_assert(graph.object (3).real_links.length == 0);
assert(strncmp (graph.object (2).head, "def", 3) == 0);
assert(graph.object (2).real_links.length == 1);
assert(graph.object (2).real_links[0].objidx == 1);
hb_always_assert(strncmp (graph.object (2).head, "def", 3) == 0);
hb_always_assert(graph.object (2).real_links.length == 1);
hb_always_assert(graph.object (2).real_links[0].objidx == 1);
assert(strncmp (graph.object (1).head, "ghi", 3) == 0);
assert(graph.object (1).real_links.length == 1);
assert(graph.object (1).real_links[0].objidx == 0);
hb_always_assert(strncmp (graph.object (1).head, "ghi", 3) == 0);
hb_always_assert(graph.object (1).real_links.length == 1);
hb_always_assert(graph.object (1).real_links[0].objidx == 0);
assert(strncmp (graph.object (0).head, "jkl", 3) == 0);
assert(graph.object (0).real_links.length == 0);
hb_always_assert(strncmp (graph.object (0).head, "jkl", 3) == 0);
hb_always_assert(graph.object (0).real_links.length == 0);
free (buffer);
}
@@ -1839,28 +1839,28 @@ static void test_duplicate_leaf ()
graph_t graph (c.object_graph ());
graph.duplicate (4, 1);
assert(strncmp (graph.object (5).head, "abc", 3) == 0);
assert(graph.object (5).real_links.length == 3);
assert(graph.object (5).real_links[0].objidx == 3);
assert(graph.object (5).real_links[1].objidx == 4);
assert(graph.object (5).real_links[2].objidx == 0);
hb_always_assert(strncmp (graph.object (5).head, "abc", 3) == 0);
hb_always_assert(graph.object (5).real_links.length == 3);
hb_always_assert(graph.object (5).real_links[0].objidx == 3);
hb_always_assert(graph.object (5).real_links[1].objidx == 4);
hb_always_assert(graph.object (5).real_links[2].objidx == 0);
assert(strncmp (graph.object (4).head, "jkl", 3) == 0);
assert(graph.object (4).real_links.length == 0);
hb_always_assert(strncmp (graph.object (4).head, "jkl", 3) == 0);
hb_always_assert(graph.object (4).real_links.length == 0);
assert(strncmp (graph.object (3).head, "def", 3) == 0);
assert(graph.object (3).real_links.length == 1);
assert(graph.object (3).real_links[0].objidx == 2);
hb_always_assert(strncmp (graph.object (3).head, "def", 3) == 0);
hb_always_assert(graph.object (3).real_links.length == 1);
hb_always_assert(graph.object (3).real_links[0].objidx == 2);
assert(strncmp (graph.object (2).head, "ghi", 3) == 0);
assert(graph.object (2).real_links.length == 1);
assert(graph.object (2).real_links[0].objidx == 1);
hb_always_assert(strncmp (graph.object (2).head, "ghi", 3) == 0);
hb_always_assert(graph.object (2).real_links.length == 1);
hb_always_assert(graph.object (2).real_links[0].objidx == 1);
assert(strncmp (graph.object (1).head, "jkl", 3) == 0);
assert(graph.object (1).real_links.length == 0);
hb_always_assert(strncmp (graph.object (1).head, "jkl", 3) == 0);
hb_always_assert(graph.object (1).real_links.length == 0);
assert(strncmp (graph.object (0).head, "mn", 2) == 0);
assert(graph.object (0).real_links.length == 0);
hb_always_assert(strncmp (graph.object (0).head, "mn", 2) == 0);
hb_always_assert(graph.object (0).real_links.length == 0);
free (buffer);
}
@@ -1875,33 +1875,33 @@ static void test_duplicate_interior ()
graph_t graph (c.object_graph ());
graph.duplicate (3, 2);
assert(strncmp (graph.object (6).head, "abc", 3) == 0);
assert(graph.object (6).real_links.length == 3);
assert(graph.object (6).real_links[0].objidx == 4);
assert(graph.object (6).real_links[1].objidx == 2);
assert(graph.object (6).real_links[2].objidx == 1);
hb_always_assert(strncmp (graph.object (6).head, "abc", 3) == 0);
hb_always_assert(graph.object (6).real_links.length == 3);
hb_always_assert(graph.object (6).real_links[0].objidx == 4);
hb_always_assert(graph.object (6).real_links[1].objidx == 2);
hb_always_assert(graph.object (6).real_links[2].objidx == 1);
assert(strncmp (graph.object (5).head, "jkl", 3) == 0);
assert(graph.object (5).real_links.length == 1);
assert(graph.object (5).real_links[0].objidx == 0);
hb_always_assert(strncmp (graph.object (5).head, "jkl", 3) == 0);
hb_always_assert(graph.object (5).real_links.length == 1);
hb_always_assert(graph.object (5).real_links[0].objidx == 0);
assert(strncmp (graph.object (4).head, "def", 3) == 0);
assert(graph.object (4).real_links.length == 1);
assert(graph.object (4).real_links[0].objidx == 3);
hb_always_assert(strncmp (graph.object (4).head, "def", 3) == 0);
hb_always_assert(graph.object (4).real_links.length == 1);
hb_always_assert(graph.object (4).real_links[0].objidx == 3);
assert(strncmp (graph.object (3).head, "ghi", 3) == 0);
assert(graph.object (3).real_links.length == 1);
assert(graph.object (3).real_links[0].objidx == 5);
hb_always_assert(strncmp (graph.object (3).head, "ghi", 3) == 0);
hb_always_assert(graph.object (3).real_links.length == 1);
hb_always_assert(graph.object (3).real_links[0].objidx == 5);
assert(strncmp (graph.object (2).head, "jkl", 3) == 0);
assert(graph.object (2).real_links.length == 1);
assert(graph.object (2).real_links[0].objidx == 0);
hb_always_assert(strncmp (graph.object (2).head, "jkl", 3) == 0);
hb_always_assert(graph.object (2).real_links.length == 1);
hb_always_assert(graph.object (2).real_links[0].objidx == 0);
assert(strncmp (graph.object (1).head, "mn", 2) == 0);
assert(graph.object (1).real_links.length == 0);
hb_always_assert(strncmp (graph.object (1).head, "mn", 2) == 0);
hb_always_assert(graph.object (1).real_links.length == 0);
assert(strncmp (graph.object (0).head, "opqrst", 6) == 0);
assert(graph.object (0).real_links.length == 0);
hb_always_assert(strncmp (graph.object (0).head, "opqrst", 6) == 0);
hb_always_assert(graph.object (0).real_links.length == 0);
free (buffer);
}
@@ -1920,7 +1920,7 @@ test_serialize ()
free (buffer_1);
hb_bytes_t actual = out->as_bytes ();
assert (actual == expected);
hb_always_assert (actual == expected);
expected.fini ();
hb_blob_destroy (out);
}
@@ -1933,7 +1933,7 @@ static void test_will_overflow_1 ()
populate_serializer_complex_2 (&c);
graph_t graph (c.object_graph ());
assert (!graph::will_overflow (graph, nullptr));
hb_always_assert (!graph::will_overflow (graph, nullptr));
free (buffer);
}
@@ -1946,7 +1946,7 @@ static void test_will_overflow_2 ()
populate_serializer_with_overflow (&c);
graph_t graph (c.object_graph ());
assert (graph::will_overflow (graph, nullptr));
hb_always_assert (graph::will_overflow (graph, nullptr));
free (buffer);
}
@@ -1959,7 +1959,7 @@ static void test_will_overflow_3 ()
populate_serializer_with_dedup_overflow (&c);
graph_t graph (c.object_graph ());
assert (graph::will_overflow (graph, nullptr));
hb_always_assert (graph::will_overflow (graph, nullptr));
free (buffer);
}
@@ -1973,9 +1973,9 @@ static void test_resolve_overflows_via_sort ()
graph_t graph (c.object_graph ());
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE);
assert (out);
hb_always_assert (out);
hb_bytes_t result = out->as_bytes ();
assert (result.length == (80000 + 3 + 3 * 2));
hb_always_assert (result.length == (80000 + 3 + 3 * 2));
free (buffer);
hb_blob_destroy (out);
@@ -1990,9 +1990,9 @@ static void test_resolve_overflows_via_duplication ()
graph_t graph (c.object_graph ());
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE);
assert (out);
hb_always_assert (out);
hb_bytes_t result = out->as_bytes ();
assert (result.length == (10000 + 2 * 2 + 60000 + 2 + 3 * 2));
hb_always_assert (result.length == (10000 + 2 * 2 + 60000 + 2 + 3 * 2));
free (buffer);
hb_blob_destroy (out);
@@ -2007,7 +2007,7 @@ static void test_resolve_overflows_via_multiple_duplications ()
graph_t graph (c.object_graph ());
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE, 5);
assert (out);
hb_always_assert (out);
free (buffer);
hb_blob_destroy (out);
@@ -2040,11 +2040,11 @@ static void test_resolve_overflows_via_isolation ()
populate_serializer_with_isolation_overflow (&c);
graph_t graph (c.object_graph ());
assert (c.offset_overflow ());
hb_always_assert (c.offset_overflow ());
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG ('G', 'S', 'U', 'B'), 0);
assert (out);
hb_always_assert (out);
hb_bytes_t result = out->as_bytes ();
assert (result.length == (1 + 10000 + 60000 + 1 + 1
hb_always_assert (result.length == (1 + 10000 + 60000 + 1 + 1
+ 4 + 3 * 2));
free (buffer);
@@ -2115,14 +2115,14 @@ static void test_resolve_overflows_via_isolation_spaces ()
populate_serializer_with_isolation_overflow_spaces (&c);
graph_t graph (c.object_graph ());
assert (c.offset_overflow ());
hb_always_assert (c.offset_overflow ());
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG ('G', 'S', 'U', 'B'), 0);
assert (out);
hb_always_assert (out);
hb_bytes_t result = out->as_bytes ();
unsigned expected_length = 3 + 2 * 60000; // objects
expected_length += 2 * 4 + 2 * 2; // links
assert (result.length == expected_length);
hb_always_assert (result.length == expected_length);
free (buffer);
hb_blob_destroy (out);
@@ -2136,9 +2136,9 @@ static void test_resolve_mixed_overflows_via_isolation_spaces ()
populate_serializer_with_24_and_32_bit_offsets (&c);
graph_t graph (c.object_graph ());
assert (c.offset_overflow ());
hb_always_assert (c.offset_overflow ());
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG ('G', 'S', 'U', 'B'), 0);
assert (out);
hb_always_assert (out);
hb_bytes_t result = out->as_bytes ();
unsigned expected_length =
@@ -2152,7 +2152,7 @@ static void test_resolve_mixed_overflows_via_isolation_spaces ()
4 * 3 + // 24
4 * 2; // 16
assert (result.length == expected_length);
hb_always_assert (result.length == expected_length);
free (buffer);
hb_blob_destroy (out);
@@ -2162,12 +2162,12 @@ static void test_resolve_with_extension_promotion ()
{
size_t buffer_size = 200000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_extension_promotion (&c);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_extension_promotion (&e, 3);
@@ -2184,12 +2184,12 @@ static void test_resolve_with_shared_extension_promotion ()
{
size_t buffer_size = 200000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_extension_promotion (&c, 0, true);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_extension_promotion (&e, 3, true);
@@ -2206,12 +2206,12 @@ static void test_resolve_with_basic_pair_pos_1_split ()
{
size_t buffer_size = 200000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_large_pair_pos_1 <1, 4>(&c);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_large_pair_pos_1 <2, 2>(&e, true);
@@ -2229,12 +2229,12 @@ static void test_resolve_with_extension_pair_pos_1_split ()
{
size_t buffer_size = 200000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_large_pair_pos_1 <1, 4>(&c, true);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_large_pair_pos_1 <2, 2>(&e, true);
@@ -2252,12 +2252,12 @@ static void test_resolve_with_basic_pair_pos_2_split ()
{
size_t buffer_size = 300000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_large_pair_pos_2 <1, 4, 3000>(&c);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_large_pair_pos_2 <2, 2, 3000>(&e, true);
@@ -2275,12 +2275,12 @@ static void test_resolve_with_close_to_limit_pair_pos_2_split ()
{
size_t buffer_size = 300000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_large_pair_pos_2 <1, 1636, 10>(&c, true, false, false);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_large_pair_pos_2 <2, 818, 10>(&e, true, false, false);
@@ -2298,12 +2298,12 @@ static void test_resolve_with_pair_pos_2_split_with_device_tables ()
{
size_t buffer_size = 300000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_large_pair_pos_2 <1, 4, 2000>(&c, false, true);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_large_pair_pos_2 <2, 2, 2000>(&e, true, true);
@@ -2321,12 +2321,12 @@ static void test_resolve_with_basic_mark_base_pos_1_split ()
{
size_t buffer_size = 200000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_large_mark_base_pos_1 <40, 10, 110, 1>(&c);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_large_mark_base_pos_1 <40, 10, 110, 2>(&e);
@@ -2344,12 +2344,12 @@ static void test_resolve_with_basic_liga_split ()
{
size_t buffer_size = 200000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_large_liga<1, 1, 2, 40000>(&c, false);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_large_liga<2, 1, 1, 40000>(&e, false);
@@ -2367,12 +2367,12 @@ static void test_resolve_with_liga_split_move ()
{
size_t buffer_size = 400000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_large_liga<1, 6, 2, 16000>(&c, true);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_large_liga<3, 2, 2, 16000>(&e, true);
@@ -2390,12 +2390,12 @@ static void test_resolve_with_liga_split_overlapping_clone ()
{
size_t buffer_size = 400000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_large_liga<1, 2, 3, 30000>(&c, true);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_large_liga_overlapping_clone_result(&e);
@@ -2477,15 +2477,15 @@ static void test_virtual_link ()
populate_serializer_virtual_link (&c);
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE);
assert (out);
hb_always_assert (out);
hb_bytes_t result = out->as_bytes ();
assert (result.length == 5 + 4 * 2);
assert (result[0] == 'a');
assert (result[5] == 'c');
assert (result[8] == 'e');
assert (result[9] == 'b');
assert (result[12] == 'd');
hb_always_assert (result.length == 5 + 4 * 2);
hb_always_assert (result[0] == 'a');
hb_always_assert (result[5] == 'c');
hb_always_assert (result[8] == 'e');
hb_always_assert (result[9] == 'b');
hb_always_assert (result[12] == 'd');
free (buffer);
hb_blob_destroy (out);
@@ -2511,7 +2511,7 @@ test_shared_node_with_virtual_links ()
add_virtual_offset (obj_c, &c);
unsigned obj_d_2 = c.pop_pack ();
assert (obj_d_1 == obj_d_2);
hb_always_assert (obj_d_1 == obj_d_2);
start_object ("a", 1, &c);
add_offset (obj_b, &c);
@@ -2521,9 +2521,9 @@ test_shared_node_with_virtual_links ()
c.pop_pack ();
c.end_serialize ();
assert(c.object_graph() [obj_d_1]->virtual_links.length == 2);
assert(c.object_graph() [obj_d_1]->virtual_links[0].objidx == obj_b);
assert(c.object_graph() [obj_d_1]->virtual_links[1].objidx == obj_c);
hb_always_assert(c.object_graph() [obj_d_1]->virtual_links.length == 2);
hb_always_assert(c.object_graph() [obj_d_1]->virtual_links[0].objidx == obj_b);
hb_always_assert(c.object_graph() [obj_d_1]->virtual_links[1].objidx == obj_c);
free(buffer);
}
@@ -2532,12 +2532,12 @@ test_repack_last ()
{
size_t buffer_size = 200000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_with_repack_last (&c, true);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_repack_last (&e, false);
@@ -2558,12 +2558,12 @@ test_dont_duplicate_virtual ()
{
size_t buffer_size = 200000;
void* buffer = malloc (buffer_size);
assert (buffer);
hb_always_assert (buffer);
hb_serialize_context_t c (buffer, buffer_size);
populate_serializer_virtual (&c, true);
void* expected_buffer = malloc (buffer_size);
assert (expected_buffer);
hb_always_assert (expected_buffer);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_virtual (&e, false);
+1 -1
View File
@@ -45,7 +45,7 @@ main (int argc, char **argv)
s.end_serialize ();
hb_bytes_t bytes = s.copy_bytes ();
assert (bytes.length == 10);
hb_always_assert (bytes.length == 10);
bytes.fini ();
return 0;
+40 -40
View File
@@ -33,9 +33,9 @@ main (int argc, char **argv)
{
hb_set_t v1 {1, 2};
hb_set_t v2 {v1};
assert (v1.get_population () == 2);
assert (hb_len (hb_iter (v1)) == 2);
assert (v2.get_population () == 2);
hb_always_assert (v1.get_population () == 2);
hb_always_assert (hb_len (hb_iter (v1)) == 2);
hb_always_assert (v2.get_population () == 2);
}
/* Test copy assignment. */
@@ -43,17 +43,17 @@ main (int argc, char **argv)
hb_set_t v1 {1, 2};
hb_set_t v2;
v2 = v1;
assert (v1.get_population () == 2);
assert (v2.get_population () == 2);
hb_always_assert (v1.get_population () == 2);
hb_always_assert (v2.get_population () == 2);
}
/* Test move constructor. */
{
hb_set_t s {1, 2};
hb_set_t v (std::move (s));
assert (s.get_population () == 0);
assert (hb_len (hb_iter (s)) == 0);
assert (v.get_population () == 2);
hb_always_assert (s.get_population () == 0);
hb_always_assert (hb_len (hb_iter (s)) == 0);
hb_always_assert (v.get_population () == 2);
}
/* Test move assignment. */
@@ -61,8 +61,8 @@ main (int argc, char **argv)
hb_set_t s = hb_set_t {1, 2};
hb_set_t v;
v = std::move (s);
assert (s.get_population () == 0);
assert (v.get_population () == 2);
hb_always_assert (s.get_population () == 0);
hb_always_assert (v.get_population () == 2);
}
/* Test initializing from iterable. */
@@ -77,10 +77,10 @@ main (int argc, char **argv)
hb_set_t v1 (s);
hb_set_t v2 (std::move (s));
assert (s.get_population () == 0);
assert (v0.get_population () == 2);
assert (v1.get_population () == 2);
assert (v2.get_population () == 2);
hb_always_assert (s.get_population () == 0);
hb_always_assert (v0.get_population () == 2);
hb_always_assert (v1.get_population () == 2);
hb_always_assert (v2.get_population () == 2);
}
/* Test initializing from iterator. */
@@ -95,7 +95,7 @@ main (int argc, char **argv)
hb_set_t v (hb_iter (s));
assert (v.get_population () == 5);
hb_always_assert (v.get_population () == 5);
}
/* Test initializing from initializer list and swapping. */
@@ -103,8 +103,8 @@ main (int argc, char **argv)
hb_set_t v1 {1, 2, 3};
hb_set_t v2 {4, 5};
hb_swap (v1, v2);
assert (v1.get_population () == 2);
assert (v2.get_population () == 3);
hb_always_assert (v1.get_population () == 2);
hb_always_assert (v2.get_population () == 3);
}
/* Test inverted sets. */
@@ -114,27 +114,27 @@ main (int argc, char **argv)
s.del (5);
hb_codepoint_t start = HB_SET_VALUE_INVALID, last = HB_SET_VALUE_INVALID;
assert (s.next_range (&start, &last));
assert (start == 0);
assert (last == 4);
assert (s.next_range (&start, &last));
assert (start == 6);
assert (last == HB_SET_VALUE_INVALID - 1);
assert (!s.next_range (&start, &last));
hb_always_assert (s.next_range (&start, &last));
hb_always_assert (start == 0);
hb_always_assert (last == 4);
hb_always_assert (s.next_range (&start, &last));
hb_always_assert (start == 6);
hb_always_assert (last == HB_SET_VALUE_INVALID - 1);
hb_always_assert (!s.next_range (&start, &last));
start = HB_SET_VALUE_INVALID;
last = HB_SET_VALUE_INVALID;
assert (s.previous_range (&start, &last));
assert (start == 6);
assert (last == HB_SET_VALUE_INVALID - 1);
assert (s.previous_range (&start, &last));
assert (start == 0);
assert (last == 4);
assert (!s.previous_range (&start, &last));
hb_always_assert (s.previous_range (&start, &last));
hb_always_assert (start == 6);
hb_always_assert (last == HB_SET_VALUE_INVALID - 1);
hb_always_assert (s.previous_range (&start, &last));
hb_always_assert (start == 0);
hb_always_assert (last == 4);
hb_always_assert (!s.previous_range (&start, &last));
assert (s.is_inverted ());
hb_always_assert (s.is_inverted ());
/* Inverted set returns true for invalid value; oh well. */
assert (s.has (HB_SET_VALUE_INVALID));
hb_always_assert (s.has (HB_SET_VALUE_INVALID));
}
/* Adding HB_SET_VALUE_INVALID */
@@ -142,23 +142,23 @@ main (int argc, char **argv)
hb_set_t s;
s.add(HB_SET_VALUE_INVALID);
assert(!s.has(HB_SET_VALUE_INVALID));
hb_always_assert(!s.has(HB_SET_VALUE_INVALID));
s.clear();
assert(!s.add_range(HB_SET_VALUE_INVALID - 2, HB_SET_VALUE_INVALID));
assert(!s.has(HB_SET_VALUE_INVALID));
hb_always_assert(!s.add_range(HB_SET_VALUE_INVALID - 2, HB_SET_VALUE_INVALID));
hb_always_assert(!s.has(HB_SET_VALUE_INVALID));
hb_codepoint_t array[] = {(unsigned) HB_SET_VALUE_INVALID, 0, 2};
s.clear();
s.add_array(array, 3);
assert(!s.has(HB_SET_VALUE_INVALID));
assert(s.has(2));
hb_always_assert(!s.has(HB_SET_VALUE_INVALID));
hb_always_assert(s.has(2));
hb_codepoint_t sorted_array[] = {0, 2, (unsigned) HB_SET_VALUE_INVALID};
s.clear();
s.add_sorted_array(sorted_array, 3);
assert(!s.has(HB_SET_VALUE_INVALID));
assert(s.has(2));
hb_always_assert(!s.has(HB_SET_VALUE_INVALID));
hb_always_assert(s.has(2));
}
return 0;
+170 -170
View File
@@ -49,7 +49,7 @@ main (int argc, char **argv)
Triple tent (0.0, 1.0, 1.0);
Triple axis_range (0.0, 0.0, 0.0);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 0);
hb_always_assert (out.length == 0);
}
{
@@ -57,9 +57,9 @@ main (int argc, char **argv)
Triple tent (0.0, 1.0, 1.0);
Triple axis_range (0.5, 0.5, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 1);
assert (out[0].first == 0.5);
assert (out[0].second == Triple ());
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 0.5);
hb_always_assert (out[0].second == Triple ());
}
{
@@ -67,7 +67,7 @@ main (int argc, char **argv)
Triple tent (0.3, 0.5, 0.8);
Triple axis_range (0.1, 0.2, 0.3);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 0);
hb_always_assert (out.length == 0);
}
/* Case 2 */
@@ -75,9 +75,9 @@ main (int argc, char **argv)
Triple tent (0.0, 1.0, 1.0);
Triple axis_range (-1.0, 0.0, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 1);
assert (out[0].first == 0.5);
assert (out[0].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 0.5);
hb_always_assert (out[0].second == Triple (0.0, 1.0, 1.0));
}
/* Case 2 */
@@ -85,9 +85,9 @@ main (int argc, char **argv)
Triple tent (0.0, 1.0, 1.0);
Triple axis_range (-1.0, 0.0, 0.75);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 1);
assert (out[0].first == 0.75);
assert (out[0].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 0.75);
hb_always_assert (out[0].second == Triple (0.0, 1.0, 1.0));
}
/* Without gain: */
@@ -96,11 +96,11 @@ main (int argc, char **argv)
Triple tent (0.0, 0.2, 1.0);
Triple axis_range (-1.0, 0.0, 0.8);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 2);
assert (out[0].first == 1.0);
assert (out[0].second == Triple (0.0, 0.25, 1.0));
assert (approx (out[1].first, 0.250));
assert (out[1].second == Triple (0.25, 1.0, 1.0));
hb_always_assert (out.length == 2);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple (0.0, 0.25, 1.0));
hb_always_assert (approx (out[1].first, 0.250));
hb_always_assert (out[1].second == Triple (0.25, 1.0, 1.0));
}
/* Case 3 boundary */
@@ -108,11 +108,11 @@ main (int argc, char **argv)
Triple tent (0.0, 0.4, 1.0);
Triple axis_range (-1.0, 0.0, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 2);
assert (out[0].first == 1.0);
assert (out[0].second == Triple (0.0, 0.8, 1.0));
assert (approx (out[1].first, 2.5/3));
assert (out[1].second == Triple (0.8, 1.0, 1.0));
hb_always_assert (out.length == 2);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple (0.0, 0.8, 1.0));
hb_always_assert (approx (out[1].first, 2.5/3));
hb_always_assert (out[1].second == Triple (0.8, 1.0, 1.0));
}
/* Case 4 */
@@ -120,11 +120,11 @@ main (int argc, char **argv)
Triple tent (0.0, 0.25, 1.0);
Triple axis_range (-1.0, 0.0, 0.4);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 2);
assert (out[0].first == 1.0);
assert (out[0].second == Triple (0.0, 0.625, 1.0));
assert (approx (out[1].first, 0.80));
assert (out[1].second == Triple (0.625, 1.0, 1.0));
hb_always_assert (out.length == 2);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple (0.0, 0.625, 1.0));
hb_always_assert (approx (out[1].first, 0.80));
hb_always_assert (out[1].second == Triple (0.625, 1.0, 1.0));
}
/* Case 4 */
@@ -132,11 +132,11 @@ main (int argc, char **argv)
Triple tent (0.25, 0.3, 1.05);
Triple axis_range (0.0, 0.2, 0.4);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 2);
assert (out[0].first == 1.0);
assert (approx (out[0].second, Triple (0.25, 0.5, 1.0)));
assert (approx (out[1].first, 2.6 / 3));
assert (approx (out[1].second, Triple (0.5, 1.0, 1.0)));
hb_always_assert (out.length == 2);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (approx (out[0].second, Triple (0.25, 0.5, 1.0)));
hb_always_assert (approx (out[1].first, 2.6 / 3));
hb_always_assert (approx (out[1].second, Triple (0.5, 1.0, 1.0)));
}
/* Case 4 boundary */
@@ -144,9 +144,9 @@ main (int argc, char **argv)
Triple tent (0.25, 0.5, 1.0);
Triple axis_range (0.0, 0.25, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 1);
assert (out[0].first == 1.0);
assert (out[0].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple (0.0, 1.0, 1.0));
}
/* With gain */
@@ -155,41 +155,41 @@ main (int argc, char **argv)
Triple tent (0.0, 0.5, 1.0);
Triple axis_range (0.0, 0.5, 1.0);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 3);
assert (out[0].first == 1.0);
assert (out[0].second == Triple ());
assert (out[1].first == -1.0);
assert (out[1].second == Triple (0.0, 1.0, 1.0));
assert (out[2].first == -1.0);
assert (out[2].second == Triple (-1.0, -1.0, 0.0));
hb_always_assert (out.length == 3);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (out[1].first == -1.0);
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (out[2].first == -1.0);
hb_always_assert (out[2].second == Triple (-1.0, -1.0, 0.0));
}
{
Triple tent (0.0, 0.5, 1.0);
Triple axis_range (0.0, 0.5, 0.75);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 3);
assert (out[0].first == 1.0);
assert (out[0].second == Triple ());
assert (out[1].first == -0.5);
assert (out[1].second == Triple (0.0, 1.0, 1.0));
assert (out[2].first == -1.0);
assert (out[2].second == Triple (-1.0, -1.0, 0.0));
hb_always_assert (out.length == 3);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (out[1].first == -0.5);
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (out[2].first == -1.0);
hb_always_assert (out[2].second == Triple (-1.0, -1.0, 0.0));
}
{
Triple tent (0.0, 0.50, 1.0);
Triple axis_range (0.0, 0.25, 0.8);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 4);
assert (out[0].first == 0.5);
assert (out[0].second == Triple ());
assert (out[1].first == 0.5);
assert (approx (out[1].second, Triple (0.0, 0.454545, 0.909091)));
assert (approx (out[2].first, -0.1));
assert (approx (out[2].second, Triple (0.909091, 1.0, 1.0)));
assert (out[3].first == -0.5);
assert (out[3].second == Triple (-1.0, -1.0, 0.0));
hb_always_assert (out.length == 4);
hb_always_assert (out[0].first == 0.5);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (out[1].first == 0.5);
hb_always_assert (approx (out[1].second, Triple (0.0, 0.454545, 0.909091)));
hb_always_assert (approx (out[2].first, -0.1));
hb_always_assert (approx (out[2].second, Triple (0.909091, 1.0, 1.0)));
hb_always_assert (out[3].first == -0.5);
hb_always_assert (out[3].second == Triple (-1.0, -1.0, 0.0));
}
/* Case 3a/1neg */
@@ -197,13 +197,13 @@ main (int argc, char **argv)
Triple tent (0.0, 0.5, 2.0);
Triple axis_range (0.2, 0.5, 0.8);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 3);
assert (out[0].first == 1.0);
assert (out[0].second == Triple ());
assert (approx (out[1].first, -0.2));
assert (out[1].second == Triple (0.0, 1.0, 1.0));
assert (approx (out[2].first, -0.6));
assert (out[2].second == Triple (-1.0, -1.0, 0.0));
hb_always_assert (out.length == 3);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (approx (out[1].first, -0.2));
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (approx (out[2].first, -0.6));
hb_always_assert (out[2].second == Triple (-1.0, -1.0, 0.0));
}
/* Case 3a/1neg */
@@ -211,13 +211,13 @@ main (int argc, char **argv)
Triple tent (0.0, 0.5, 2.0);
Triple axis_range (0.2, 0.5, 1.0);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 3);
assert (out[0].first == 1.0);
assert (out[0].second == Triple ());
assert (approx (out[1].first, -1.0/3));
assert (out[1].second == Triple (0.0, 1.0, 1.0));
assert (approx (out[2].first, -0.6));
assert (out[2].second == Triple (-1.0, -1.0, 0.0));
hb_always_assert (out.length == 3);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (approx (out[1].first, -1.0/3));
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (approx (out[2].first, -0.6));
hb_always_assert (out[2].second == Triple (-1.0, -1.0, 0.0));
}
/* Case 3 */
@@ -225,11 +225,11 @@ main (int argc, char **argv)
Triple tent (0.0, 0.5, 1.0);
Triple axis_range (0.25, 0.25, 0.75);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 2);
assert (out[0].first == 0.5);
assert (out[0].second == Triple ());
assert (out[1].first == 0.5);
assert (out[1].second == Triple (0.0, 0.5, 1.0));
hb_always_assert (out.length == 2);
hb_always_assert (out[0].first == 0.5);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (out[1].first == 0.5);
hb_always_assert (out[1].second == Triple (0.0, 0.5, 1.0));
}
/* Case 1neg */
@@ -237,13 +237,13 @@ main (int argc, char **argv)
Triple tent (0.0, 0.5, 1.0);
Triple axis_range (0.0, 0.25, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 3);
assert (out[0].first == 0.5);
assert (out[0].second == Triple ());
assert (out[1].first == 0.5);
assert (out[1].second == Triple (0.0, 1.0, 1.0));
assert (out[2].first == -0.5);
assert (out[2].second == Triple (-1.0, -1.0, 0.0));
hb_always_assert (out.length == 3);
hb_always_assert (out[0].first == 0.5);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (out[1].first == 0.5);
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (out[2].first == -0.5);
hb_always_assert (out[2].second == Triple (-1.0, -1.0, 0.0));
}
/* Case 2neg */
@@ -251,15 +251,15 @@ main (int argc, char **argv)
Triple tent (0.05, 0.55, 1.0);
Triple axis_range (0.0, 0.25, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 4);
assert (approx (out[0].first, 0.4));
assert (out[0].second == Triple ());
assert (approx (out[1].first, 0.5));
assert (out[1].second == Triple (0.0, 1.0, 1.0));
assert (approx (out[2].first, -0.4));
assert (out[2].second == Triple (-1.0, -0.8, 0.0));
assert (approx (out[3].first, -0.4));
assert (out[3].second == Triple (-1.0, -1.0, -0.8));
hb_always_assert (out.length == 4);
hb_always_assert (approx (out[0].first, 0.4));
hb_always_assert (out[0].second == Triple ());
hb_always_assert (approx (out[1].first, 0.5));
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (approx (out[2].first, -0.4));
hb_always_assert (out[2].second == Triple (-1.0, -0.8, 0.0));
hb_always_assert (approx (out[3].first, -0.4));
hb_always_assert (out[3].second == Triple (-1.0, -1.0, -0.8));
}
/* Case 2neg, other side */
@@ -267,15 +267,15 @@ main (int argc, char **argv)
Triple tent (-1.0, -0.55, -0.05);
Triple axis_range (-0.5, -0.25, 0.0);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 4);
assert (approx (out[0].first, 0.4));
assert (out[0].second == Triple ());
assert (approx (out[1].first, 0.5));
assert (out[1].second == Triple (-1.0, -1.0, 0.0));
assert (approx (out[2].first, -0.4));
assert (out[2].second == Triple (0.0, 0.8, 1.0));
assert (approx (out[3].first, -0.4));
assert (out[3].second == Triple (0.8, 1.0, 1.0));
hb_always_assert (out.length == 4);
hb_always_assert (approx (out[0].first, 0.4));
hb_always_assert (out[0].second == Triple ());
hb_always_assert (approx (out[1].first, 0.5));
hb_always_assert (out[1].second == Triple (-1.0, -1.0, 0.0));
hb_always_assert (approx (out[2].first, -0.4));
hb_always_assert (out[2].second == Triple (0.0, 0.8, 1.0));
hb_always_assert (approx (out[3].first, -0.4));
hb_always_assert (out[3].second == Triple (0.8, 1.0, 1.0));
}
/* Misc corner cases */
@@ -283,86 +283,86 @@ main (int argc, char **argv)
Triple tent (0.5, 0.5, 0.5);
Triple axis_range (0.5, 0.5, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 1);
assert (out[0].first == 1.0);
assert (out[0].second == Triple ());
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple ());
}
{
Triple tent (0.3, 0.5, 0.7);
Triple axis_range (0.1, 0.5, 0.9);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 5);
assert (out[0].first == 1.0);
assert (out[0].second == Triple ());
assert (out[1].first == -1.0);
assert (approx(out[1].second, Triple (0.0, 0.5, 1.0)));
assert (out[2].first == -1.0);
assert (approx(out[2].second, Triple (0.5, 1.0, 1.0)));
assert (out[3].first == -1.0);
assert (approx (out[3].second, Triple (-1.0, -0.5, 0.0)));
assert (out[4].first == -1.0);
assert (approx (out[4].second, Triple (-1.0, -1.0, -0.5)));
hb_always_assert (out.length == 5);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (out[1].first == -1.0);
hb_always_assert (approx(out[1].second, Triple (0.0, 0.5, 1.0)));
hb_always_assert (out[2].first == -1.0);
hb_always_assert (approx(out[2].second, Triple (0.5, 1.0, 1.0)));
hb_always_assert (out[3].first == -1.0);
hb_always_assert (approx (out[3].second, Triple (-1.0, -0.5, 0.0)));
hb_always_assert (out[4].first == -1.0);
hb_always_assert (approx (out[4].second, Triple (-1.0, -1.0, -0.5)));
}
{
Triple tent (0.5, 0.5, 0.5);
Triple axis_range (0.25, 0.25, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 1);
assert (out[0].first == 1.0);
assert (out[0].second == Triple (1.0, 1.0, 1.0));
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple (1.0, 1.0, 1.0));
}
{
Triple tent (0.5, 0.5, 0.5);
Triple axis_range (0.25, 0.35, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 1);
assert (out[0].first == 1.0);
assert (out[0].second == Triple (1.0, 1.0, 1.0));
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple (1.0, 1.0, 1.0));
}
{
Triple tent (0.5, 0.5, 0.55);
Triple axis_range (0.25, 0.35, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 1);
assert (out[0].first == 1.0);
assert (out[0].second == Triple (1.0, 1.0, 1.0));
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple (1.0, 1.0, 1.0));
}
{
Triple tent (0.5, 0.5, 1.0);
Triple axis_range (0.5, 0.5, 1.0);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 2);
assert (out[0].first == 1.0);
assert (out[0].second == Triple ());
assert (out[1].first == -1.0);
assert (out[1].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (out.length == 2);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (out[1].first == -1.0);
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
}
{
Triple tent (0.25, 0.5, 1.0);
Triple axis_range (0.5, 0.5, 1.0);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 2);
assert (out[0].first == 1.0);
assert (out[0].second == Triple ());
assert (out[1].first == -1.0);
assert (out[1].second == Triple (0.0, 1.0, 1.0));
hb_always_assert (out.length == 2);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (out[1].first == -1.0);
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
}
{
Triple tent (0.0, 0.2, 1.0);
Triple axis_range (0.0, 0.0, 0.5);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 2);
assert (out[0].first == 1.0);
assert (out[0].second == Triple (0.0, 0.4, 1.0));
assert (out[1].first == 0.625);
assert (out[1].second == Triple (0.4, 1.0, 1.0));
hb_always_assert (out.length == 2);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple (0.0, 0.4, 1.0));
hb_always_assert (out[1].first == 0.625);
hb_always_assert (out[1].second == Triple (0.4, 1.0, 1.0));
}
@@ -370,43 +370,43 @@ main (int argc, char **argv)
Triple tent (0.0, 0.5, 1.0);
Triple axis_range (-1.0, 0.25, 1.0);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 5);
assert (out[0].first == 0.5);
assert (out[0].second == Triple ());
assert (out[1].first == 0.5);
assert (out[1].second == Triple (0.0, 1.0/3, 2.0/3));
assert (out[2].first == -0.5);
assert (out[2].second == Triple (2.0/3, 1.0, 1.0));
assert (out[3].first == -0.5);
assert (out[3].second == Triple (-1.0, -0.2, 0.0));
assert (out[4].first == -0.5);
assert (out[4].second == Triple (-1.0, -1.0, -0.2));
hb_always_assert (out.length == 5);
hb_always_assert (out[0].first == 0.5);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (out[1].first == 0.5);
hb_always_assert (out[1].second == Triple (0.0, 1.0/3, 2.0/3));
hb_always_assert (out[2].first == -0.5);
hb_always_assert (out[2].second == Triple (2.0/3, 1.0, 1.0));
hb_always_assert (out[3].first == -0.5);
hb_always_assert (out[3].second == Triple (-1.0, -0.2, 0.0));
hb_always_assert (out[4].first == -0.5);
hb_always_assert (out[4].second == Triple (-1.0, -1.0, -0.2));
}
{
Triple tent (0.5, 0.5, 0.5);
Triple axis_range (0.0, 0.5, 1.0);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 5);
assert (out[0].first == 1.0);
assert (out[0].second == Triple ());
assert (out[1].first == -1.0);
assert (out[1].second == Triple (0.0, 2/(double) (1 << 14), 1.0));
assert (out[2].first == -1.0);
assert (out[2].second == Triple (2/(double) (1 << 14), 1.0, 1.0));
assert (out[3].first == -1.0);
assert (out[3].second == Triple (-1.0, -2/(double) (1 << 14), 0.0));
assert (out[4].first == -1.0);
assert (out[4].second == Triple (-1.0, -1.0, -2/(double) (1 << 14)));
hb_always_assert (out.length == 5);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple ());
hb_always_assert (out[1].first == -1.0);
hb_always_assert (out[1].second == Triple (0.0, 2/(double) (1 << 14), 1.0));
hb_always_assert (out[2].first == -1.0);
hb_always_assert (out[2].second == Triple (2/(double) (1 << 14), 1.0, 1.0));
hb_always_assert (out[3].first == -1.0);
hb_always_assert (out[3].second == Triple (-1.0, -2/(double) (1 << 14), 0.0));
hb_always_assert (out[4].first == -1.0);
hb_always_assert (out[4].second == Triple (-1.0, -1.0, -2/(double) (1 << 14)));
}
{
Triple tent (0.0, 1.0, 1.0);
Triple axis_range (-1.0, -0.5, 1.0);
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
assert (out.length == 1);
assert (out[0].first == 1.0);
assert (out[0].second == Triple (1.0/3, 1.0, 1.0));
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple (1.0/3, 1.0, 1.0));
}
{
@@ -414,9 +414,9 @@ main (int argc, char **argv)
Triple axis_range (-1.0, -0.5, 1.0);
TripleDistances axis_distances{2.0, 1.0};
rebase_tent_result_t out = rebase_tent (tent, axis_range, axis_distances);
assert (out.length == 1);
assert (out[0].first == 1.0);
assert (out[0].second == Triple (0.5, 1.0, 1.0));
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (out[0].second == Triple (0.5, 1.0, 1.0));
}
{
@@ -424,8 +424,8 @@ main (int argc, char **argv)
Triple axis_range (-1.0, 0.2, 1.0);
TripleDistances axis_distances{1.0, 1.0};
rebase_tent_result_t out = rebase_tent (tent, axis_range, axis_distances);
assert (out.length == 1);
assert (out[0].first == 1.0);
assert (approx (out[0].second, Triple (0.5, 0.625, 0.75)));
hb_always_assert (out.length == 1);
hb_always_assert (out[0].first == 1.0);
hb_always_assert (approx (out[0].second, Triple (0.5, 0.625, 0.75)));
}
}
+36 -36
View File
@@ -48,33 +48,33 @@ test_decompile_cvar ()
hb_bytes_t var_data_bytes{(const char* ) cvar_data + 4, len - 4};
bool result = OT::TupleVariationData<>::get_tuple_iterator (var_data_bytes, axis_count, cvar_table,
shared_indices, &iterator);
assert (result);
hb_always_assert (result);
result = tuple_var_data->decompile_tuple_variations (point_count, false, iterator, &axis_idx_tag_map,
shared_indices, hb_array<const OT::F2DOT14> (),
tuple_variations);
assert (result);
assert (tuple_variations.tuple_vars.length == 2);
hb_always_assert (result);
hb_always_assert (tuple_variations.tuple_vars.length == 2);
for (unsigned i = 0; i < 2; i++)
{
assert (tuple_variations.tuple_vars[i].axis_tuples.get_population () == 1);
assert (!tuple_variations.tuple_vars[i].deltas_y);
assert (tuple_variations.tuple_vars[i].indices.length == 65);
assert (tuple_variations.tuple_vars[i].indices.length == tuple_variations.tuple_vars[i].deltas_x.length);
hb_always_assert (tuple_variations.tuple_vars[i].axis_tuples.get_population () == 1);
hb_always_assert (!tuple_variations.tuple_vars[i].deltas_y);
hb_always_assert (tuple_variations.tuple_vars[i].indices.length == 65);
hb_always_assert (tuple_variations.tuple_vars[i].indices.length == tuple_variations.tuple_vars[i].deltas_x.length);
}
assert (tuple_variations.tuple_vars[0].axis_tuples.get (axis_tag) == Triple (-1.0, -1.0, 0.0));
assert (tuple_variations.tuple_vars[1].axis_tuples.get (axis_tag) == Triple (0.0, 1.0, 1.0));
hb_always_assert (tuple_variations.tuple_vars[0].axis_tuples.get (axis_tag) == Triple (-1.0, -1.0, 0.0));
hb_always_assert (tuple_variations.tuple_vars[1].axis_tuples.get (axis_tag) == Triple (0.0, 1.0, 1.0));
hb_vector_t<float> deltas_1 {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, -3.0, 1.0, 0.0, -1.0, 0.0, -3.0, 1.0, 0.0, -37.0, -37.0, -26.0, -26.0, 0.0, 0.0, 0.0, -3.0, 0.0, 0.0, 0.0, 0.0, 0.0, -3.0, 0.0, 2.0, -29.0, -29.0, -20.0, -20.0, 0.0, 0.0, 0.0, 1.0, -29.0, -29.0, -20.0, -20.0, 0.0, 0.0, 0.0, 1.0};
for (unsigned i = 0; i < 65; i++)
{
if (i < 23)
assert (tuple_variations.tuple_vars[0].indices[i] == 0);
hb_always_assert (tuple_variations.tuple_vars[0].indices[i] == 0);
else
{
assert (tuple_variations.tuple_vars[0].indices[i] == 1);
assert (tuple_variations.tuple_vars[0].deltas_x[i] == deltas_1[i]);
hb_always_assert (tuple_variations.tuple_vars[0].indices[i] == 1);
hb_always_assert (tuple_variations.tuple_vars[0].deltas_x[i] == deltas_1[i]);
}
}
@@ -82,11 +82,11 @@ test_decompile_cvar ()
for (unsigned i = 0 ; i < 65; i++)
{
if (i < 23)
assert (tuple_variations.tuple_vars[1].indices[i] == 0);
hb_always_assert (tuple_variations.tuple_vars[1].indices[i] == 0);
else
{
assert (tuple_variations.tuple_vars[1].indices[i] == 1);
assert (tuple_variations.tuple_vars[1].deltas_x[i] == deltas_2[i]);
hb_always_assert (tuple_variations.tuple_vars[1].indices[i] == 1);
hb_always_assert (tuple_variations.tuple_vars[1].deltas_x[i] == deltas_2[i]);
}
}
@@ -99,12 +99,12 @@ test_decompile_cvar ()
tuple_variations.instantiate (normalized_axes_location, axes_triple_distances);
assert (tuple_variations.tuple_vars[0].indices.length == 65);
assert (tuple_variations.tuple_vars[1].indices.length == 65);
assert (!tuple_variations.tuple_vars[0].deltas_y);
assert (!tuple_variations.tuple_vars[1].deltas_y);
assert (tuple_variations.tuple_vars[0].axis_tuples.get (axis_tag) == Triple (-1.0, -1.0, 0.0));
assert (tuple_variations.tuple_vars[1].axis_tuples.get (axis_tag) == Triple (0.0, 1.0, 1.0));
hb_always_assert (tuple_variations.tuple_vars[0].indices.length == 65);
hb_always_assert (tuple_variations.tuple_vars[1].indices.length == 65);
hb_always_assert (!tuple_variations.tuple_vars[0].deltas_y);
hb_always_assert (!tuple_variations.tuple_vars[1].deltas_y);
hb_always_assert (tuple_variations.tuple_vars[0].axis_tuples.get (axis_tag) == Triple (-1.0, -1.0, 0.0));
hb_always_assert (tuple_variations.tuple_vars[1].axis_tuples.get (axis_tag) == Triple (0.0, 1.0, 1.0));
hb_vector_t<float> rounded_deltas_1 {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1, 0.0, -2, 1, 0.0, -1, 0.0, -2, 1, 0.0, -19, -19, -13, -13, 0.0, 0.0, 0.0, -2, 0.0, 0.0, 0.0, 0.0, 0.0, -2, 0.0, 1, -15, -15, -10.0, -10.0, 0.0, 0.0, 0.0, 1, -15, -15, -10.0, -10.0, 0.0, 0.0, 0.0, 1};
@@ -114,41 +114,41 @@ test_decompile_cvar ()
{
if (i < 23)
{
assert (tuple_variations.tuple_vars[0].indices[i] == 0);
assert (tuple_variations.tuple_vars[1].indices[i] == 0);
hb_always_assert (tuple_variations.tuple_vars[0].indices[i] == 0);
hb_always_assert (tuple_variations.tuple_vars[1].indices[i] == 0);
}
else
{
assert (tuple_variations.tuple_vars[0].indices[i] == 1);
assert (tuple_variations.tuple_vars[1].indices[i] == 1);
assert (roundf (tuple_variations.tuple_vars[0].deltas_x[i]) == rounded_deltas_1[i]);
assert (roundf (tuple_variations.tuple_vars[1].deltas_x[i]) == rounded_deltas_2[i]);
hb_always_assert (tuple_variations.tuple_vars[0].indices[i] == 1);
hb_always_assert (tuple_variations.tuple_vars[1].indices[i] == 1);
hb_always_assert (roundf (tuple_variations.tuple_vars[0].deltas_x[i]) == rounded_deltas_1[i]);
hb_always_assert (roundf (tuple_variations.tuple_vars[1].deltas_x[i]) == rounded_deltas_2[i]);
}
}
hb_map_t axes_index_map;
axes_index_map.set (0, 0);
bool res = tuple_variations.compile_bytes (axes_index_map, axis_idx_tag_map, false);
assert (res);
assert (tuple_variations.tuple_vars[0].compiled_tuple_header.length == 6);
hb_always_assert (res);
hb_always_assert (tuple_variations.tuple_vars[0].compiled_tuple_header.length == 6);
const unsigned char tuple_var_header_1[] = "\x0\x51\xa0\x0\xc0\x0";
for (unsigned i = 0; i < 6; i++)
assert(tuple_variations.tuple_vars[0].compiled_tuple_header.arrayZ[i] == tuple_var_header_1[i]);
hb_always_assert(tuple_variations.tuple_vars[0].compiled_tuple_header.arrayZ[i] == tuple_var_header_1[i]);
assert (tuple_variations.tuple_vars[1].compiled_tuple_header.length == 6);
hb_always_assert (tuple_variations.tuple_vars[1].compiled_tuple_header.length == 6);
const unsigned char tuple_var_header_2[] = "\x0\x54\xa0\x0\x40\x0";
for (unsigned i = 0; i < 6; i++)
assert(tuple_variations.tuple_vars[1].compiled_tuple_header.arrayZ[i] == tuple_var_header_2[i]);
hb_always_assert(tuple_variations.tuple_vars[1].compiled_tuple_header.arrayZ[i] == tuple_var_header_2[i]);
assert (tuple_variations.tuple_vars[0].compiled_deltas.length == 37);
assert (tuple_variations.tuple_vars[1].compiled_deltas.length == 40);
hb_always_assert (tuple_variations.tuple_vars[0].compiled_deltas.length == 37);
hb_always_assert (tuple_variations.tuple_vars[1].compiled_deltas.length == 40);
const unsigned char compiled_deltas_1[] = "\x0d\xff\x00\xfe\x01\x00\xff\x00\xfe\x01\x00\xed\xed\xf3\xf3\x82\x00\xfe\x84\x06\xfe\x00\x01\xf1\xf1\xf6\xf6\x82\x04\x01\xf1\xf1\xf6\xf6\x82\x00\x01";
for (unsigned i = 0; i < 37; i++)
assert (tuple_variations.tuple_vars[0].compiled_deltas.arrayZ[i] == compiled_deltas_1[i]);
hb_always_assert (tuple_variations.tuple_vars[0].compiled_deltas.arrayZ[i] == compiled_deltas_1[i]);
const unsigned char compiled_deltas_2[] = "\x0d\x01\x00\x04\xfe\x00\x01\x00\x04\xfe\x00\x44\x44\x30\x30\x82\x00\x04\x81\x09\x01\xff\x01\x05\xff\xfc\x33\x33\x25\x25\x82\x04\xff\x33\x33\x25\x25\x82\x00\xff";
for (unsigned i = 0; i < 40; i++)
assert (tuple_variations.tuple_vars[1].compiled_deltas.arrayZ[i] == compiled_deltas_2[i]);
hb_always_assert (tuple_variations.tuple_vars[1].compiled_deltas.arrayZ[i] == compiled_deltas_2[i]);
}
int
+46 -46
View File
@@ -33,19 +33,19 @@
int
main (int argc, char **argv)
{
assert (sizeof (hb_vector_t<int>) == sizeof (hb_sorted_vector_t<int>));
hb_always_assert (sizeof (hb_vector_t<int>) == sizeof (hb_sorted_vector_t<int>));
/* Test copy constructor. */
{
hb_vector_t<int> v1 {1, 2};
hb_vector_t<int> v2 {v1};
hb_vector_t<int> V2 {v1};
assert (v1.length == 2);
assert (v1[0] == 1);
assert (v1[1] == 2);
assert (v2.length == 2);
assert (v2[0] == 1);
assert (v2[1] == 2);
hb_always_assert (v1.length == 2);
hb_always_assert (v1[0] == 1);
hb_always_assert (v1[1] == 2);
hb_always_assert (v2.length == 2);
hb_always_assert (v2[0] == 1);
hb_always_assert (v2[1] == 2);
}
/* Test copy assignment. */
@@ -53,12 +53,12 @@ main (int argc, char **argv)
hb_vector_t<int> v1 {1, 2};
hb_vector_t<int> v2 = v1;
hb_vector_t<int> V2 = v1;
assert (v1.length == 2);
assert (v1[0] == 1);
assert (v1[1] == 2);
assert (v2.length == 2);
assert (v2[0] == 1);
assert (v2[1] == 2);
hb_always_assert (v1.length == 2);
hb_always_assert (v1[0] == 1);
hb_always_assert (v1[1] == 2);
hb_always_assert (v2.length == 2);
hb_always_assert (v2[0] == 1);
hb_always_assert (v2[1] == 2);
}
/* Test move constructor. */
@@ -67,11 +67,11 @@ main (int argc, char **argv)
hb_sorted_vector_t<int> S {1, 2};
hb_vector_t<int> v (std::move (s));
hb_sorted_vector_t<int> V (std::move (S));
assert (s.length == 0);
assert (S.length == 0);
assert (v.length == 2);
assert (v[0] == 1);
assert (v[1] == 2);
hb_always_assert (s.length == 0);
hb_always_assert (S.length == 0);
hb_always_assert (v.length == 2);
hb_always_assert (v[0] == 1);
hb_always_assert (v[1] == 2);
}
/* Test move assignment. */
@@ -82,12 +82,12 @@ main (int argc, char **argv)
hb_sorted_vector_t<int> V;
v = std::move (s);
V = std::move (S);
assert (s.length == 0);
assert (S.length == 0);
assert (v.length == 2);
assert (V.length == 2);
assert (v[0] == 1);
assert (v[1] == 2);
hb_always_assert (s.length == 0);
hb_always_assert (S.length == 0);
hb_always_assert (v.length == 2);
hb_always_assert (V.length == 2);
hb_always_assert (v[0] == 1);
hb_always_assert (v[1] == 2);
}
/* Test initializing from iterable. */
@@ -100,12 +100,12 @@ main (int argc, char **argv)
hb_vector_t<int> v (s);
hb_sorted_vector_t<int> V (s);
assert (v.length == 2);
assert (V.length == 2);
assert (v[0] == 12);
assert (V[0] == 12);
assert (v[1] == 18);
assert (V[1] == 18);
hb_always_assert (v.length == 2);
hb_always_assert (V.length == 2);
hb_always_assert (v[0] == 12);
hb_always_assert (V[0] == 12);
hb_always_assert (v[1] == 18);
hb_always_assert (V[1] == 18);
}
/* Test initializing from iterator. */
@@ -118,12 +118,12 @@ main (int argc, char **argv)
hb_vector_t<int> v (hb_iter (s));
hb_vector_t<int> V (hb_iter (s));
assert (v.length == 2);
assert (V.length == 2);
assert (v[0] == 12);
assert (V[0] == 12);
assert (v[1] == 18);
assert (V[1] == 18);
hb_always_assert (v.length == 2);
hb_always_assert (V.length == 2);
hb_always_assert (v[0] == 12);
hb_always_assert (V[0] == 12);
hb_always_assert (v[1] == 18);
hb_always_assert (V[1] == 18);
}
/* Test initializing from initializer list and swapping. */
@@ -131,10 +131,10 @@ main (int argc, char **argv)
hb_vector_t<int> v1 {1, 2, 3};
hb_vector_t<int> v2 {4, 5};
hb_swap (v1, v2);
assert (v1.length == 2);
assert (v1[0] == 4);
assert (v2.length == 3);
assert (v2[2] == 3);
hb_always_assert (v1.length == 2);
hb_always_assert (v1[0] == 4);
hb_always_assert (v2.length == 3);
hb_always_assert (v2[2] == 3);
}
/* Test initializing sorted-vector from initializer list and swapping. */
@@ -142,10 +142,10 @@ main (int argc, char **argv)
hb_sorted_vector_t<int> v1 {1, 2, 3};
hb_sorted_vector_t<int> v2 {4, 5};
hb_swap (v1, v2);
assert (v1.length == 2);
assert (v1[0] == 4);
assert (v2.length == 3);
assert (v2[2] == 3);
hb_always_assert (v1.length == 2);
hb_always_assert (v1[0] == 4);
hb_always_assert (v2.length == 3);
hb_always_assert (v2[2] == 3);
}
{
@@ -171,9 +171,9 @@ main (int argc, char **argv)
hb_set_t s {1, 5, 7};
v.push (s);
v << s;
assert (s.get_population () == 3);
hb_always_assert (s.get_population () == 3);
v << std::move (s);
assert (s.get_population () == 0);
hb_always_assert (s.get_population () == 0);
}
{