From aadc7ccff1398177d4e2fd6cf505a3dafeac2fca Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Fri, 25 Jul 2025 02:18:15 -0600 Subject: [PATCH 1/4] [subset-table] Add a HB_UNUSED --- src/hb-subset-table.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hb-subset-table.hh b/src/hb-subset-table.hh index 7a10d6ef6..66588ec6f 100644 --- a/src/hb-subset-table.hh +++ b/src/hb-subset-table.hh @@ -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 ()) From 2dc0b070e8f640145e48c8254d0aed8b9a787e02 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Fri, 25 Jul 2025 02:20:50 -0600 Subject: [PATCH 2/4] [test] Mark a couple functions as unused Under NDEBUG. --- src/graph/test-classdef-graph.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/graph/test-classdef-graph.cc b/src/graph/test-classdef-graph.cc index 2da934811..b050093a7 100644 --- a/src/graph/test-classdef-graph.cc +++ b/src/graph/test-classdef-graph.cc @@ -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 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 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 ()); From 75f919876fa46194bcce8112f2b5f06987c40da3 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Fri, 25 Jul 2025 02:39:47 -0600 Subject: [PATCH 3/4] [src/test-*] Use hb_always_assert() which isn't compiled out under NDEBUG Part of https://github.com/harfbuzz/harfbuzz/issues/5418 --- src/graph/test-classdef-graph.cc | 58 ++--- src/hb.hh | 9 + src/meson.build | 1 - src/test-algs.cc | 46 ++-- src/test-array.cc | 8 +- src/test-bimap.cc | 54 ++--- src/test-buffer-serialize.cc | 2 +- src/test-cff.cc | 4 +- src/test-decycler.cc | 6 +- src/test-gpos-size-params.cc | 2 +- src/test-gsub-would-substitute.cc | 2 +- src/test-item-varstore.cc | 8 +- src/test-iter.cc | 96 ++++---- src/test-map.cc | 118 +++++----- src/test-multimap.cc | 32 +-- src/test-number.cc | 138 +++++------ src/test-ot-glyphname.cc | 2 +- src/test-ot-meta.cc | 2 +- src/test-ot-name.cc | 2 +- src/test-priority-queue.cc | 22 +- src/test-repacker.cc | 234 +++++++++---------- src/test-serialize.cc | 2 +- src/test-set.cc | 80 +++---- src/test-subset-instancer-solver.cc | 340 ++++++++++++++-------------- src/test-tuple-varstore.cc | 72 +++--- src/test-vector.cc | 92 ++++---- 26 files changed, 720 insertions(+), 712 deletions(-) diff --git a/src/graph/test-classdef-graph.cc b/src/graph/test-classdef-graph.cc index b050093a7..d3e8d892b 100644 --- a/src/graph/test-classdef-graph.cc +++ b/src/graph/test-classdef-graph.cc @@ -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); @@ -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 diff --git a/src/hb.hh b/src/hb.hh index 89e9df6ff..128f2fcd5 100644 --- a/src/hb.hh +++ b/src/hb.hh @@ -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 */ diff --git a/src/meson.build b/src/meson.build index 4ddaef8c2..531f151d2 100644 --- a/src/meson.build +++ b/src/meson.build @@ -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, ) diff --git a/src/test-algs.cc b/src/test-algs.cc index 450a7c439..0f25420ab 100644 --- a/src/test-algs.cc +++ b/src/test-algs.cc @@ -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 xp = hb_pair_t (nullptr, 0); xp = hb_pair_t (nullptr, 1); xp = hb_pair_t (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_reference (&set1)})); - assert (hb_hash (set1) == hb_hash (hb::unique_ptr {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_reference (&set1)})); + hb_always_assert (hb_hash (set1) == hb_hash (hb::unique_ptr {hb_set_reference (&set1)})); return 0; } diff --git a/src/test-array.cc b/src/test-array.cc index 28cd02364..2e2714722 100644 --- a/src/test-array.cc +++ b/src/test-array.cc @@ -36,7 +36,7 @@ test_reverse () int expected_values[] = {9, 8, 7, 6, 5, 4, 3, 2, 1}; hb_array_t 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 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 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) == sizeof (hb_sorted_array_t)); + // hb_always_assert (sizeof (hb_array_t) == sizeof (hb_sorted_array_t)); test_reverse (); test_reverse_range (); diff --git a/src/test-bimap.cc b/src/test-bimap.cc index 1253d0c1d..a80f44bb3 100644 --- a/src/test-bimap.cc +++ b/src/test-bimap.cc @@ -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; } diff --git a/src/test-buffer-serialize.cc b/src/test-buffer-serialize.cc index 421e5da68..87d364bf0 100644 --- a/src/test-buffer-serialize.cc +++ b/src/test-buffer-serialize.cc @@ -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; diff --git a/src/test-cff.cc b/src/test-cff.cc index 38ddba3c4..6127cfb2c 100644 --- a/src/test-cff.cc +++ b/src/test-cff.cc @@ -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 (); } } diff --git a/src/test-decycler.cc b/src/test-decycler.cc index dbe0f24f2..c1afcb8ae 100644 --- a/src/test-decycler.cc +++ b/src/test-decycler.cc @@ -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); diff --git a/src/test-gpos-size-params.cc b/src/test-gpos-size-params.cc index b96381ddc..87dc54a7a 100644 --- a/src/test-gpos-size-params.cc +++ b/src/test-gpos-size-params.cc @@ -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; diff --git a/src/test-gsub-would-substitute.cc b/src/test-gsub-would-substitute.cc index 87123030e..b3e67fde7 100644 --- a/src/test-gsub-would-substitute.cc +++ b/src/test-gsub-would-substitute.cc @@ -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; diff --git a/src/test-item-varstore.cc b/src/test-item-varstore.cc index bf0a10043..3e2cae708 100644 --- a/src/test-item-varstore.cc +++ b/src/test-item-varstore.cc @@ -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 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 diff --git a/src/test-iter.cc b/src/test-iter.cc index bb966d4c9..be50ad9fb 100644 --- a/src/test-iter.cc +++ b/src/test-iter.cc @@ -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 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> 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 (); diff --git a/src/test-map.cc b/src/test-map.cc index cb722eb92..a68da8c82 100644 --- a/src/test-map.cc +++ b/src/test-map.cc @@ -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 m1; hb_hashmap_t m2; hb_hashmap_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 {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 m1; vector_t v {3}; - assert (v.length == 1); + hb_always_assert (v.length == 1); m1 << hb_pair_t {vector_t {3}, v}; - assert (v.length == 1); + hb_always_assert (v.length == 1); m1 << hb_pair_t {vector_t {4}, std::move (v)}; - assert (v.length == 0); + hb_always_assert (v.length == 0); m1 << hb_pair_t {vector_t {4}, vector_t {5}}; m1 << hb_pair_t {vector_t {4}, vector_t {5}}; hb_hashmap_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 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; diff --git a/src/test-multimap.cc b/src/test-multimap.cc index 8cd8f5285..d3b843645 100644 --- a/src/test-multimap.cc +++ b/src/test-multimap.cc @@ -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; } diff --git a/src/test-number.cc b/src/test-number.cc index 57835288c..8a114c90f 100644 --- a/src/test-number.cc +++ b/src/test-number.cc @@ -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; diff --git a/src/test-ot-glyphname.cc b/src/test-ot-glyphname.cc index ec6e149a5..265656898 100644 --- a/src/test-ot-glyphname.cc +++ b/src/test-ot-glyphname.cc @@ -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); diff --git a/src/test-ot-meta.cc b/src/test-ot-meta.cc index 6daacc47d..f538fecfe 100644 --- a/src/test-ot-meta.cc +++ b/src/test-ot-meta.cc @@ -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; diff --git a/src/test-ot-name.cc b/src/test-ot-name.cc index bfa654a7c..50f38aa9b 100644 --- a/src/test-ot-name.cc +++ b/src/test-ot-name.cc @@ -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; diff --git a/src/test-priority-queue.cc b/src/test-priority-queue.cc index 67ee5ee4c..f4fd5e9ff 100644 --- a/src/test-priority-queue.cc +++ b/src/test-priority-queue.cc @@ -31,23 +31,23 @@ static void test_insert () { hb_priority_queue_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 diff --git a/src/test-repacker.cc b/src/test-repacker.cc index 51256b9e0..e157d4e49 100644 --- a/src/test-repacker.cc +++ b/src/test-repacker.cc @@ -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); diff --git a/src/test-serialize.cc b/src/test-serialize.cc index 4c90abb11..d148660ec 100644 --- a/src/test-serialize.cc +++ b/src/test-serialize.cc @@ -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; diff --git a/src/test-set.cc b/src/test-set.cc index 853aed406..70d3f6756 100644 --- a/src/test-set.cc +++ b/src/test-set.cc @@ -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; diff --git a/src/test-subset-instancer-solver.cc b/src/test-subset-instancer-solver.cc index 06b71bdc1..eba83ff51 100644 --- a/src/test-subset-instancer-solver.cc +++ b/src/test-subset-instancer-solver.cc @@ -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))); } } diff --git a/src/test-tuple-varstore.cc b/src/test-tuple-varstore.cc index 9fdbacafa..cef04ab7e 100644 --- a/src/test-tuple-varstore.cc +++ b/src/test-tuple-varstore.cc @@ -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 (), 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 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 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 diff --git a/src/test-vector.cc b/src/test-vector.cc index cc8ceabd1..1f6dc8252 100644 --- a/src/test-vector.cc +++ b/src/test-vector.cc @@ -33,19 +33,19 @@ int main (int argc, char **argv) { - assert (sizeof (hb_vector_t) == sizeof (hb_sorted_vector_t)); + hb_always_assert (sizeof (hb_vector_t) == sizeof (hb_sorted_vector_t)); /* Test copy constructor. */ { hb_vector_t v1 {1, 2}; hb_vector_t v2 {v1}; hb_vector_t 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 v1 {1, 2}; hb_vector_t v2 = v1; hb_vector_t 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 S {1, 2}; hb_vector_t v (std::move (s)); hb_sorted_vector_t 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 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 v (s); hb_sorted_vector_t 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 v (hb_iter (s)); hb_vector_t 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 v1 {1, 2, 3}; hb_vector_t 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 v1 {1, 2, 3}; hb_sorted_vector_t 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); } { From b87d866b35ab197355b7b0c9405664f537d1b636 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Fri, 25 Jul 2025 03:21:46 -0600 Subject: [PATCH 4/4] Fix HB_TINY `ninja -Cbuild libs` with experimental_api=true --- src/hb-buffer-deserialize-json.hh | 8 ++++---- src/hb-buffer-deserialize-text-glyphs.hh | 10 +++++----- src/hb-shape.cc | 3 ++- src/hb-subset-table-cff.cc | 4 +++- 4 files changed, 14 insertions(+), 11 deletions(-) diff --git a/src/hb-buffer-deserialize-json.hh b/src/hb-buffer-deserialize-json.hh index e57b6163c..75a1a1129 100644 --- a/src/hb-buffer-deserialize-json.hh +++ b/src/hb-buffer-deserialize-json.hh @@ -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: diff --git a/src/hb-buffer-deserialize-text-glyphs.hh b/src/hb-buffer-deserialize-text-glyphs.hh index 8fc54b36c..8c0353b3b 100644 --- a/src/hb-buffer-deserialize-text-glyphs.hh +++ b/src/hb-buffer-deserialize-text-glyphs.hh @@ -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" } } diff --git a/src/hb-shape.cc b/src/hb-shape.cc index c62f8c6bc..db46e110c 100644 --- a/src/hb-shape.cc +++ b/src/hb-shape.cc @@ -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 diff --git a/src/hb-subset-table-cff.cc b/src/hb-subset-table-cff.cc index 34c93a15e..3984cfb86 100644 --- a/src/hb-subset-table-cff.cc +++ b/src/hb-subset-table-cff.cc @@ -40,6 +40,7 @@ bool _hb_subset_table_cff (hb_subset_plan_t *plan, hb_vector_t &buf, hb_t #ifdef HB_EXPERIMENTAL_API +#ifndef HB_NO_CFF template 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