mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-21 15:01:01 +01:00
Merge pull request #5419 from harfbuzz/tiny-fix
Fix build with `-DNDEBUG`
This commit is contained in:
31 files changed
+739
-728
No files matched your search
@@ -38,7 +38,7 @@ static unsigned actual_class_def_size(It glyph_and_class) {
|
||||
hb_serialize_context_t serializer(buffer, 100);
|
||||
OT::ClassDef_serialize (&serializer, glyph_and_class);
|
||||
serializer.end_serialize ();
|
||||
assert(!serializer.in_error());
|
||||
hb_always_assert(!serializer.in_error());
|
||||
|
||||
hb_blob_t* blob = serializer.copy_blob();
|
||||
unsigned size = hb_blob_get_length(blob);
|
||||
@@ -66,7 +66,7 @@ static unsigned actual_coverage_size(It glyphs) {
|
||||
hb_serialize_context_t serializer(buffer, 100);
|
||||
OT::Layout::Common::Coverage_serialize (&serializer, glyphs);
|
||||
serializer.end_serialize ();
|
||||
assert(!serializer.in_error());
|
||||
hb_always_assert(!serializer.in_error());
|
||||
|
||||
hb_blob_t* blob = serializer.copy_blob();
|
||||
unsigned size = hb_blob_get_length(blob);
|
||||
@@ -101,9 +101,9 @@ static bool check_coverage_size(graph::class_def_size_estimator_t& estimator,
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool check_add_class_def_size(graph::class_def_size_estimator_t& estimator,
|
||||
const gid_and_class_list_t& map,
|
||||
unsigned klass, hb_vector_t<unsigned> klasses)
|
||||
static HB_UNUSED bool check_add_class_def_size(graph::class_def_size_estimator_t& estimator,
|
||||
const gid_and_class_list_t& map,
|
||||
unsigned klass, hb_vector_t<unsigned> klasses)
|
||||
{
|
||||
unsigned result = estimator.add_class_def_size(klass);
|
||||
unsigned expected = actual_class_def_size(map, klasses);
|
||||
@@ -115,7 +115,7 @@ static bool check_add_class_def_size(graph::class_def_size_estimator_t& estimato
|
||||
return check_coverage_size(estimator, map, klasses);
|
||||
}
|
||||
|
||||
static bool check_add_class_def_size (const gid_and_class_list_t& list, unsigned klass)
|
||||
static HB_UNUSED bool check_add_class_def_size (const gid_and_class_list_t& list, unsigned klass)
|
||||
{
|
||||
graph::class_def_size_estimator_t estimator (list.iter ());
|
||||
|
||||
@@ -149,13 +149,13 @@ static void test_class_and_coverage_size_estimates ()
|
||||
{
|
||||
gid_and_class_list_t empty = {
|
||||
};
|
||||
assert (check_add_class_def_size (empty, 0));
|
||||
assert (check_add_class_def_size (empty, 1));
|
||||
hb_always_assert (check_add_class_def_size (empty, 0));
|
||||
hb_always_assert (check_add_class_def_size (empty, 1));
|
||||
|
||||
gid_and_class_list_t class_zero = {
|
||||
{5, 0},
|
||||
};
|
||||
assert (check_add_class_def_size (class_zero, 0));
|
||||
hb_always_assert (check_add_class_def_size (class_zero, 0));
|
||||
|
||||
gid_and_class_list_t consecutive = {
|
||||
{4, 0},
|
||||
@@ -169,9 +169,9 @@ static void test_class_and_coverage_size_estimates ()
|
||||
{10, 2},
|
||||
{11, 2},
|
||||
};
|
||||
assert (check_add_class_def_size (consecutive, 0));
|
||||
assert (check_add_class_def_size (consecutive, 1));
|
||||
assert (check_add_class_def_size (consecutive, 2));
|
||||
hb_always_assert (check_add_class_def_size (consecutive, 0));
|
||||
hb_always_assert (check_add_class_def_size (consecutive, 1));
|
||||
hb_always_assert (check_add_class_def_size (consecutive, 2));
|
||||
|
||||
gid_and_class_list_t non_consecutive = {
|
||||
{4, 0},
|
||||
@@ -185,9 +185,9 @@ static void test_class_and_coverage_size_estimates ()
|
||||
{11, 2},
|
||||
{13, 2},
|
||||
};
|
||||
assert (check_add_class_def_size (non_consecutive, 0));
|
||||
assert (check_add_class_def_size (non_consecutive, 1));
|
||||
assert (check_add_class_def_size (non_consecutive, 2));
|
||||
hb_always_assert (check_add_class_def_size (non_consecutive, 0));
|
||||
hb_always_assert (check_add_class_def_size (non_consecutive, 1));
|
||||
hb_always_assert (check_add_class_def_size (non_consecutive, 2));
|
||||
|
||||
gid_and_class_list_t multiple_ranges = {
|
||||
{4, 0},
|
||||
@@ -202,8 +202,8 @@ static void test_class_and_coverage_size_estimates ()
|
||||
{12, 1},
|
||||
{13, 1},
|
||||
};
|
||||
assert (check_add_class_def_size (multiple_ranges, 0));
|
||||
assert (check_add_class_def_size (multiple_ranges, 1));
|
||||
hb_always_assert (check_add_class_def_size (multiple_ranges, 0));
|
||||
hb_always_assert (check_add_class_def_size (multiple_ranges, 1));
|
||||
}
|
||||
|
||||
static void test_running_class_and_coverage_size_estimates () {
|
||||
@@ -229,14 +229,14 @@ static void test_running_class_and_coverage_size_estimates () {
|
||||
};
|
||||
|
||||
graph::class_def_size_estimator_t estimator1(consecutive_map.iter());
|
||||
assert(check_add_class_def_size(estimator1, consecutive_map, 1, {1}));
|
||||
assert(check_add_class_def_size(estimator1, consecutive_map, 2, {1, 2}));
|
||||
assert(check_add_class_def_size(estimator1, consecutive_map, 2, {1, 2})); // check that adding the same class again works
|
||||
assert(check_add_class_def_size(estimator1, consecutive_map, 3, {1, 2, 3}));
|
||||
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 1, {1}));
|
||||
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 2, {1, 2}));
|
||||
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 2, {1, 2})); // check that adding the same class again works
|
||||
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 3, {1, 2, 3}));
|
||||
|
||||
estimator1.reset();
|
||||
assert(check_add_class_def_size(estimator1, consecutive_map, 2, {2}));
|
||||
assert(check_add_class_def_size(estimator1, consecutive_map, 3, {2, 3}));
|
||||
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 2, {2}));
|
||||
hb_always_assert(check_add_class_def_size(estimator1, consecutive_map, 3, {2, 3}));
|
||||
|
||||
// #### With non-consecutive gids: always uses format 2 ###
|
||||
gid_and_class_list_t non_consecutive_map = {
|
||||
@@ -261,13 +261,13 @@ static void test_running_class_and_coverage_size_estimates () {
|
||||
};
|
||||
|
||||
graph::class_def_size_estimator_t estimator2(non_consecutive_map.iter());
|
||||
assert(check_add_class_def_size(estimator2, non_consecutive_map, 1, {1}));
|
||||
assert(check_add_class_def_size(estimator2, non_consecutive_map, 2, {1, 2}));
|
||||
assert(check_add_class_def_size(estimator2, non_consecutive_map, 3, {1, 2, 3}));
|
||||
hb_always_assert(check_add_class_def_size(estimator2, non_consecutive_map, 1, {1}));
|
||||
hb_always_assert(check_add_class_def_size(estimator2, non_consecutive_map, 2, {1, 2}));
|
||||
hb_always_assert(check_add_class_def_size(estimator2, non_consecutive_map, 3, {1, 2, 3}));
|
||||
|
||||
estimator2.reset();
|
||||
assert(check_add_class_def_size(estimator2, non_consecutive_map, 2, {2}));
|
||||
assert(check_add_class_def_size(estimator2, non_consecutive_map, 3, {2, 3}));
|
||||
hb_always_assert(check_add_class_def_size(estimator2, non_consecutive_map, 2, {2}));
|
||||
hb_always_assert(check_add_class_def_size(estimator2, non_consecutive_map, 3, {2, 3}));
|
||||
}
|
||||
|
||||
static void test_running_class_size_estimates_with_locally_consecutive_glyphs () {
|
||||
@@ -278,13 +278,13 @@ static void test_running_class_size_estimates_with_locally_consecutive_glyphs ()
|
||||
};
|
||||
|
||||
graph::class_def_size_estimator_t estimator(map.iter());
|
||||
assert(check_add_class_def_size(estimator, map, 1, {1}));
|
||||
assert(check_add_class_def_size(estimator, map, 2, {1, 2}));
|
||||
assert(check_add_class_def_size(estimator, map, 3, {1, 2, 3}));
|
||||
hb_always_assert(check_add_class_def_size(estimator, map, 1, {1}));
|
||||
hb_always_assert(check_add_class_def_size(estimator, map, 2, {1, 2}));
|
||||
hb_always_assert(check_add_class_def_size(estimator, map, 3, {1, 2, 3}));
|
||||
|
||||
estimator.reset();
|
||||
assert(check_add_class_def_size(estimator, map, 2, {2}));
|
||||
assert(check_add_class_def_size(estimator, map, 3, {2, 3}));
|
||||
hb_always_assert(check_add_class_def_size(estimator, map, 2, {2}));
|
||||
hb_always_assert(check_add_class_def_size(estimator, map, 3, {2, 3}));
|
||||
}
|
||||
|
||||
int
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -32,7 +32,7 @@
|
||||
#include "hb.hh"
|
||||
|
||||
|
||||
#line 33 "hb-buffer-deserialize-text-glyphs.hh"
|
||||
#line 36 "hb-buffer-deserialize-text-glyphs.hh"
|
||||
static const unsigned char _deserialize_text_glyphs_trans_keys[] = {
|
||||
0u, 0u, 35u, 124u, 48u, 57u, 60u, 124u, 45u, 57u, 48u, 57u, 44u, 44u, 45u, 57u,
|
||||
48u, 57u, 44u, 44u, 45u, 57u, 48u, 57u, 44u, 44u, 45u, 57u, 48u, 57u, 62u, 62u,
|
||||
@@ -389,12 +389,12 @@ _hb_buffer_deserialize_text_glyphs (hb_buffer_t *buffer,
|
||||
hb_glyph_info_t info = {0};
|
||||
hb_glyph_position_t pos = {0};
|
||||
|
||||
#line 386 "hb-buffer-deserialize-text-glyphs.hh"
|
||||
#line 393 "hb-buffer-deserialize-text-glyphs.hh"
|
||||
{
|
||||
cs = deserialize_text_glyphs_start;
|
||||
}
|
||||
|
||||
#line 389 "hb-buffer-deserialize-text-glyphs.hh"
|
||||
#line 398 "hb-buffer-deserialize-text-glyphs.hh"
|
||||
{
|
||||
int _slen;
|
||||
int _trans;
|
||||
@@ -552,7 +552,7 @@ _resume:
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
#line 523 "hb-buffer-deserialize-text-glyphs.hh"
|
||||
#line 556 "hb-buffer-deserialize-text-glyphs.hh"
|
||||
}
|
||||
|
||||
_again:
|
||||
@@ -573,7 +573,7 @@ _again:
|
||||
*end_ptr = p;
|
||||
}
|
||||
break;
|
||||
#line 542 "hb-buffer-deserialize-text-glyphs.hh"
|
||||
#line 577 "hb-buffer-deserialize-text-glyphs.hh"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+2
-1
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -40,6 +40,7 @@ bool _hb_subset_table_cff (hb_subset_plan_t *plan, hb_vector_t<char> &buf, hb_t
|
||||
|
||||
|
||||
#ifdef HB_EXPERIMENTAL_API
|
||||
#ifndef HB_NO_CFF
|
||||
|
||||
template<typename accel_t>
|
||||
static hb_blob_t* get_charstrings_data(accel_t& accel, hb_codepoint_t glyph_index) {
|
||||
@@ -111,7 +112,7 @@ HB_EXTERN hb_blob_t*
|
||||
hb_subset_cff_get_charstrings_index (hb_face_t* face) {
|
||||
return get_charstrings_index (*face->table.cff1);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* hb_subset_cff2_get_charstring_data:
|
||||
* @face: A face object
|
||||
@@ -139,3 +140,4 @@ hb_subset_cff2_get_charstrings_index (hb_face_t* face) {
|
||||
return get_charstrings_index (*face->table.cff2);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
@@ -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 ())
|
||||
|
||||
@@ -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 */
|
||||
@@ -767,7 +767,6 @@ if get_option('tests').enabled()
|
||||
foreach name, source : noinst_programs
|
||||
executable(name, source,
|
||||
include_directories: incconfig,
|
||||
cpp_args: cpp_args + ['-UNDEBUG'],
|
||||
dependencies: libharfbuzz_dep,
|
||||
install: false,
|
||||
)
|
||||
|
||||
+23
-23
@@ -47,24 +47,24 @@ main (int argc, char **argv)
|
||||
auto p = hb_pair (1, i);
|
||||
|
||||
p.second = 2;
|
||||
assert (i == 2);
|
||||
hb_always_assert (i == 2);
|
||||
|
||||
const int c = 3;
|
||||
auto pc = hb_pair (1, c);
|
||||
assert (pc.second == 3);
|
||||
hb_always_assert (pc.second == 3);
|
||||
|
||||
auto q = p;
|
||||
assert (&q != &p);
|
||||
hb_always_assert (&q != &p);
|
||||
q.second = 4;
|
||||
assert (i == 4);
|
||||
hb_always_assert (i == 4);
|
||||
|
||||
hb_invoke (test_func, 0, nullptr);
|
||||
|
||||
A a;
|
||||
hb_invoke (&A::a, a);
|
||||
|
||||
assert (1 == hb_min (8, 1));
|
||||
assert (8 == hb_max (8, 1));
|
||||
hb_always_assert (1 == hb_min (8, 1));
|
||||
hb_always_assert (8 == hb_max (8, 1));
|
||||
|
||||
int x = 1, y = 2;
|
||||
hb_min (x, 3);
|
||||
@@ -72,39 +72,39 @@ main (int argc, char **argv)
|
||||
hb_min (x, 4 + 3);
|
||||
int &z = hb_min (x, y);
|
||||
z = 3;
|
||||
assert (x == 3);
|
||||
hb_always_assert (x == 3);
|
||||
|
||||
hb_pair_t<const int*, int> xp = hb_pair_t<int *, long> (nullptr, 0);
|
||||
xp = hb_pair_t<int *, double> (nullptr, 1);
|
||||
xp = hb_pair_t<const int*, int> (nullptr, 1);
|
||||
|
||||
assert (3 == hb_partial (hb_min, 3) (4));
|
||||
assert (3 == hb_partial<1> (hb_min, 4) (3));
|
||||
hb_always_assert (3 == hb_partial (hb_min, 3) (4));
|
||||
hb_always_assert (3 == hb_partial<1> (hb_min, 4) (3));
|
||||
|
||||
auto M0 = hb_partial<2> (hb_max, 0);
|
||||
assert (M0 (-2) == 0);
|
||||
assert (M0 (+2) == 2);
|
||||
hb_always_assert (M0 (-2) == 0);
|
||||
hb_always_assert (M0 (+2) == 2);
|
||||
|
||||
assert (hb_add (2) (5) == 7);
|
||||
assert (hb_add (5) (2) == 7);
|
||||
hb_always_assert (hb_add (2) (5) == 7);
|
||||
hb_always_assert (hb_add (5) (2) == 7);
|
||||
|
||||
x = 1;
|
||||
assert (++hb_inc (x) == 3);
|
||||
assert (x == 3);
|
||||
hb_always_assert (++hb_inc (x) == 3);
|
||||
hb_always_assert (x == 3);
|
||||
|
||||
hb_set_t set1 {1};
|
||||
hb_set_t set2 {2};
|
||||
|
||||
assert (hb_hash (set1) != hb_hash (set2));
|
||||
assert (hb_hash (set1) == hb_hash (hb_set_t {1}));
|
||||
assert (hb_hash (set1) != hb_hash (hb_set_t {}));
|
||||
assert (hb_hash (set1) != hb_hash (hb_set_t {2}));
|
||||
assert (hb_hash (set2) == hb_hash (hb_set_t {2}));
|
||||
hb_always_assert (hb_hash (set1) != hb_hash (set2));
|
||||
hb_always_assert (hb_hash (set1) == hb_hash (hb_set_t {1}));
|
||||
hb_always_assert (hb_hash (set1) != hb_hash (hb_set_t {}));
|
||||
hb_always_assert (hb_hash (set1) != hb_hash (hb_set_t {2}));
|
||||
hb_always_assert (hb_hash (set2) == hb_hash (hb_set_t {2}));
|
||||
|
||||
/* hb_hash, unlike std::hash, dereferences pointers. */
|
||||
assert (hb_hash (set1) == hb_hash (&set1));
|
||||
assert (hb_hash (set1) == hb_hash (hb::shared_ptr<hb_set_t> {hb_set_reference (&set1)}));
|
||||
assert (hb_hash (set1) == hb_hash (hb::unique_ptr<hb_set_t> {hb_set_reference (&set1)}));
|
||||
hb_always_assert (hb_hash (set1) == hb_hash (&set1));
|
||||
hb_always_assert (hb_hash (set1) == hb_hash (hb::shared_ptr<hb_set_t> {hb_set_reference (&set1)}));
|
||||
hb_always_assert (hb_hash (set1) == hb_hash (hb::unique_ptr<hb_set_t> {hb_set_reference (&set1)}));
|
||||
|
||||
return 0;
|
||||
}
|
||||
+4
-4
@@ -36,7 +36,7 @@ test_reverse ()
|
||||
|
||||
int expected_values[] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
|
||||
hb_array_t<int> expected (expected_values, 9);
|
||||
assert (a == expected);
|
||||
hb_always_assert (a == expected);
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -48,7 +48,7 @@ test_reverse_range ()
|
||||
|
||||
int expected_values[] = {1, 2, 6, 5, 4, 3, 7, 8, 9};
|
||||
hb_array_t<int> expected (expected_values, 9);
|
||||
assert (a == expected);
|
||||
hb_always_assert (a == expected);
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -64,14 +64,14 @@ test_reverse_invalid ()
|
||||
|
||||
int expected_values[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
hb_array_t<int> expected (expected_values, 9);
|
||||
assert (a == expected);
|
||||
hb_always_assert (a == expected);
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
/* The following fails on MSVC. */
|
||||
// assert (sizeof (hb_array_t<int>) == sizeof (hb_sorted_array_t<int>));
|
||||
// hb_always_assert (sizeof (hb_array_t<int>) == sizeof (hb_sorted_array_t<int>));
|
||||
|
||||
test_reverse ();
|
||||
test_reverse_range ();
|
||||
|
||||
+27
-27
@@ -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;
|
||||
}
|
||||
@@ -64,7 +64,7 @@ main (int argc, char **argv)
|
||||
argv[1] = (char *) "/dev/null";
|
||||
|
||||
hb_blob_t *blob = hb_blob_create_from_file_or_fail (argv[1]);
|
||||
assert (blob);
|
||||
hb_always_assert (blob);
|
||||
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
|
||||
hb_blob_destroy (blob);
|
||||
blob = nullptr;
|
||||
|
||||
+2
-2
@@ -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 ();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -43,7 +43,7 @@ test_item_variations ()
|
||||
const OT::ItemVariationStore& src_var_store = hvar_table+(hvar_table->varStore);
|
||||
bool result = item_vars.create_from_item_varstore (src_var_store, axis_idx_tag_map);
|
||||
|
||||
assert (result);
|
||||
hb_always_assert (result);
|
||||
|
||||
/* partial instancing wght=300:800 */
|
||||
hb_hashmap_t<hb_tag_t, Triple> normalized_axes_location;
|
||||
@@ -53,10 +53,10 @@ test_item_variations ()
|
||||
axes_triple_distances.set (axis_tag, TripleDistances (200.0, 500.0));
|
||||
|
||||
result = item_vars.instantiate_tuple_vars (normalized_axes_location, axes_triple_distances);
|
||||
assert (result);
|
||||
hb_always_assert (result);
|
||||
result = item_vars.as_item_varstore (false);
|
||||
assert (result);
|
||||
assert (item_vars.get_region_list().length == 8);
|
||||
hb_always_assert (result);
|
||||
hb_always_assert (item_vars.get_region_list().length == 8);
|
||||
}
|
||||
|
||||
int
|
||||
|
||||
+48
-48
@@ -84,7 +84,7 @@ test_iterator_non_default_constructable (Iter it)
|
||||
it = it + 10;
|
||||
it = 10 + it;
|
||||
|
||||
assert (*it == it[0]);
|
||||
hb_always_assert (*it == it[0]);
|
||||
|
||||
static_assert (true || it.is_random_access_iterator, "");
|
||||
static_assert (true || it.is_sorted_iterator, "");
|
||||
@@ -96,7 +96,7 @@ static void
|
||||
test_iterator (Iter it)
|
||||
{
|
||||
Iter default_constructed;
|
||||
assert (!default_constructed);
|
||||
hb_always_assert (!default_constructed);
|
||||
|
||||
test_iterator_non_default_constructable (it);
|
||||
}
|
||||
@@ -118,7 +118,7 @@ static void check_sequential (It it)
|
||||
{
|
||||
int i = 1;
|
||||
for (int v : +it) {
|
||||
assert (v == i++);
|
||||
hb_always_assert (v == i++);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -131,16 +131,16 @@ static void test_concat ()
|
||||
hb_vector_t<int> d = {1, 2, 3, 4, 5};
|
||||
|
||||
auto it1 = hb_concat (a, b);
|
||||
assert (it1.len () == 5);
|
||||
assert (it1.is_random_access_iterator);
|
||||
hb_always_assert (it1.len () == 5);
|
||||
hb_always_assert (it1.is_random_access_iterator);
|
||||
auto it2 = hb_concat (c, d);
|
||||
assert (it2.len () == 5);
|
||||
hb_always_assert (it2.len () == 5);
|
||||
auto it3 = hb_concat (d, c);
|
||||
assert (it3.len () == 5);
|
||||
hb_always_assert (it3.len () == 5);
|
||||
for (int i = 0; i < 5; i++) {
|
||||
assert(it1[i] == i + 1);
|
||||
assert(it2[i] == i + 1);
|
||||
assert(it3[i] == i + 1);
|
||||
hb_always_assert(it1[i] == i + 1);
|
||||
hb_always_assert(it2[i] == i + 1);
|
||||
hb_always_assert(it3[i] == i + 1);
|
||||
}
|
||||
|
||||
check_sequential (it1);
|
||||
@@ -149,40 +149,40 @@ static void test_concat ()
|
||||
|
||||
auto it4 = +it1;
|
||||
it4 += 0;
|
||||
assert (*it4 == 1);
|
||||
hb_always_assert (*it4 == 1);
|
||||
|
||||
it4 += 2;
|
||||
assert (*it4 == 3);
|
||||
assert (it4);
|
||||
assert (it4.len () == 3);
|
||||
hb_always_assert (*it4 == 3);
|
||||
hb_always_assert (it4);
|
||||
hb_always_assert (it4.len () == 3);
|
||||
|
||||
it4 += 2;
|
||||
assert (*it4 == 5);
|
||||
assert (it4);
|
||||
assert (it4.len () == 1);
|
||||
hb_always_assert (*it4 == 5);
|
||||
hb_always_assert (it4);
|
||||
hb_always_assert (it4.len () == 1);
|
||||
|
||||
it4++;
|
||||
assert (!it4);
|
||||
assert (it4.len () == 0);
|
||||
hb_always_assert (!it4);
|
||||
hb_always_assert (it4.len () == 0);
|
||||
|
||||
auto it5 = +it1;
|
||||
it5 += 3;
|
||||
assert (*it5 == 4);
|
||||
hb_always_assert (*it5 == 4);
|
||||
|
||||
hb_set_t s_a = {1, 2, 3};
|
||||
hb_set_t s_b = {4, 5};
|
||||
auto it6 = hb_concat (s_a, s_b);
|
||||
assert (!it6.is_random_access_iterator);
|
||||
hb_always_assert (!it6.is_random_access_iterator);
|
||||
check_sequential (it6);
|
||||
assert (it6.len () == 5);
|
||||
hb_always_assert (it6.len () == 5);
|
||||
|
||||
it6 += 0;
|
||||
assert (*it6 == 1);
|
||||
hb_always_assert (*it6 == 1);
|
||||
|
||||
it6 += 3;
|
||||
assert (*it6 == 4);
|
||||
assert (it6);
|
||||
assert (it6.len () == 2);
|
||||
hb_always_assert (*it6 == 4);
|
||||
hb_always_assert (it6);
|
||||
hb_always_assert (it6.len () == 2);
|
||||
}
|
||||
|
||||
int
|
||||
@@ -235,16 +235,16 @@ main (int argc, char **argv)
|
||||
test_iterator_non_default_constructable (hb_iter (st) | hb_filter ());
|
||||
test_iterator_non_default_constructable (hb_iter (st) | hb_map (hb_lidentity));
|
||||
|
||||
assert (true == hb_all (st));
|
||||
assert (false == hb_all (st, 42u));
|
||||
assert (true == hb_any (st));
|
||||
assert (false == hb_any (st, 14u));
|
||||
assert (true == hb_any (st, 14u, [] (unsigned _) { return _ - 1u; }));
|
||||
assert (true == hb_any (st, [] (unsigned _) { return _ == 15u; }));
|
||||
assert (true == hb_any (st, 15u));
|
||||
assert (false == hb_none (st));
|
||||
assert (false == hb_none (st, 15u));
|
||||
assert (true == hb_none (st, 17u));
|
||||
hb_always_assert (true == hb_all (st));
|
||||
hb_always_assert (false == hb_all (st, 42u));
|
||||
hb_always_assert (true == hb_any (st));
|
||||
hb_always_assert (false == hb_any (st, 14u));
|
||||
hb_always_assert (true == hb_any (st, 14u, [] (unsigned _) { return _ - 1u; }));
|
||||
hb_always_assert (true == hb_any (st, [] (unsigned _) { return _ == 15u; }));
|
||||
hb_always_assert (true == hb_any (st, 15u));
|
||||
hb_always_assert (false == hb_none (st));
|
||||
hb_always_assert (false == hb_none (st, 15u));
|
||||
hb_always_assert (true == hb_none (st, 17u));
|
||||
|
||||
hb_array_t<hb_vector_t<int>> pa;
|
||||
pa->as_array ();
|
||||
@@ -318,7 +318,7 @@ main (int argc, char **argv)
|
||||
}, hb_map_create ())
|
||||
;
|
||||
/* The result should be something like 0->10, 1->11, ..., 9->19 */
|
||||
assert (hb_map_get (result, 9) == 19);
|
||||
hb_always_assert (hb_map_get (result, 9) == 19);
|
||||
hb_map_destroy (result);
|
||||
|
||||
/* Like above, but passing hb_set_t instead of hb_set_t * */
|
||||
@@ -341,7 +341,7 @@ main (int argc, char **argv)
|
||||
}, hb_map_create ())
|
||||
;
|
||||
/* The result should be something like 0->10, 1->11, ..., 9->19 */
|
||||
assert (hb_map_get (result, 9) == 19);
|
||||
hb_always_assert (hb_map_get (result, 9) == 19);
|
||||
hb_map_destroy (result);
|
||||
|
||||
unsigned int temp3 = 0;
|
||||
@@ -361,20 +361,20 @@ main (int argc, char **argv)
|
||||
hb_iota ();
|
||||
hb_iota (3);
|
||||
hb_iota (3, 2);
|
||||
assert ((&vl) + 1 == *++hb_iota (&vl, hb_inc));
|
||||
hb_always_assert ((&vl) + 1 == *++hb_iota (&vl, hb_inc));
|
||||
hb_range ();
|
||||
hb_repeat (7u);
|
||||
hb_repeat (nullptr);
|
||||
hb_repeat (vl) | hb_chop (3);
|
||||
assert (hb_len (hb_range (10) | hb_take (3)) == 3);
|
||||
assert (hb_range (9).len () == 9);
|
||||
assert (hb_range (2, 9).len () == 7);
|
||||
assert (hb_range (2, 9, 3).len () == 3);
|
||||
assert (hb_range (2, 8, 3).len () == 2);
|
||||
assert (hb_range (2, 7, 3).len () == 2);
|
||||
assert (hb_range (-2, -9, -3).len () == 3);
|
||||
assert (hb_range (-2, -8, -3).len () == 2);
|
||||
assert (hb_range (-2, -7, -3).len () == 2);
|
||||
hb_always_assert (hb_len (hb_range (10) | hb_take (3)) == 3);
|
||||
hb_always_assert (hb_range (9).len () == 9);
|
||||
hb_always_assert (hb_range (2, 9).len () == 7);
|
||||
hb_always_assert (hb_range (2, 9, 3).len () == 3);
|
||||
hb_always_assert (hb_range (2, 8, 3).len () == 2);
|
||||
hb_always_assert (hb_range (2, 7, 3).len () == 2);
|
||||
hb_always_assert (hb_range (-2, -9, -3).len () == 3);
|
||||
hb_always_assert (hb_range (-2, -8, -3).len () == 2);
|
||||
hb_always_assert (hb_range (-2, -7, -3).len () == 2);
|
||||
|
||||
test_concat ();
|
||||
|
||||
|
||||
+59
-59
@@ -36,10 +36,10 @@ main (int argc, char **argv)
|
||||
hb_map_t v1;
|
||||
v1.set (1, 2);
|
||||
hb_map_t v2 {v1};
|
||||
assert (v1.get_population () == 1);
|
||||
assert (v2.get_population () == 1);
|
||||
assert (v1[1] == 2);
|
||||
assert (v2[1] == 2);
|
||||
hb_always_assert (v1.get_population () == 1);
|
||||
hb_always_assert (v2.get_population () == 1);
|
||||
hb_always_assert (v1[1] == 2);
|
||||
hb_always_assert (v2[1] == 2);
|
||||
}
|
||||
|
||||
/* Test copy assignment. */
|
||||
@@ -47,10 +47,10 @@ main (int argc, char **argv)
|
||||
hb_map_t v1;
|
||||
v1.set (1, 2);
|
||||
hb_map_t v2 = v1;
|
||||
assert (v1.get_population () == 1);
|
||||
assert (v2.get_population () == 1);
|
||||
assert (v1[1] == 2);
|
||||
assert (v2[1] == 2);
|
||||
hb_always_assert (v1.get_population () == 1);
|
||||
hb_always_assert (v2.get_population () == 1);
|
||||
hb_always_assert (v1[1] == 2);
|
||||
hb_always_assert (v2[1] == 2);
|
||||
}
|
||||
|
||||
/* Test move constructor. */
|
||||
@@ -58,8 +58,8 @@ main (int argc, char **argv)
|
||||
hb_map_t s {};
|
||||
s.set (1, 2);
|
||||
hb_map_t v (std::move (s));
|
||||
assert (s.get_population () == 0);
|
||||
assert (v.get_population () == 1);
|
||||
hb_always_assert (s.get_population () == 0);
|
||||
hb_always_assert (v.get_population () == 1);
|
||||
}
|
||||
|
||||
/* Test move assignment. */
|
||||
@@ -68,8 +68,8 @@ main (int argc, char **argv)
|
||||
s.set (1, 2);
|
||||
hb_map_t v;
|
||||
v = std::move (s);
|
||||
assert (s.get_population () == 0);
|
||||
assert (v.get_population () == 1);
|
||||
hb_always_assert (s.get_population () == 0);
|
||||
hb_always_assert (v.get_population () == 1);
|
||||
}
|
||||
|
||||
/* Test initializing from iterable. */
|
||||
@@ -84,10 +84,10 @@ main (int argc, char **argv)
|
||||
hb_map_t v1 (s);
|
||||
hb_map_t v2 (std::move (s));
|
||||
|
||||
assert (s.get_population () == 0);
|
||||
assert (v0.get_population () == 2);
|
||||
assert (v1.get_population () == 2);
|
||||
assert (v2.get_population () == 2);
|
||||
hb_always_assert (s.get_population () == 0);
|
||||
hb_always_assert (v0.get_population () == 2);
|
||||
hb_always_assert (v1.get_population () == 2);
|
||||
hb_always_assert (v2.get_population () == 2);
|
||||
}
|
||||
|
||||
/* Test call fini() twice. */
|
||||
@@ -107,7 +107,7 @@ main (int argc, char **argv)
|
||||
|
||||
hb_map_t v (hb_iter (s));
|
||||
|
||||
assert (v.get_population () == 2);
|
||||
hb_always_assert (v.get_population () == 2);
|
||||
}
|
||||
|
||||
/* Test initializing from initializer list and swapping. */
|
||||
@@ -116,8 +116,8 @@ main (int argc, char **argv)
|
||||
hb_map_t v1 {pair_t{1,2}, pair_t{4,5}};
|
||||
hb_map_t v2 {pair_t{3,4}};
|
||||
hb_swap (v1, v2);
|
||||
assert (v1.get_population () == 1);
|
||||
assert (v2.get_population () == 2);
|
||||
hb_always_assert (v1.get_population () == 1);
|
||||
hb_always_assert (v2.get_population () == 2);
|
||||
}
|
||||
|
||||
/* Test class key / value types. */
|
||||
@@ -125,9 +125,9 @@ main (int argc, char **argv)
|
||||
hb_hashmap_t<hb_bytes_t, int> m1;
|
||||
hb_hashmap_t<int, hb_bytes_t> m2;
|
||||
hb_hashmap_t<hb_bytes_t, hb_bytes_t> m3;
|
||||
assert (m1.get_population () == 0);
|
||||
assert (m2.get_population () == 0);
|
||||
assert (m3.get_population () == 0);
|
||||
hb_always_assert (m1.get_population () == 0);
|
||||
hb_always_assert (m2.get_population () == 0);
|
||||
hb_always_assert (m3.get_population () == 0);
|
||||
}
|
||||
|
||||
{
|
||||
@@ -157,8 +157,8 @@ main (int argc, char **argv)
|
||||
m1.set (hb_map_t (), hb_map_t {pair (1u, 2u)});
|
||||
m1.set (hb_map_t {pair (1u, 2u)}, hb_map_t {pair (2u, 3u)});
|
||||
|
||||
assert (m1.get (hb_map_t ()) == hb_map_t {pair (1u, 2u)});
|
||||
assert (m1.get (hb_map_t {pair (1u, 2u)}) == hb_map_t {pair (2u, 3u)});
|
||||
hb_always_assert (m1.get (hb_map_t ()) == hb_map_t {pair (1u, 2u)});
|
||||
hb_always_assert (m1.get (hb_map_t {pair (1u, 2u)}) == hb_map_t {pair (2u, 3u)});
|
||||
}
|
||||
|
||||
/* Test hashing sets. */
|
||||
@@ -169,8 +169,8 @@ main (int argc, char **argv)
|
||||
m1.set (hb_set_t (), hb_set_t {1});
|
||||
m1.set (hb_set_t {1, 1000}, hb_set_t {2});
|
||||
|
||||
assert (m1.get (hb_set_t ()) == hb_set_t {1});
|
||||
assert (m1.get (hb_set_t {1000, 1}) == hb_set_t {2});
|
||||
hb_always_assert (m1.get (hb_set_t ()) == hb_set_t {1});
|
||||
hb_always_assert (m1.get (hb_set_t {1000, 1}) == hb_set_t {2});
|
||||
}
|
||||
|
||||
/* Test hashing vectors. */
|
||||
@@ -184,8 +184,8 @@ main (int argc, char **argv)
|
||||
|
||||
m1 << hb_pair_t<vector_t, vector_t> {vector_t {2}, vector_t ()};
|
||||
|
||||
assert (m1.get (vector_t ()) == vector_t {1});
|
||||
assert (m1.get (vector_t {1}) == vector_t {2});
|
||||
hb_always_assert (m1.get (vector_t ()) == vector_t {1});
|
||||
hb_always_assert (m1.get (vector_t {1}) == vector_t {2});
|
||||
}
|
||||
|
||||
/* Test moving values */
|
||||
@@ -194,20 +194,20 @@ main (int argc, char **argv)
|
||||
|
||||
hb_hashmap_t<vector_t, vector_t> m1;
|
||||
vector_t v {3};
|
||||
assert (v.length == 1);
|
||||
hb_always_assert (v.length == 1);
|
||||
m1 << hb_pair_t<vector_t, vector_t> {vector_t {3}, v};
|
||||
assert (v.length == 1);
|
||||
hb_always_assert (v.length == 1);
|
||||
m1 << hb_pair_t<vector_t, vector_t&&> {vector_t {4}, std::move (v)};
|
||||
assert (v.length == 0);
|
||||
hb_always_assert (v.length == 0);
|
||||
m1 << hb_pair_t<vector_t&&, vector_t> {vector_t {4}, vector_t {5}};
|
||||
m1 << hb_pair_t<vector_t&&, vector_t&&> {vector_t {4}, vector_t {5}};
|
||||
|
||||
hb_hashmap_t<vector_t, vector_t> m2;
|
||||
vector_t v2 {3};
|
||||
m2.set (vector_t {4}, v2);
|
||||
assert (v2.length == 1);
|
||||
hb_always_assert (v2.length == 1);
|
||||
m2.set (vector_t {5}, std::move (v2));
|
||||
assert (v2.length == 0);
|
||||
hb_always_assert (v2.length == 0);
|
||||
}
|
||||
|
||||
/* Test hb::shared_ptr. */
|
||||
@@ -250,10 +250,10 @@ main (int argc, char **argv)
|
||||
hb::shared_ptr<hb_map_t> p2 {m2};
|
||||
m.set (p1,1);
|
||||
|
||||
assert (m.has (p2));
|
||||
hb_always_assert (m.has (p2));
|
||||
|
||||
m1->set (2,4);
|
||||
assert (!m.has (p2));
|
||||
hb_always_assert (!m.has (p2));
|
||||
}
|
||||
/* Test value type with hb_bytes_t. */
|
||||
{
|
||||
@@ -262,8 +262,8 @@ main (int argc, char **argv)
|
||||
hb_bytes_t bytes (c_str);
|
||||
|
||||
m.set (1, bytes);
|
||||
assert (m.has (1));
|
||||
assert (m.get (1) == hb_bytes_t {"Test"});
|
||||
hb_always_assert (m.has (1));
|
||||
hb_always_assert (m.get (1) == hb_bytes_t {"Test"});
|
||||
}
|
||||
/* Test operators. */
|
||||
{
|
||||
@@ -275,16 +275,16 @@ main (int argc, char **argv)
|
||||
m3.set (1, 3);
|
||||
m3.set (3, 5);
|
||||
|
||||
assert (m1 == m2);
|
||||
assert (m1 != m3);
|
||||
assert (!(m2 == m3));
|
||||
hb_always_assert (m1 == m2);
|
||||
hb_always_assert (m1 != m3);
|
||||
hb_always_assert (!(m2 == m3));
|
||||
|
||||
m2 = m3;
|
||||
assert (m2.has (1));
|
||||
assert (!m2.has (2));
|
||||
assert (m2.has (3));
|
||||
hb_always_assert (m2.has (1));
|
||||
hb_always_assert (!m2.has (2));
|
||||
hb_always_assert (m2.has (3));
|
||||
|
||||
assert (m3.has (3));
|
||||
hb_always_assert (m3.has (3));
|
||||
}
|
||||
/* Test reset. */
|
||||
{
|
||||
@@ -309,15 +309,15 @@ main (int argc, char **argv)
|
||||
m.next (&i, &k, &v);)
|
||||
{
|
||||
pop++;
|
||||
if (k == 1) assert (v == 1);
|
||||
else if (k == 2) assert (v == 1);
|
||||
else if (k == 3) assert (v == 2);
|
||||
else if (k == 4) assert (v == 3);
|
||||
else if (k == 5) assert (v == 5);
|
||||
else if (k == 6) assert (v == 8);
|
||||
else assert (false);
|
||||
if (k == 1) hb_always_assert (v == 1);
|
||||
else if (k == 2) hb_always_assert (v == 1);
|
||||
else if (k == 3) hb_always_assert (v == 2);
|
||||
else if (k == 4) hb_always_assert (v == 3);
|
||||
else if (k == 5) hb_always_assert (v == 5);
|
||||
else if (k == 6) hb_always_assert (v == 8);
|
||||
else hb_always_assert (false);
|
||||
}
|
||||
assert (pop == m.get_population ());
|
||||
hb_always_assert (pop == m.get_population ());
|
||||
}
|
||||
/* Test update */
|
||||
{
|
||||
@@ -327,9 +327,9 @@ main (int argc, char **argv)
|
||||
m2.set (1, 3);
|
||||
|
||||
m1.update (m2);
|
||||
assert (m1.get_population () == 2);
|
||||
assert (m1[1] == 3);
|
||||
assert (m1[2] == 4);
|
||||
hb_always_assert (m1.get_population () == 2);
|
||||
hb_always_assert (m1[1] == 3);
|
||||
hb_always_assert (m1[2] == 4);
|
||||
}
|
||||
/* Test keys / values */
|
||||
{
|
||||
@@ -347,11 +347,11 @@ main (int argc, char **argv)
|
||||
hb_copy (m.keys (), keys);
|
||||
hb_copy (m.values (), values);
|
||||
|
||||
assert (keys.is_equal (hb_set_t ({1, 2, 3, 4, 5, 6})));
|
||||
assert (values.is_equal (hb_set_t ({1, 1, 2, 3, 5, 8})));
|
||||
hb_always_assert (keys.is_equal (hb_set_t ({1, 2, 3, 4, 5, 6})));
|
||||
hb_always_assert (values.is_equal (hb_set_t ({1, 1, 2, 3, 5, 8})));
|
||||
|
||||
assert (keys.is_equal (hb_set_t (m.keys ())));
|
||||
assert (values.is_equal (hb_set_t (m.values ())));
|
||||
hb_always_assert (keys.is_equal (hb_set_t (m.keys ())));
|
||||
hb_always_assert (values.is_equal (hb_set_t (m.values ())));
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
+16
-16
@@ -30,30 +30,30 @@ main (int argc, char **argv)
|
||||
{
|
||||
hb_multimap_t m;
|
||||
|
||||
assert (m.get (10).length == 0);
|
||||
hb_always_assert (m.get (10).length == 0);
|
||||
|
||||
m.add (10, 11);
|
||||
assert (m.get (10).length == 1);
|
||||
hb_always_assert (m.get (10).length == 1);
|
||||
|
||||
m.add (10, 12);
|
||||
assert (m.get (10).length == 2);
|
||||
hb_always_assert (m.get (10).length == 2);
|
||||
|
||||
m.add (10, 13);
|
||||
assert (m.get (10).length == 3);
|
||||
assert (m.get (10)[0] == 11);
|
||||
assert (m.get (10)[1] == 12);
|
||||
assert (m.get (10)[2] == 13);
|
||||
hb_always_assert (m.get (10).length == 3);
|
||||
hb_always_assert (m.get (10)[0] == 11);
|
||||
hb_always_assert (m.get (10)[1] == 12);
|
||||
hb_always_assert (m.get (10)[2] == 13);
|
||||
|
||||
assert (m.get (11).length == 0);
|
||||
hb_always_assert (m.get (11).length == 0);
|
||||
m.add (11, 14);
|
||||
assert (m.get (10).length == 3);
|
||||
assert (m.get (11).length == 1);
|
||||
assert (m.get (12).length == 0);
|
||||
assert (m.get (10)[0] == 11);
|
||||
assert (m.get (10)[1] == 12);
|
||||
assert (m.get (10)[2] == 13);
|
||||
assert (m.get (11)[0] == 14);
|
||||
assert (m.get (12)[0] == 0); // Array fallback value
|
||||
hb_always_assert (m.get (10).length == 3);
|
||||
hb_always_assert (m.get (11).length == 1);
|
||||
hb_always_assert (m.get (12).length == 0);
|
||||
hb_always_assert (m.get (10)[0] == 11);
|
||||
hb_always_assert (m.get (10)[1] == 12);
|
||||
hb_always_assert (m.get (10)[2] == 13);
|
||||
hb_always_assert (m.get (11)[0] == 14);
|
||||
hb_always_assert (m.get (12)[0] == 0); // Array fallback value
|
||||
|
||||
return 0;
|
||||
}
|
||||
+69
-69
@@ -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;
|
||||
|
||||
@@ -40,7 +40,7 @@ main (int argc, char **argv)
|
||||
}
|
||||
|
||||
hb_blob_t *blob = hb_blob_create_from_file_or_fail (argv[1]);
|
||||
assert (blob);
|
||||
hb_always_assert (blob);
|
||||
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
|
||||
hb_font_t *font = hb_font_create (face);
|
||||
hb_blob_destroy (blob);
|
||||
|
||||
+1
-1
@@ -38,7 +38,7 @@ main (int argc, char **argv)
|
||||
}
|
||||
|
||||
hb_blob_t *blob = hb_blob_create_from_file_or_fail (argv[1]);
|
||||
assert (blob);
|
||||
hb_always_assert (blob);
|
||||
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
|
||||
hb_blob_destroy (blob);
|
||||
blob = nullptr;
|
||||
|
||||
+1
-1
@@ -40,7 +40,7 @@ main (int argc, char **argv)
|
||||
}
|
||||
|
||||
hb_blob_t *blob = hb_blob_create_from_file_or_fail (argv[1]);
|
||||
assert (blob);
|
||||
hb_always_assert (blob);
|
||||
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
|
||||
hb_blob_destroy (blob);
|
||||
blob = nullptr;
|
||||
|
||||
+11
-11
@@ -31,23 +31,23 @@ static void
|
||||
test_insert ()
|
||||
{
|
||||
hb_priority_queue_t<int64_t> queue;
|
||||
assert (queue.is_empty ());
|
||||
hb_always_assert (queue.is_empty ());
|
||||
|
||||
queue.insert (10, 0);
|
||||
assert (!queue.is_empty ());
|
||||
assert (queue.minimum () == hb_pair (10, 0));
|
||||
hb_always_assert (!queue.is_empty ());
|
||||
hb_always_assert (queue.minimum () == hb_pair (10, 0));
|
||||
|
||||
queue.insert (20, 1);
|
||||
assert (queue.minimum () == hb_pair (10, 0));
|
||||
hb_always_assert (queue.minimum () == hb_pair (10, 0));
|
||||
|
||||
queue.insert (5, 2);
|
||||
assert (queue.minimum () == hb_pair (5, 2));
|
||||
hb_always_assert (queue.minimum () == hb_pair (5, 2));
|
||||
|
||||
queue.insert (15, 3);
|
||||
assert (queue.minimum () == hb_pair (5, 2));
|
||||
hb_always_assert (queue.minimum () == hb_pair (5, 2));
|
||||
|
||||
queue.insert (1, 4);
|
||||
assert (queue.minimum () == hb_pair (1, 4));
|
||||
hb_always_assert (queue.minimum () == hb_pair (1, 4));
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -65,12 +65,12 @@ test_extract ()
|
||||
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
assert (!queue.is_empty ());
|
||||
assert (queue.minimum () == hb_pair (i * 10, i));
|
||||
assert (queue.pop_minimum () == hb_pair (i * 10, i));
|
||||
hb_always_assert (!queue.is_empty ());
|
||||
hb_always_assert (queue.minimum () == hb_pair (i * 10, i));
|
||||
hb_always_assert (queue.pop_minimum () == hb_pair (i * 10, i));
|
||||
}
|
||||
|
||||
assert (queue.is_empty ());
|
||||
hb_always_assert (queue.is_empty ());
|
||||
}
|
||||
|
||||
int
|
||||
|
||||
+117
-117
@@ -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);
|
||||
|
||||
|
||||
@@ -45,7 +45,7 @@ main (int argc, char **argv)
|
||||
s.end_serialize ();
|
||||
|
||||
hb_bytes_t bytes = s.copy_bytes ();
|
||||
assert (bytes.length == 10);
|
||||
hb_always_assert (bytes.length == 10);
|
||||
bytes.fini ();
|
||||
|
||||
return 0;
|
||||
|
||||
+40
-40
@@ -33,9 +33,9 @@ main (int argc, char **argv)
|
||||
{
|
||||
hb_set_t v1 {1, 2};
|
||||
hb_set_t v2 {v1};
|
||||
assert (v1.get_population () == 2);
|
||||
assert (hb_len (hb_iter (v1)) == 2);
|
||||
assert (v2.get_population () == 2);
|
||||
hb_always_assert (v1.get_population () == 2);
|
||||
hb_always_assert (hb_len (hb_iter (v1)) == 2);
|
||||
hb_always_assert (v2.get_population () == 2);
|
||||
}
|
||||
|
||||
/* Test copy assignment. */
|
||||
@@ -43,17 +43,17 @@ main (int argc, char **argv)
|
||||
hb_set_t v1 {1, 2};
|
||||
hb_set_t v2;
|
||||
v2 = v1;
|
||||
assert (v1.get_population () == 2);
|
||||
assert (v2.get_population () == 2);
|
||||
hb_always_assert (v1.get_population () == 2);
|
||||
hb_always_assert (v2.get_population () == 2);
|
||||
}
|
||||
|
||||
/* Test move constructor. */
|
||||
{
|
||||
hb_set_t s {1, 2};
|
||||
hb_set_t v (std::move (s));
|
||||
assert (s.get_population () == 0);
|
||||
assert (hb_len (hb_iter (s)) == 0);
|
||||
assert (v.get_population () == 2);
|
||||
hb_always_assert (s.get_population () == 0);
|
||||
hb_always_assert (hb_len (hb_iter (s)) == 0);
|
||||
hb_always_assert (v.get_population () == 2);
|
||||
}
|
||||
|
||||
/* Test move assignment. */
|
||||
@@ -61,8 +61,8 @@ main (int argc, char **argv)
|
||||
hb_set_t s = hb_set_t {1, 2};
|
||||
hb_set_t v;
|
||||
v = std::move (s);
|
||||
assert (s.get_population () == 0);
|
||||
assert (v.get_population () == 2);
|
||||
hb_always_assert (s.get_population () == 0);
|
||||
hb_always_assert (v.get_population () == 2);
|
||||
}
|
||||
|
||||
/* Test initializing from iterable. */
|
||||
@@ -77,10 +77,10 @@ main (int argc, char **argv)
|
||||
hb_set_t v1 (s);
|
||||
hb_set_t v2 (std::move (s));
|
||||
|
||||
assert (s.get_population () == 0);
|
||||
assert (v0.get_population () == 2);
|
||||
assert (v1.get_population () == 2);
|
||||
assert (v2.get_population () == 2);
|
||||
hb_always_assert (s.get_population () == 0);
|
||||
hb_always_assert (v0.get_population () == 2);
|
||||
hb_always_assert (v1.get_population () == 2);
|
||||
hb_always_assert (v2.get_population () == 2);
|
||||
}
|
||||
|
||||
/* Test initializing from iterator. */
|
||||
@@ -95,7 +95,7 @@ main (int argc, char **argv)
|
||||
|
||||
hb_set_t v (hb_iter (s));
|
||||
|
||||
assert (v.get_population () == 5);
|
||||
hb_always_assert (v.get_population () == 5);
|
||||
}
|
||||
|
||||
/* Test initializing from initializer list and swapping. */
|
||||
@@ -103,8 +103,8 @@ main (int argc, char **argv)
|
||||
hb_set_t v1 {1, 2, 3};
|
||||
hb_set_t v2 {4, 5};
|
||||
hb_swap (v1, v2);
|
||||
assert (v1.get_population () == 2);
|
||||
assert (v2.get_population () == 3);
|
||||
hb_always_assert (v1.get_population () == 2);
|
||||
hb_always_assert (v2.get_population () == 3);
|
||||
}
|
||||
|
||||
/* Test inverted sets. */
|
||||
@@ -114,27 +114,27 @@ main (int argc, char **argv)
|
||||
s.del (5);
|
||||
|
||||
hb_codepoint_t start = HB_SET_VALUE_INVALID, last = HB_SET_VALUE_INVALID;
|
||||
assert (s.next_range (&start, &last));
|
||||
assert (start == 0);
|
||||
assert (last == 4);
|
||||
assert (s.next_range (&start, &last));
|
||||
assert (start == 6);
|
||||
assert (last == HB_SET_VALUE_INVALID - 1);
|
||||
assert (!s.next_range (&start, &last));
|
||||
hb_always_assert (s.next_range (&start, &last));
|
||||
hb_always_assert (start == 0);
|
||||
hb_always_assert (last == 4);
|
||||
hb_always_assert (s.next_range (&start, &last));
|
||||
hb_always_assert (start == 6);
|
||||
hb_always_assert (last == HB_SET_VALUE_INVALID - 1);
|
||||
hb_always_assert (!s.next_range (&start, &last));
|
||||
|
||||
start = HB_SET_VALUE_INVALID;
|
||||
last = HB_SET_VALUE_INVALID;
|
||||
assert (s.previous_range (&start, &last));
|
||||
assert (start == 6);
|
||||
assert (last == HB_SET_VALUE_INVALID - 1);
|
||||
assert (s.previous_range (&start, &last));
|
||||
assert (start == 0);
|
||||
assert (last == 4);
|
||||
assert (!s.previous_range (&start, &last));
|
||||
hb_always_assert (s.previous_range (&start, &last));
|
||||
hb_always_assert (start == 6);
|
||||
hb_always_assert (last == HB_SET_VALUE_INVALID - 1);
|
||||
hb_always_assert (s.previous_range (&start, &last));
|
||||
hb_always_assert (start == 0);
|
||||
hb_always_assert (last == 4);
|
||||
hb_always_assert (!s.previous_range (&start, &last));
|
||||
|
||||
assert (s.is_inverted ());
|
||||
hb_always_assert (s.is_inverted ());
|
||||
/* Inverted set returns true for invalid value; oh well. */
|
||||
assert (s.has (HB_SET_VALUE_INVALID));
|
||||
hb_always_assert (s.has (HB_SET_VALUE_INVALID));
|
||||
}
|
||||
|
||||
/* Adding HB_SET_VALUE_INVALID */
|
||||
@@ -142,23 +142,23 @@ main (int argc, char **argv)
|
||||
hb_set_t s;
|
||||
|
||||
s.add(HB_SET_VALUE_INVALID);
|
||||
assert(!s.has(HB_SET_VALUE_INVALID));
|
||||
hb_always_assert(!s.has(HB_SET_VALUE_INVALID));
|
||||
|
||||
s.clear();
|
||||
assert(!s.add_range(HB_SET_VALUE_INVALID - 2, HB_SET_VALUE_INVALID));
|
||||
assert(!s.has(HB_SET_VALUE_INVALID));
|
||||
hb_always_assert(!s.add_range(HB_SET_VALUE_INVALID - 2, HB_SET_VALUE_INVALID));
|
||||
hb_always_assert(!s.has(HB_SET_VALUE_INVALID));
|
||||
|
||||
hb_codepoint_t array[] = {(unsigned) HB_SET_VALUE_INVALID, 0, 2};
|
||||
s.clear();
|
||||
s.add_array(array, 3);
|
||||
assert(!s.has(HB_SET_VALUE_INVALID));
|
||||
assert(s.has(2));
|
||||
hb_always_assert(!s.has(HB_SET_VALUE_INVALID));
|
||||
hb_always_assert(s.has(2));
|
||||
|
||||
hb_codepoint_t sorted_array[] = {0, 2, (unsigned) HB_SET_VALUE_INVALID};
|
||||
s.clear();
|
||||
s.add_sorted_array(sorted_array, 3);
|
||||
assert(!s.has(HB_SET_VALUE_INVALID));
|
||||
assert(s.has(2));
|
||||
hb_always_assert(!s.has(HB_SET_VALUE_INVALID));
|
||||
hb_always_assert(s.has(2));
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
+170
-170
@@ -49,7 +49,7 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 1.0, 1.0);
|
||||
Triple axis_range (0.0, 0.0, 0.0);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 0);
|
||||
hb_always_assert (out.length == 0);
|
||||
}
|
||||
|
||||
{
|
||||
@@ -57,9 +57,9 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 1.0, 1.0);
|
||||
Triple axis_range (0.5, 0.5, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 0.5);
|
||||
assert (out[0].second == Triple ());
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 0.5);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
}
|
||||
|
||||
{
|
||||
@@ -67,7 +67,7 @@ main (int argc, char **argv)
|
||||
Triple tent (0.3, 0.5, 0.8);
|
||||
Triple axis_range (0.1, 0.2, 0.3);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 0);
|
||||
hb_always_assert (out.length == 0);
|
||||
}
|
||||
|
||||
/* Case 2 */
|
||||
@@ -75,9 +75,9 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 1.0, 1.0);
|
||||
Triple axis_range (-1.0, 0.0, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 0.5);
|
||||
assert (out[0].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 0.5);
|
||||
hb_always_assert (out[0].second == Triple (0.0, 1.0, 1.0));
|
||||
}
|
||||
|
||||
/* Case 2 */
|
||||
@@ -85,9 +85,9 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 1.0, 1.0);
|
||||
Triple axis_range (-1.0, 0.0, 0.75);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 0.75);
|
||||
assert (out[0].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 0.75);
|
||||
hb_always_assert (out[0].second == Triple (0.0, 1.0, 1.0));
|
||||
}
|
||||
|
||||
/* Without gain: */
|
||||
@@ -96,11 +96,11 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 0.2, 1.0);
|
||||
Triple axis_range (-1.0, 0.0, 0.8);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 2);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple (0.0, 0.25, 1.0));
|
||||
assert (approx (out[1].first, 0.250));
|
||||
assert (out[1].second == Triple (0.25, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 2);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple (0.0, 0.25, 1.0));
|
||||
hb_always_assert (approx (out[1].first, 0.250));
|
||||
hb_always_assert (out[1].second == Triple (0.25, 1.0, 1.0));
|
||||
}
|
||||
|
||||
/* Case 3 boundary */
|
||||
@@ -108,11 +108,11 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 0.4, 1.0);
|
||||
Triple axis_range (-1.0, 0.0, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 2);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple (0.0, 0.8, 1.0));
|
||||
assert (approx (out[1].first, 2.5/3));
|
||||
assert (out[1].second == Triple (0.8, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 2);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple (0.0, 0.8, 1.0));
|
||||
hb_always_assert (approx (out[1].first, 2.5/3));
|
||||
hb_always_assert (out[1].second == Triple (0.8, 1.0, 1.0));
|
||||
}
|
||||
|
||||
/* Case 4 */
|
||||
@@ -120,11 +120,11 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 0.25, 1.0);
|
||||
Triple axis_range (-1.0, 0.0, 0.4);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 2);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple (0.0, 0.625, 1.0));
|
||||
assert (approx (out[1].first, 0.80));
|
||||
assert (out[1].second == Triple (0.625, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 2);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple (0.0, 0.625, 1.0));
|
||||
hb_always_assert (approx (out[1].first, 0.80));
|
||||
hb_always_assert (out[1].second == Triple (0.625, 1.0, 1.0));
|
||||
}
|
||||
|
||||
/* Case 4 */
|
||||
@@ -132,11 +132,11 @@ main (int argc, char **argv)
|
||||
Triple tent (0.25, 0.3, 1.05);
|
||||
Triple axis_range (0.0, 0.2, 0.4);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 2);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (approx (out[0].second, Triple (0.25, 0.5, 1.0)));
|
||||
assert (approx (out[1].first, 2.6 / 3));
|
||||
assert (approx (out[1].second, Triple (0.5, 1.0, 1.0)));
|
||||
hb_always_assert (out.length == 2);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (approx (out[0].second, Triple (0.25, 0.5, 1.0)));
|
||||
hb_always_assert (approx (out[1].first, 2.6 / 3));
|
||||
hb_always_assert (approx (out[1].second, Triple (0.5, 1.0, 1.0)));
|
||||
}
|
||||
|
||||
/* Case 4 boundary */
|
||||
@@ -144,9 +144,9 @@ main (int argc, char **argv)
|
||||
Triple tent (0.25, 0.5, 1.0);
|
||||
Triple axis_range (0.0, 0.25, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple (0.0, 1.0, 1.0));
|
||||
}
|
||||
|
||||
/* With gain */
|
||||
@@ -155,41 +155,41 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 0.5, 1.0);
|
||||
Triple axis_range (0.0, 0.5, 1.0);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 3);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (out[1].first == -1.0);
|
||||
assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
assert (out[2].first == -1.0);
|
||||
assert (out[2].second == Triple (-1.0, -1.0, 0.0));
|
||||
hb_always_assert (out.length == 3);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (out[1].first == -1.0);
|
||||
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (out[2].first == -1.0);
|
||||
hb_always_assert (out[2].second == Triple (-1.0, -1.0, 0.0));
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.0, 0.5, 1.0);
|
||||
Triple axis_range (0.0, 0.5, 0.75);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 3);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (out[1].first == -0.5);
|
||||
assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
assert (out[2].first == -1.0);
|
||||
assert (out[2].second == Triple (-1.0, -1.0, 0.0));
|
||||
hb_always_assert (out.length == 3);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (out[1].first == -0.5);
|
||||
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (out[2].first == -1.0);
|
||||
hb_always_assert (out[2].second == Triple (-1.0, -1.0, 0.0));
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.0, 0.50, 1.0);
|
||||
Triple axis_range (0.0, 0.25, 0.8);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 4);
|
||||
assert (out[0].first == 0.5);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (out[1].first == 0.5);
|
||||
assert (approx (out[1].second, Triple (0.0, 0.454545, 0.909091)));
|
||||
assert (approx (out[2].first, -0.1));
|
||||
assert (approx (out[2].second, Triple (0.909091, 1.0, 1.0)));
|
||||
assert (out[3].first == -0.5);
|
||||
assert (out[3].second == Triple (-1.0, -1.0, 0.0));
|
||||
hb_always_assert (out.length == 4);
|
||||
hb_always_assert (out[0].first == 0.5);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (out[1].first == 0.5);
|
||||
hb_always_assert (approx (out[1].second, Triple (0.0, 0.454545, 0.909091)));
|
||||
hb_always_assert (approx (out[2].first, -0.1));
|
||||
hb_always_assert (approx (out[2].second, Triple (0.909091, 1.0, 1.0)));
|
||||
hb_always_assert (out[3].first == -0.5);
|
||||
hb_always_assert (out[3].second == Triple (-1.0, -1.0, 0.0));
|
||||
}
|
||||
|
||||
/* Case 3a/1neg */
|
||||
@@ -197,13 +197,13 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 0.5, 2.0);
|
||||
Triple axis_range (0.2, 0.5, 0.8);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 3);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (approx (out[1].first, -0.2));
|
||||
assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
assert (approx (out[2].first, -0.6));
|
||||
assert (out[2].second == Triple (-1.0, -1.0, 0.0));
|
||||
hb_always_assert (out.length == 3);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (approx (out[1].first, -0.2));
|
||||
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (approx (out[2].first, -0.6));
|
||||
hb_always_assert (out[2].second == Triple (-1.0, -1.0, 0.0));
|
||||
}
|
||||
|
||||
/* Case 3a/1neg */
|
||||
@@ -211,13 +211,13 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 0.5, 2.0);
|
||||
Triple axis_range (0.2, 0.5, 1.0);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 3);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (approx (out[1].first, -1.0/3));
|
||||
assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
assert (approx (out[2].first, -0.6));
|
||||
assert (out[2].second == Triple (-1.0, -1.0, 0.0));
|
||||
hb_always_assert (out.length == 3);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (approx (out[1].first, -1.0/3));
|
||||
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (approx (out[2].first, -0.6));
|
||||
hb_always_assert (out[2].second == Triple (-1.0, -1.0, 0.0));
|
||||
}
|
||||
|
||||
/* Case 3 */
|
||||
@@ -225,11 +225,11 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 0.5, 1.0);
|
||||
Triple axis_range (0.25, 0.25, 0.75);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 2);
|
||||
assert (out[0].first == 0.5);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (out[1].first == 0.5);
|
||||
assert (out[1].second == Triple (0.0, 0.5, 1.0));
|
||||
hb_always_assert (out.length == 2);
|
||||
hb_always_assert (out[0].first == 0.5);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (out[1].first == 0.5);
|
||||
hb_always_assert (out[1].second == Triple (0.0, 0.5, 1.0));
|
||||
}
|
||||
|
||||
/* Case 1neg */
|
||||
@@ -237,13 +237,13 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 0.5, 1.0);
|
||||
Triple axis_range (0.0, 0.25, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 3);
|
||||
assert (out[0].first == 0.5);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (out[1].first == 0.5);
|
||||
assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
assert (out[2].first == -0.5);
|
||||
assert (out[2].second == Triple (-1.0, -1.0, 0.0));
|
||||
hb_always_assert (out.length == 3);
|
||||
hb_always_assert (out[0].first == 0.5);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (out[1].first == 0.5);
|
||||
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (out[2].first == -0.5);
|
||||
hb_always_assert (out[2].second == Triple (-1.0, -1.0, 0.0));
|
||||
}
|
||||
|
||||
/* Case 2neg */
|
||||
@@ -251,15 +251,15 @@ main (int argc, char **argv)
|
||||
Triple tent (0.05, 0.55, 1.0);
|
||||
Triple axis_range (0.0, 0.25, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 4);
|
||||
assert (approx (out[0].first, 0.4));
|
||||
assert (out[0].second == Triple ());
|
||||
assert (approx (out[1].first, 0.5));
|
||||
assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
assert (approx (out[2].first, -0.4));
|
||||
assert (out[2].second == Triple (-1.0, -0.8, 0.0));
|
||||
assert (approx (out[3].first, -0.4));
|
||||
assert (out[3].second == Triple (-1.0, -1.0, -0.8));
|
||||
hb_always_assert (out.length == 4);
|
||||
hb_always_assert (approx (out[0].first, 0.4));
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (approx (out[1].first, 0.5));
|
||||
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (approx (out[2].first, -0.4));
|
||||
hb_always_assert (out[2].second == Triple (-1.0, -0.8, 0.0));
|
||||
hb_always_assert (approx (out[3].first, -0.4));
|
||||
hb_always_assert (out[3].second == Triple (-1.0, -1.0, -0.8));
|
||||
}
|
||||
|
||||
/* Case 2neg, other side */
|
||||
@@ -267,15 +267,15 @@ main (int argc, char **argv)
|
||||
Triple tent (-1.0, -0.55, -0.05);
|
||||
Triple axis_range (-0.5, -0.25, 0.0);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 4);
|
||||
assert (approx (out[0].first, 0.4));
|
||||
assert (out[0].second == Triple ());
|
||||
assert (approx (out[1].first, 0.5));
|
||||
assert (out[1].second == Triple (-1.0, -1.0, 0.0));
|
||||
assert (approx (out[2].first, -0.4));
|
||||
assert (out[2].second == Triple (0.0, 0.8, 1.0));
|
||||
assert (approx (out[3].first, -0.4));
|
||||
assert (out[3].second == Triple (0.8, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 4);
|
||||
hb_always_assert (approx (out[0].first, 0.4));
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (approx (out[1].first, 0.5));
|
||||
hb_always_assert (out[1].second == Triple (-1.0, -1.0, 0.0));
|
||||
hb_always_assert (approx (out[2].first, -0.4));
|
||||
hb_always_assert (out[2].second == Triple (0.0, 0.8, 1.0));
|
||||
hb_always_assert (approx (out[3].first, -0.4));
|
||||
hb_always_assert (out[3].second == Triple (0.8, 1.0, 1.0));
|
||||
}
|
||||
|
||||
/* Misc corner cases */
|
||||
@@ -283,86 +283,86 @@ main (int argc, char **argv)
|
||||
Triple tent (0.5, 0.5, 0.5);
|
||||
Triple axis_range (0.5, 0.5, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple ());
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.3, 0.5, 0.7);
|
||||
Triple axis_range (0.1, 0.5, 0.9);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 5);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (out[1].first == -1.0);
|
||||
assert (approx(out[1].second, Triple (0.0, 0.5, 1.0)));
|
||||
assert (out[2].first == -1.0);
|
||||
assert (approx(out[2].second, Triple (0.5, 1.0, 1.0)));
|
||||
assert (out[3].first == -1.0);
|
||||
assert (approx (out[3].second, Triple (-1.0, -0.5, 0.0)));
|
||||
assert (out[4].first == -1.0);
|
||||
assert (approx (out[4].second, Triple (-1.0, -1.0, -0.5)));
|
||||
hb_always_assert (out.length == 5);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (out[1].first == -1.0);
|
||||
hb_always_assert (approx(out[1].second, Triple (0.0, 0.5, 1.0)));
|
||||
hb_always_assert (out[2].first == -1.0);
|
||||
hb_always_assert (approx(out[2].second, Triple (0.5, 1.0, 1.0)));
|
||||
hb_always_assert (out[3].first == -1.0);
|
||||
hb_always_assert (approx (out[3].second, Triple (-1.0, -0.5, 0.0)));
|
||||
hb_always_assert (out[4].first == -1.0);
|
||||
hb_always_assert (approx (out[4].second, Triple (-1.0, -1.0, -0.5)));
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.5, 0.5, 0.5);
|
||||
Triple axis_range (0.25, 0.25, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple (1.0, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple (1.0, 1.0, 1.0));
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.5, 0.5, 0.5);
|
||||
Triple axis_range (0.25, 0.35, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple (1.0, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple (1.0, 1.0, 1.0));
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.5, 0.5, 0.55);
|
||||
Triple axis_range (0.25, 0.35, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple (1.0, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple (1.0, 1.0, 1.0));
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.5, 0.5, 1.0);
|
||||
Triple axis_range (0.5, 0.5, 1.0);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 2);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (out[1].first == -1.0);
|
||||
assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 2);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (out[1].first == -1.0);
|
||||
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.25, 0.5, 1.0);
|
||||
Triple axis_range (0.5, 0.5, 1.0);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 2);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (out[1].first == -1.0);
|
||||
assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 2);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (out[1].first == -1.0);
|
||||
hb_always_assert (out[1].second == Triple (0.0, 1.0, 1.0));
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.0, 0.2, 1.0);
|
||||
Triple axis_range (0.0, 0.0, 0.5);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 2);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple (0.0, 0.4, 1.0));
|
||||
assert (out[1].first == 0.625);
|
||||
assert (out[1].second == Triple (0.4, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 2);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple (0.0, 0.4, 1.0));
|
||||
hb_always_assert (out[1].first == 0.625);
|
||||
hb_always_assert (out[1].second == Triple (0.4, 1.0, 1.0));
|
||||
}
|
||||
|
||||
|
||||
@@ -370,43 +370,43 @@ main (int argc, char **argv)
|
||||
Triple tent (0.0, 0.5, 1.0);
|
||||
Triple axis_range (-1.0, 0.25, 1.0);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 5);
|
||||
assert (out[0].first == 0.5);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (out[1].first == 0.5);
|
||||
assert (out[1].second == Triple (0.0, 1.0/3, 2.0/3));
|
||||
assert (out[2].first == -0.5);
|
||||
assert (out[2].second == Triple (2.0/3, 1.0, 1.0));
|
||||
assert (out[3].first == -0.5);
|
||||
assert (out[3].second == Triple (-1.0, -0.2, 0.0));
|
||||
assert (out[4].first == -0.5);
|
||||
assert (out[4].second == Triple (-1.0, -1.0, -0.2));
|
||||
hb_always_assert (out.length == 5);
|
||||
hb_always_assert (out[0].first == 0.5);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (out[1].first == 0.5);
|
||||
hb_always_assert (out[1].second == Triple (0.0, 1.0/3, 2.0/3));
|
||||
hb_always_assert (out[2].first == -0.5);
|
||||
hb_always_assert (out[2].second == Triple (2.0/3, 1.0, 1.0));
|
||||
hb_always_assert (out[3].first == -0.5);
|
||||
hb_always_assert (out[3].second == Triple (-1.0, -0.2, 0.0));
|
||||
hb_always_assert (out[4].first == -0.5);
|
||||
hb_always_assert (out[4].second == Triple (-1.0, -1.0, -0.2));
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.5, 0.5, 0.5);
|
||||
Triple axis_range (0.0, 0.5, 1.0);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 5);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple ());
|
||||
assert (out[1].first == -1.0);
|
||||
assert (out[1].second == Triple (0.0, 2/(double) (1 << 14), 1.0));
|
||||
assert (out[2].first == -1.0);
|
||||
assert (out[2].second == Triple (2/(double) (1 << 14), 1.0, 1.0));
|
||||
assert (out[3].first == -1.0);
|
||||
assert (out[3].second == Triple (-1.0, -2/(double) (1 << 14), 0.0));
|
||||
assert (out[4].first == -1.0);
|
||||
assert (out[4].second == Triple (-1.0, -1.0, -2/(double) (1 << 14)));
|
||||
hb_always_assert (out.length == 5);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple ());
|
||||
hb_always_assert (out[1].first == -1.0);
|
||||
hb_always_assert (out[1].second == Triple (0.0, 2/(double) (1 << 14), 1.0));
|
||||
hb_always_assert (out[2].first == -1.0);
|
||||
hb_always_assert (out[2].second == Triple (2/(double) (1 << 14), 1.0, 1.0));
|
||||
hb_always_assert (out[3].first == -1.0);
|
||||
hb_always_assert (out[3].second == Triple (-1.0, -2/(double) (1 << 14), 0.0));
|
||||
hb_always_assert (out[4].first == -1.0);
|
||||
hb_always_assert (out[4].second == Triple (-1.0, -1.0, -2/(double) (1 << 14)));
|
||||
}
|
||||
|
||||
{
|
||||
Triple tent (0.0, 1.0, 1.0);
|
||||
Triple axis_range (-1.0, -0.5, 1.0);
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, default_axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple (1.0/3, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple (1.0/3, 1.0, 1.0));
|
||||
}
|
||||
|
||||
{
|
||||
@@ -414,9 +414,9 @@ main (int argc, char **argv)
|
||||
Triple axis_range (-1.0, -0.5, 1.0);
|
||||
TripleDistances axis_distances{2.0, 1.0};
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (out[0].second == Triple (0.5, 1.0, 1.0));
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (out[0].second == Triple (0.5, 1.0, 1.0));
|
||||
}
|
||||
|
||||
{
|
||||
@@ -424,8 +424,8 @@ main (int argc, char **argv)
|
||||
Triple axis_range (-1.0, 0.2, 1.0);
|
||||
TripleDistances axis_distances{1.0, 1.0};
|
||||
rebase_tent_result_t out = rebase_tent (tent, axis_range, axis_distances);
|
||||
assert (out.length == 1);
|
||||
assert (out[0].first == 1.0);
|
||||
assert (approx (out[0].second, Triple (0.5, 0.625, 0.75)));
|
||||
hb_always_assert (out.length == 1);
|
||||
hb_always_assert (out[0].first == 1.0);
|
||||
hb_always_assert (approx (out[0].second, Triple (0.5, 0.625, 0.75)));
|
||||
}
|
||||
}
|
||||
+36
-36
@@ -48,33 +48,33 @@ test_decompile_cvar ()
|
||||
hb_bytes_t var_data_bytes{(const char* ) cvar_data + 4, len - 4};
|
||||
bool result = OT::TupleVariationData<>::get_tuple_iterator (var_data_bytes, axis_count, cvar_table,
|
||||
shared_indices, &iterator);
|
||||
assert (result);
|
||||
hb_always_assert (result);
|
||||
|
||||
result = tuple_var_data->decompile_tuple_variations (point_count, false, iterator, &axis_idx_tag_map,
|
||||
shared_indices, hb_array<const OT::F2DOT14> (),
|
||||
tuple_variations);
|
||||
|
||||
assert (result);
|
||||
assert (tuple_variations.tuple_vars.length == 2);
|
||||
hb_always_assert (result);
|
||||
hb_always_assert (tuple_variations.tuple_vars.length == 2);
|
||||
for (unsigned i = 0; i < 2; i++)
|
||||
{
|
||||
assert (tuple_variations.tuple_vars[i].axis_tuples.get_population () == 1);
|
||||
assert (!tuple_variations.tuple_vars[i].deltas_y);
|
||||
assert (tuple_variations.tuple_vars[i].indices.length == 65);
|
||||
assert (tuple_variations.tuple_vars[i].indices.length == tuple_variations.tuple_vars[i].deltas_x.length);
|
||||
hb_always_assert (tuple_variations.tuple_vars[i].axis_tuples.get_population () == 1);
|
||||
hb_always_assert (!tuple_variations.tuple_vars[i].deltas_y);
|
||||
hb_always_assert (tuple_variations.tuple_vars[i].indices.length == 65);
|
||||
hb_always_assert (tuple_variations.tuple_vars[i].indices.length == tuple_variations.tuple_vars[i].deltas_x.length);
|
||||
}
|
||||
assert (tuple_variations.tuple_vars[0].axis_tuples.get (axis_tag) == Triple (-1.0, -1.0, 0.0));
|
||||
assert (tuple_variations.tuple_vars[1].axis_tuples.get (axis_tag) == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].axis_tuples.get (axis_tag) == Triple (-1.0, -1.0, 0.0));
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].axis_tuples.get (axis_tag) == Triple (0.0, 1.0, 1.0));
|
||||
|
||||
hb_vector_t<float> deltas_1 {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, -3.0, 1.0, 0.0, -1.0, 0.0, -3.0, 1.0, 0.0, -37.0, -37.0, -26.0, -26.0, 0.0, 0.0, 0.0, -3.0, 0.0, 0.0, 0.0, 0.0, 0.0, -3.0, 0.0, 2.0, -29.0, -29.0, -20.0, -20.0, 0.0, 0.0, 0.0, 1.0, -29.0, -29.0, -20.0, -20.0, 0.0, 0.0, 0.0, 1.0};
|
||||
for (unsigned i = 0; i < 65; i++)
|
||||
{
|
||||
if (i < 23)
|
||||
assert (tuple_variations.tuple_vars[0].indices[i] == 0);
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].indices[i] == 0);
|
||||
else
|
||||
{
|
||||
assert (tuple_variations.tuple_vars[0].indices[i] == 1);
|
||||
assert (tuple_variations.tuple_vars[0].deltas_x[i] == deltas_1[i]);
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].indices[i] == 1);
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].deltas_x[i] == deltas_1[i]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -82,11 +82,11 @@ test_decompile_cvar ()
|
||||
for (unsigned i = 0 ; i < 65; i++)
|
||||
{
|
||||
if (i < 23)
|
||||
assert (tuple_variations.tuple_vars[1].indices[i] == 0);
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].indices[i] == 0);
|
||||
else
|
||||
{
|
||||
assert (tuple_variations.tuple_vars[1].indices[i] == 1);
|
||||
assert (tuple_variations.tuple_vars[1].deltas_x[i] == deltas_2[i]);
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].indices[i] == 1);
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].deltas_x[i] == deltas_2[i]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -99,12 +99,12 @@ test_decompile_cvar ()
|
||||
|
||||
tuple_variations.instantiate (normalized_axes_location, axes_triple_distances);
|
||||
|
||||
assert (tuple_variations.tuple_vars[0].indices.length == 65);
|
||||
assert (tuple_variations.tuple_vars[1].indices.length == 65);
|
||||
assert (!tuple_variations.tuple_vars[0].deltas_y);
|
||||
assert (!tuple_variations.tuple_vars[1].deltas_y);
|
||||
assert (tuple_variations.tuple_vars[0].axis_tuples.get (axis_tag) == Triple (-1.0, -1.0, 0.0));
|
||||
assert (tuple_variations.tuple_vars[1].axis_tuples.get (axis_tag) == Triple (0.0, 1.0, 1.0));
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].indices.length == 65);
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].indices.length == 65);
|
||||
hb_always_assert (!tuple_variations.tuple_vars[0].deltas_y);
|
||||
hb_always_assert (!tuple_variations.tuple_vars[1].deltas_y);
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].axis_tuples.get (axis_tag) == Triple (-1.0, -1.0, 0.0));
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].axis_tuples.get (axis_tag) == Triple (0.0, 1.0, 1.0));
|
||||
|
||||
hb_vector_t<float> rounded_deltas_1 {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1, 0.0, -2, 1, 0.0, -1, 0.0, -2, 1, 0.0, -19, -19, -13, -13, 0.0, 0.0, 0.0, -2, 0.0, 0.0, 0.0, 0.0, 0.0, -2, 0.0, 1, -15, -15, -10.0, -10.0, 0.0, 0.0, 0.0, 1, -15, -15, -10.0, -10.0, 0.0, 0.0, 0.0, 1};
|
||||
|
||||
@@ -114,41 +114,41 @@ test_decompile_cvar ()
|
||||
{
|
||||
if (i < 23)
|
||||
{
|
||||
assert (tuple_variations.tuple_vars[0].indices[i] == 0);
|
||||
assert (tuple_variations.tuple_vars[1].indices[i] == 0);
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].indices[i] == 0);
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].indices[i] == 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
assert (tuple_variations.tuple_vars[0].indices[i] == 1);
|
||||
assert (tuple_variations.tuple_vars[1].indices[i] == 1);
|
||||
assert (roundf (tuple_variations.tuple_vars[0].deltas_x[i]) == rounded_deltas_1[i]);
|
||||
assert (roundf (tuple_variations.tuple_vars[1].deltas_x[i]) == rounded_deltas_2[i]);
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].indices[i] == 1);
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].indices[i] == 1);
|
||||
hb_always_assert (roundf (tuple_variations.tuple_vars[0].deltas_x[i]) == rounded_deltas_1[i]);
|
||||
hb_always_assert (roundf (tuple_variations.tuple_vars[1].deltas_x[i]) == rounded_deltas_2[i]);
|
||||
}
|
||||
}
|
||||
|
||||
hb_map_t axes_index_map;
|
||||
axes_index_map.set (0, 0);
|
||||
bool res = tuple_variations.compile_bytes (axes_index_map, axis_idx_tag_map, false);
|
||||
assert (res);
|
||||
assert (tuple_variations.tuple_vars[0].compiled_tuple_header.length == 6);
|
||||
hb_always_assert (res);
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].compiled_tuple_header.length == 6);
|
||||
const unsigned char tuple_var_header_1[] = "\x0\x51\xa0\x0\xc0\x0";
|
||||
for (unsigned i = 0; i < 6; i++)
|
||||
assert(tuple_variations.tuple_vars[0].compiled_tuple_header.arrayZ[i] == tuple_var_header_1[i]);
|
||||
hb_always_assert(tuple_variations.tuple_vars[0].compiled_tuple_header.arrayZ[i] == tuple_var_header_1[i]);
|
||||
|
||||
assert (tuple_variations.tuple_vars[1].compiled_tuple_header.length == 6);
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].compiled_tuple_header.length == 6);
|
||||
const unsigned char tuple_var_header_2[] = "\x0\x54\xa0\x0\x40\x0";
|
||||
for (unsigned i = 0; i < 6; i++)
|
||||
assert(tuple_variations.tuple_vars[1].compiled_tuple_header.arrayZ[i] == tuple_var_header_2[i]);
|
||||
hb_always_assert(tuple_variations.tuple_vars[1].compiled_tuple_header.arrayZ[i] == tuple_var_header_2[i]);
|
||||
|
||||
assert (tuple_variations.tuple_vars[0].compiled_deltas.length == 37);
|
||||
assert (tuple_variations.tuple_vars[1].compiled_deltas.length == 40);
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].compiled_deltas.length == 37);
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].compiled_deltas.length == 40);
|
||||
const unsigned char compiled_deltas_1[] = "\x0d\xff\x00\xfe\x01\x00\xff\x00\xfe\x01\x00\xed\xed\xf3\xf3\x82\x00\xfe\x84\x06\xfe\x00\x01\xf1\xf1\xf6\xf6\x82\x04\x01\xf1\xf1\xf6\xf6\x82\x00\x01";
|
||||
for (unsigned i = 0; i < 37; i++)
|
||||
assert (tuple_variations.tuple_vars[0].compiled_deltas.arrayZ[i] == compiled_deltas_1[i]);
|
||||
hb_always_assert (tuple_variations.tuple_vars[0].compiled_deltas.arrayZ[i] == compiled_deltas_1[i]);
|
||||
|
||||
const unsigned char compiled_deltas_2[] = "\x0d\x01\x00\x04\xfe\x00\x01\x00\x04\xfe\x00\x44\x44\x30\x30\x82\x00\x04\x81\x09\x01\xff\x01\x05\xff\xfc\x33\x33\x25\x25\x82\x04\xff\x33\x33\x25\x25\x82\x00\xff";
|
||||
for (unsigned i = 0; i < 40; i++)
|
||||
assert (tuple_variations.tuple_vars[1].compiled_deltas.arrayZ[i] == compiled_deltas_2[i]);
|
||||
hb_always_assert (tuple_variations.tuple_vars[1].compiled_deltas.arrayZ[i] == compiled_deltas_2[i]);
|
||||
}
|
||||
|
||||
int
|
||||
|
||||
+46
-46
@@ -33,19 +33,19 @@
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
assert (sizeof (hb_vector_t<int>) == sizeof (hb_sorted_vector_t<int>));
|
||||
hb_always_assert (sizeof (hb_vector_t<int>) == sizeof (hb_sorted_vector_t<int>));
|
||||
|
||||
/* Test copy constructor. */
|
||||
{
|
||||
hb_vector_t<int> v1 {1, 2};
|
||||
hb_vector_t<int> v2 {v1};
|
||||
hb_vector_t<int> V2 {v1};
|
||||
assert (v1.length == 2);
|
||||
assert (v1[0] == 1);
|
||||
assert (v1[1] == 2);
|
||||
assert (v2.length == 2);
|
||||
assert (v2[0] == 1);
|
||||
assert (v2[1] == 2);
|
||||
hb_always_assert (v1.length == 2);
|
||||
hb_always_assert (v1[0] == 1);
|
||||
hb_always_assert (v1[1] == 2);
|
||||
hb_always_assert (v2.length == 2);
|
||||
hb_always_assert (v2[0] == 1);
|
||||
hb_always_assert (v2[1] == 2);
|
||||
}
|
||||
|
||||
/* Test copy assignment. */
|
||||
@@ -53,12 +53,12 @@ main (int argc, char **argv)
|
||||
hb_vector_t<int> v1 {1, 2};
|
||||
hb_vector_t<int> v2 = v1;
|
||||
hb_vector_t<int> V2 = v1;
|
||||
assert (v1.length == 2);
|
||||
assert (v1[0] == 1);
|
||||
assert (v1[1] == 2);
|
||||
assert (v2.length == 2);
|
||||
assert (v2[0] == 1);
|
||||
assert (v2[1] == 2);
|
||||
hb_always_assert (v1.length == 2);
|
||||
hb_always_assert (v1[0] == 1);
|
||||
hb_always_assert (v1[1] == 2);
|
||||
hb_always_assert (v2.length == 2);
|
||||
hb_always_assert (v2[0] == 1);
|
||||
hb_always_assert (v2[1] == 2);
|
||||
}
|
||||
|
||||
/* Test move constructor. */
|
||||
@@ -67,11 +67,11 @@ main (int argc, char **argv)
|
||||
hb_sorted_vector_t<int> S {1, 2};
|
||||
hb_vector_t<int> v (std::move (s));
|
||||
hb_sorted_vector_t<int> V (std::move (S));
|
||||
assert (s.length == 0);
|
||||
assert (S.length == 0);
|
||||
assert (v.length == 2);
|
||||
assert (v[0] == 1);
|
||||
assert (v[1] == 2);
|
||||
hb_always_assert (s.length == 0);
|
||||
hb_always_assert (S.length == 0);
|
||||
hb_always_assert (v.length == 2);
|
||||
hb_always_assert (v[0] == 1);
|
||||
hb_always_assert (v[1] == 2);
|
||||
}
|
||||
|
||||
/* Test move assignment. */
|
||||
@@ -82,12 +82,12 @@ main (int argc, char **argv)
|
||||
hb_sorted_vector_t<int> V;
|
||||
v = std::move (s);
|
||||
V = std::move (S);
|
||||
assert (s.length == 0);
|
||||
assert (S.length == 0);
|
||||
assert (v.length == 2);
|
||||
assert (V.length == 2);
|
||||
assert (v[0] == 1);
|
||||
assert (v[1] == 2);
|
||||
hb_always_assert (s.length == 0);
|
||||
hb_always_assert (S.length == 0);
|
||||
hb_always_assert (v.length == 2);
|
||||
hb_always_assert (V.length == 2);
|
||||
hb_always_assert (v[0] == 1);
|
||||
hb_always_assert (v[1] == 2);
|
||||
}
|
||||
|
||||
/* Test initializing from iterable. */
|
||||
@@ -100,12 +100,12 @@ main (int argc, char **argv)
|
||||
hb_vector_t<int> v (s);
|
||||
hb_sorted_vector_t<int> V (s);
|
||||
|
||||
assert (v.length == 2);
|
||||
assert (V.length == 2);
|
||||
assert (v[0] == 12);
|
||||
assert (V[0] == 12);
|
||||
assert (v[1] == 18);
|
||||
assert (V[1] == 18);
|
||||
hb_always_assert (v.length == 2);
|
||||
hb_always_assert (V.length == 2);
|
||||
hb_always_assert (v[0] == 12);
|
||||
hb_always_assert (V[0] == 12);
|
||||
hb_always_assert (v[1] == 18);
|
||||
hb_always_assert (V[1] == 18);
|
||||
}
|
||||
|
||||
/* Test initializing from iterator. */
|
||||
@@ -118,12 +118,12 @@ main (int argc, char **argv)
|
||||
hb_vector_t<int> v (hb_iter (s));
|
||||
hb_vector_t<int> V (hb_iter (s));
|
||||
|
||||
assert (v.length == 2);
|
||||
assert (V.length == 2);
|
||||
assert (v[0] == 12);
|
||||
assert (V[0] == 12);
|
||||
assert (v[1] == 18);
|
||||
assert (V[1] == 18);
|
||||
hb_always_assert (v.length == 2);
|
||||
hb_always_assert (V.length == 2);
|
||||
hb_always_assert (v[0] == 12);
|
||||
hb_always_assert (V[0] == 12);
|
||||
hb_always_assert (v[1] == 18);
|
||||
hb_always_assert (V[1] == 18);
|
||||
}
|
||||
|
||||
/* Test initializing from initializer list and swapping. */
|
||||
@@ -131,10 +131,10 @@ main (int argc, char **argv)
|
||||
hb_vector_t<int> v1 {1, 2, 3};
|
||||
hb_vector_t<int> v2 {4, 5};
|
||||
hb_swap (v1, v2);
|
||||
assert (v1.length == 2);
|
||||
assert (v1[0] == 4);
|
||||
assert (v2.length == 3);
|
||||
assert (v2[2] == 3);
|
||||
hb_always_assert (v1.length == 2);
|
||||
hb_always_assert (v1[0] == 4);
|
||||
hb_always_assert (v2.length == 3);
|
||||
hb_always_assert (v2[2] == 3);
|
||||
}
|
||||
|
||||
/* Test initializing sorted-vector from initializer list and swapping. */
|
||||
@@ -142,10 +142,10 @@ main (int argc, char **argv)
|
||||
hb_sorted_vector_t<int> v1 {1, 2, 3};
|
||||
hb_sorted_vector_t<int> v2 {4, 5};
|
||||
hb_swap (v1, v2);
|
||||
assert (v1.length == 2);
|
||||
assert (v1[0] == 4);
|
||||
assert (v2.length == 3);
|
||||
assert (v2[2] == 3);
|
||||
hb_always_assert (v1.length == 2);
|
||||
hb_always_assert (v1[0] == 4);
|
||||
hb_always_assert (v2.length == 3);
|
||||
hb_always_assert (v2[2] == 3);
|
||||
}
|
||||
|
||||
{
|
||||
@@ -171,9 +171,9 @@ main (int argc, char **argv)
|
||||
hb_set_t s {1, 5, 7};
|
||||
v.push (s);
|
||||
v << s;
|
||||
assert (s.get_population () == 3);
|
||||
hb_always_assert (s.get_population () == 3);
|
||||
v << std::move (s);
|
||||
assert (s.get_population () == 0);
|
||||
hb_always_assert (s.get_population () == 0);
|
||||
}
|
||||
|
||||
{
|
||||
|
||||
Reference in new issue
Block a user