Files
harfbuzz/src/test-algs.cc
T
Behdad Esfahbod 818eea711c [algs] Preserve float precision when rounding (#6351)
Adding 0.5 in float can round up before floor sees the value. This
turns the predecessor of 0.5 into 1, and changes sufficiently large
odd integral floats by one. The latter also shifts exactly representable
16.16 axis bounds when the subsetter writes fvar.

Add 0.5 in double to preserve the input's fractional bits while retaining
the existing tie direction toward positive infinity. Exercise half ties,
their neighboring floats, and large positive and negative integers.

Validation: the new regression fails before the fix; the full Meson suite
passes all 282 configured tests after it.

Assisted-by: Codex
2026-10-10 12:08:50 -06:00

159 lines
5.2 KiB
C++

/*
* Copyright © 2019 Facebook, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Facebook Author(s): Behdad Esfahbod
*/
#include "hb.hh"
#include "hb-algs.hh"
#include "hb-set.hh"
static char *
test_func (int a, char **b)
{
return b ? b[a] : nullptr;
}
struct A
{
void a () {}
};
int
main (int argc, char **argv)
{
hb_always_assert (roundf (0.5f) == 1.f);
hb_always_assert (roundf (-0.5f) == 0.f);
hb_always_assert (roundf (1.5f) == 2.f);
hb_always_assert (roundf (-1.5f) == -1.f);
hb_always_assert (roundf (nextafterf (0.5f, 0.f)) == 0.f);
hb_always_assert (roundf (nextafterf (-0.5f, -1.f)) == -1.f);
hb_always_assert (roundf (nextafterf (1.5f, 1.f)) == 1.f);
hb_always_assert (roundf (nextafterf (-1.5f, -2.f)) == -2.f);
hb_always_assert (roundf (15383929.f) == 15383929.f);
hb_always_assert (roundf (-15383929.f) == -15383929.f);
hb_always_assert (roundf (8388609.f) == 8388609.f);
hb_always_assert (roundf (-8388609.f) == -8388609.f);
int i = 1;
auto p = hb_pair (1, i);
p.second = 2;
hb_always_assert (i == 2);
const int c = 3;
auto pc = hb_pair (1, c);
hb_always_assert (pc.second == 3);
auto q = p;
hb_always_assert (&q != &p);
q.second = 4;
hb_always_assert (i == 4);
hb_invoke (test_func, 0, nullptr);
A a;
hb_invoke (&A::a, a);
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);
hb_min (3, x);
hb_min (x, 4 + 3);
int &z = hb_min (x, y);
z = 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);
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);
hb_always_assert (M0 (-2) == 0);
hb_always_assert (M0 (+2) == 2);
hb_always_assert (hb_add (2) (5) == 7);
hb_always_assert (hb_add (5) (2) == 7);
hb_always_assert (hb_saturate_add (1, 2) == 3);
hb_always_assert (hb_saturate_add (INT_MAX, 1) == INT_MAX);
hb_always_assert (hb_saturate_add (INT_MIN, -1) == INT_MIN);
hb_always_assert (hb_saturate_add (INT_MAX, INT_MIN) == -1);
hb_always_assert (hb_saturate_sub (3, 2) == 1);
hb_always_assert (hb_saturate_sub (INT_MAX, -1) == INT_MAX);
hb_always_assert (hb_saturate_sub (INT_MIN, 1) == INT_MIN);
hb_always_assert (hb_saturate_sub (INT_MIN, INT_MIN) == 0);
hb_always_assert (hb_saturate_neg (2) == -2);
hb_always_assert (hb_saturate_neg (-2) == 2);
hb_always_assert (hb_saturate_neg (INT_MIN) == INT_MAX);
hb_always_assert (hb_clamp_to<int> (1.) == 1);
hb_always_assert (hb_clamp_to<int> ((double) INT_MAX + 1.) == INT_MAX);
hb_always_assert (hb_clamp_to<int> ((double) INT_MIN - 1.) == INT_MIN);
hb_always_assert (hb_clamp_to<int> ((int64_t) 1) == 1);
hb_always_assert (hb_clamp_to<int> ((int64_t) INT_MAX + 1) == INT_MAX);
hb_always_assert (hb_clamp_to<int> ((int64_t) INT_MIN - 1) == INT_MIN);
int64_t budget = 10;
hb_always_assert (hb_budget_spend (budget, 4, 2));
hb_always_assert (budget == 2);
hb_always_assert (!hb_budget_spend (budget, 3));
hb_always_assert (budget == -1);
hb_always_assert (!hb_budget_spend (budget, 1));
hb_always_assert (budget == -2);
budget = 0;
hb_always_assert (hb_budget_spend (budget, 0));
hb_always_assert (!hb_budget_spend (budget, 1));
hb_always_assert (budget == -1);
budget = INT64_MAX;
hb_always_assert (hb_budget_spend (budget, 1024));
hb_always_assert (budget == INT64_MAX - 1024);
x = 1;
hb_always_assert (++hb_inc (x) == 3);
hb_always_assert (x == 3);
hb_set_t set1 {1};
hb_set_t set2 {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. */
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;
}