dymokomi/luce-browser-render
Source of release 0.6.2
0.6.2 / src / gfx / tests_pixel_units.lucb
#==============================================================================================
#
# tests_pixel_units - CSSPixels, CSSPixelFraction and DevicePixels, pinned to the donor
#
# DESCRIPTION:
# Values computed by the donor's PixelUnits.h (Ladybird 47c82b38d0, compiled locally)
# for the cases Tests/LibWeb/TestCSSPixels.cpp does not cover: float conversions and
# their rounding, saturation, the fraction arithmetic, the free functions and the hash.
# Raw values are the fixed-point integers (1px = 64).
#
#==============================================================================================
test "pixel_units: nearest_f32_0_3":
# C++: CSSPixels::nearest_value_for(0.3f).raw_value()
assert((i64)(css_pixels_nearest_value_for_f32(0.3).raw_value()) == 19)
test "pixel_units: nearest_f32_minus_0_3":
# C++: CSSPixels::nearest_value_for(-0.3f).raw_value()
assert((i64)(css_pixels_nearest_value_for_f32(-0.3).raw_value()) == -19)
test "pixel_units: nearest_f32_half_raw":
# C++: CSSPixels::nearest_value_for(0.0234375f).raw_value()
assert((i64)(css_pixels_nearest_value_for_f32(0.0234375).raw_value()) == 2)
test "pixel_units: nearest_f32_half_raw_even":
# C++: CSSPixels::nearest_value_for(0.0078125f).raw_value()
assert((i64)(css_pixels_nearest_value_for_f32(0.0078125).raw_value()) == 0)
test "pixel_units: nearest_f32_huge":
# C++: CSSPixels::nearest_value_for(1e10f).raw_value()
assert((i64)(css_pixels_nearest_value_for_f32(1e10).raw_value()) == 2147483647)
test "pixel_units: nearest_f32_minus_huge":
# C++: CSSPixels::nearest_value_for(-1e10f).raw_value()
assert((i64)(css_pixels_nearest_value_for_f32(-1e10).raw_value()) == -2147483648)
test "pixel_units: nearest_f32_nan":
# C++: CSSPixels::nearest_value_for(NAN).raw_value()
assert((i64)(css_pixels_nearest_value_for_f32(f32.bits(0x7fc00000)).raw_value()) == 0)
test "pixel_units: nearest_f64_1_2345":
# C++: CSSPixels::nearest_value_for(1.2345).raw_value()
assert((i64)(css_pixels_nearest_value_for_f64(1.2345).raw_value()) == 79)
test "pixel_units: nearest_f64_minus_2_5_raw":
# C++: CSSPixels::nearest_value_for(-0.0390625).raw_value()
assert((i64)(css_pixels_nearest_value_for_f64(-0.0390625).raw_value()) == -2)
test "pixel_units: floored_f32_0_3":
# C++: CSSPixels::floored_value_for(0.3f).raw_value()
assert((i64)(css_pixels_floored_value_for_f32(0.3).raw_value()) == 19)
test "pixel_units: floored_f32_minus_0_3":
# C++: CSSPixels::floored_value_for(-0.3f).raw_value()
assert((i64)(css_pixels_floored_value_for_f32(-0.3).raw_value()) == -20)
test "pixel_units: floored_f64_minus_1_01":
# C++: CSSPixels::floored_value_for(-1.01).raw_value()
assert((i64)(css_pixels_floored_value_for_f64(-1.01).raw_value()) == -65)
test "pixel_units: from_int_big":
# C++: CSSPixels((i64)100000000).raw_value()
assert((i64)(css_pixels_from_int(100000000).raw_value()) == 2147483647)
test "pixel_units: from_int_minus_big":
# C++: CSSPixels((i64)-100000000).raw_value()
assert((i64)(css_pixels_from_int(-100000000).raw_value()) == -2147483648)
test "pixel_units: from_int_max_integer":
# C++: CSSPixels(CSSPixels::max_integer_value).raw_value()
assert((i64)(css_pixels_from_int(css_pixels_max_integer_value).raw_value()) == 2147483584)
test "pixel_units: from_int_minus_7":
# C++: CSSPixels(-7).raw_value()
assert((i64)(css_pixels_from_int(-7).raw_value()) == -448)
test "pixel_units: from_unsigned_big":
# C++: CSSPixels((u32)4000000000u).raw_value()
assert((i64)(css_pixels_from_unsigned(4000000000).raw_value()) == 2147483647)
test "pixel_units: from_unsigned_12":
# C++: CSSPixels((u32)12u).raw_value()
assert((i64)(css_pixels_from_unsigned(12).raw_value()) == 768)
test "pixel_units: to_int_negative":
# C++: CSSPixels::from_raw(-100).to_int()
assert((i64)(css_pixels_from_raw(-100).to_int()) == -1)
test "pixel_units: to_float_raw_1":
# C++: CSSPixels::from_raw(1).to_float()
assert((css_pixels_from_raw(1).to_float()).bits() == 0x3c800000) # 0.015625
test "pixel_units: to_double_raw_minus_97":
# C++: CSSPixels::from_raw(-97).to_double()
assert((css_pixels_from_raw(-97).to_double()).bits() == 0xbff8400000000000) # -1.515625
test "pixel_units: smallest_positive":
# C++: CSSPixels::smallest_positive_value().raw_value()
assert((i64)(css_pixels_smallest_positive_value().raw_value()) == 1)
test "pixel_units: min_is_saturated":
# C++: CSSPixels::min().might_be_saturated()
assert((css_pixels_min().might_be_saturated()) == true)
test "pixel_units: max_raw":
# C++: CSSPixels::max().raw_value()
assert((i64)(css_pixels_max().raw_value()) == 2147483647)
test "pixel_units: increment":
# C++: CSSPixels a = CSSPixels::from_raw(5); ++a; a.raw_value()
var a = css_pixels_from_raw(5)
_ = css_pixels_inc(&a)
assert((i64)(a.raw_value()) == 69)
test "pixel_units: decrement_saturates":
# C++: CSSPixels a = CSSPixels::min(); --a; a.raw_value()
var a = css_pixels_min()
_ = css_pixels_dec(&a)
assert((i64)(a.raw_value()) == -2147483648)
test "pixel_units: cmp_less":
# C++: (CSSPixels(1) <=> CSSPixels(2))
assert((i64)(css_pixels_from_int(1).cmp(css_pixels_from_int(2))) == -1)
test "pixel_units: cmp_equal":
# C++: (CSSPixels(2) <=> CSSPixels(2))
assert((i64)(css_pixels_from_int(2).cmp(css_pixels_from_int(2))) == 0)
test "pixel_units: unary_minus":
# C++: (-CSSPixels::from_raw(77)).raw_value()
assert((i64)(css_pixels_from_raw(77).neg().raw_value()) == -77)
test "pixel_units: unary_plus":
# C++: (+CSSPixels::from_raw(-77)).raw_value()
let v = css_pixels_from_raw(-77)
assert((i64)(css_pixels_add(&v).raw_value()) == -77)
test "pixel_units: mul_negative_rounding":
# C++: (CSSPixels::from_raw(-65) * CSSPixels::from_raw(96)).raw_value()
assert((i64)(css_pixels_from_raw(-65).mul(css_pixels_from_raw(96)).raw_value()) == -98)
test "pixel_units: mul_round_to_even_down":
# C++: (CSSPixels::from_raw(0b1000001) * CSSPixels::from_raw(0b100000)).raw_value()
assert((i64)(css_pixels_from_raw(0b1000001).mul(css_pixels_from_raw(0b100000)).raw_value()) == 32)
test "pixel_units: mul_saturates":
# C++: (CSSPixels(100000) * CSSPixels(100000)).raw_value()
assert((i64)(css_pixels_from_int(100000).mul(css_pixels_from_int(100000)).raw_value()) == 2147483647)
test "pixel_units: sub_saturates":
# C++: (CSSPixels::min() - CSSPixels(1)).raw_value()
assert((i64)(css_pixels_min().sub(css_pixels_from_int(1)).raw_value()) == -2147483648)
test "pixel_units: div_assign_multiplies":
# C++: CSSPixels a(6); a /= CSSPixels(2); a.raw_value()
var a = css_pixels_from_int(6)
_ = css_pixels_div_assign(&a, css_pixels_from_int(2))
assert((i64)(a.raw_value()) == 768)
test "pixel_units: mul_assign_fraction":
# C++: CSSPixels a(10); a *= CSSPixels(1) / CSSPixels(3); a.raw_value()
var a = css_pixels_from_int(10)
_ = css_pixels_mul_assign_css_pixel_fraction(&a, css_pixels_from_int(1).div(css_pixels_from_int(3)))
assert((i64)(a.raw_value()) == 213)
test "pixel_units: div_by_fraction":
# C++: (CSSPixels(10) / (CSSPixels(1) / CSSPixels(3))).raw_value()
assert((i64)(css_pixels_from_int(10).div_fraction(css_pixels_from_int(1).div(css_pixels_from_int(3))).raw_value()) == 1920)
test "pixel_units: fraction_to_css_pixels":
# C++: CSSPixels(CSSPixels(10) / CSSPixels(3)).raw_value()
let f = css_pixels_from_int(10).div(css_pixels_from_int(3))
assert((i64)(css_pixel_fraction_to_css_pixels(&f).raw_value()) == 213)
test "pixel_units: fraction_negative":
# C++: CSSPixels(CSSPixels(-10) / CSSPixels(3)).raw_value()
let f = css_pixels_from_int(-10).div(css_pixels_from_int(3))
assert((i64)(css_pixel_fraction_to_css_pixels(&f).raw_value()) == -213)
test "pixel_units: fraction_neg":
# C++: auto f = -(CSSPixels(10) / CSSPixels(3)); CSSPixels(f).raw_value()
let g = css_pixels_from_int(10).div(css_pixels_from_int(3))
let f = css_pixel_fraction_neg(&g)
assert((i64)(css_pixel_fraction_to_css_pixels(&f).raw_value()) == -213)
test "pixel_units: fraction_minus":
# C++: ((CSSPixels(10) / CSSPixels(3)) - CSSPixels(1)).raw_value()
let f = css_pixels_from_int(10).div(css_pixels_from_int(3))
assert((i64)(css_pixel_fraction_sub(&f, css_pixels_from_int(1)).raw_value()) == 149)
test "pixel_units: fraction_plus":
# C++: ((CSSPixels(10) / CSSPixels(3)) + CSSPixels(1)).raw_value()
let f = css_pixels_from_int(10).div(css_pixels_from_int(3))
assert((i64)(css_pixel_fraction_add(&f, css_pixels_from_int(1)).raw_value()) == 277)
test "pixel_units: fraction_cmp_equal":
# C++: ((CSSPixels(1) / CSSPixels(3)) <=> (CSSPixels(2) / CSSPixels(6)))
let f = css_pixels_from_int(1).div(css_pixels_from_int(3))
assert((i64)(css_pixel_fraction_cmp_css_pixel_fraction(&f, css_pixels_from_int(2).div(css_pixels_from_int(6)))) == 0)
test "pixel_units: fraction_cmp_int":
# C++: ((CSSPixels(7) / CSSPixels(3)) <=> 2)
let f = css_pixels_from_int(7).div(css_pixels_from_int(3))
assert((i64)(css_pixel_fraction_cmp_int(&f, 2)) == 1)
test "pixel_units: fraction_to_float":
# C++: (CSSPixels(1) / CSSPixels(3)).to_float()
let f = css_pixels_from_int(1).div(css_pixels_from_int(3))
assert((css_pixel_fraction_to_float(&f)).bits() == 0x3eaaaaab) # 0.333333343
test "pixel_units: fraction_to_double":
# C++: (CSSPixels(1) / CSSPixels(3)).to_double()
let f = css_pixels_from_int(1).div(css_pixels_from_int(3))
assert((css_pixel_fraction_to_double(&f)).bits() == 0x3fd5555555555555) # 0.33333333333333331
test "pixel_units: fraction_to_int":
# C++: (CSSPixels(-7) / CSSPixels(2)).to_int()
let f = css_pixels_from_int(-7).div(css_pixels_from_int(2))
assert((i64)(css_pixel_fraction_to_int(&f)) == -3)
test "pixel_units: fraction_from_ints":
# C++: CSSPixelFraction f(7, 2); CSSPixels(f).raw_value()
var f: CssPixelFraction
css_pixel_fraction_construct_int(&f, 7, 2)
assert((i64)(css_pixel_fraction_to_css_pixels(&f).raw_value()) == 224)
test "pixel_units: fraction_from_doubles_tiny_denominator":
# C++: CSSPixelFraction f(1.0, 0.001); CSSPixels(f).raw_value()
var f: CssPixelFraction
css_pixel_fraction_construct_f64(&f, 1.0, 0.001)
assert((i64)(css_pixel_fraction_to_css_pixels(&f).raw_value()) == 64000)
test "pixel_units: fraction_saturated":
# C++: (CSSPixels::from_raw(0x3FFFFFFF) / CSSPixels(0.25)).might_be_saturated()
let f = css_pixels_from_raw(0x3FFFFFFF).div(css_pixels_from_f64(0.25))
assert((css_pixel_fraction_might_be_saturated(&f)) == true)
test "pixel_units: scaled_f32":
# C++: CSSPixels(3).scaled(0.3f).raw_value()
let v = css_pixels_from_int(3)
assert((i64)(css_pixels_scaled_f32(&v, 0.3).raw_value()) == 58)
test "pixel_units: scaled_f64":
# C++: CSSPixels(3).scaled(1.0 / 3.0).raw_value()
let v = css_pixels_from_int(3)
assert((i64)(css_pixels_scaled_f64(&v, 1.0 / 3.0).raw_value()) == 64)
test "pixel_units: eq_float":
# C++: (CSSPixels::from_raw(96) == 1.5f)
assert((eq_css_pixels_f32(css_pixels_from_raw(96), 1.5)) == true)
test "pixel_units: eq_double":
# C++: (CSSPixels::from_raw(97) == 1.5)
assert((eq_css_pixels_f64(css_pixels_from_raw(97), 1.5)) == false)
test "pixel_units: gt_int":
# C++: (CSSPixels::from_raw(65) > 1)
assert((gt_css_pixels_int(css_pixels_from_raw(65), 1)) == true)
test "pixel_units: gt_float":
# C++: (CSSPixels::from_raw(64) > 1.0f)
assert((gt_css_pixels_f32(css_pixels_from_raw(64), 1.0)) == false)
test "pixel_units: lt_int":
# C++: (CSSPixels::from_raw(-1) < 0)
assert((lt_int(css_pixels_from_raw(-1), 0)) == true)
test "pixel_units: lt_double":
# C++: (CSSPixels::from_raw(-1) < -0.01)
assert((lt_f64(css_pixels_from_raw(-1), -0.01)) == true)
test "pixel_units: mul_int":
# C++: (CSSPixels::from_raw(33) * 3).raw_value()
assert((i64)(mul_css_pixels_int(css_pixels_from_raw(33), 3).raw_value()) == 99)
test "pixel_units: mul_float":
# C++: (CSSPixels::from_raw(33) * 0.1f)
assert((mul_css_pixels_f32(css_pixels_from_raw(33), 0.1)).bits() == 0x3d533333) # 0.0515624993
test "pixel_units: int_mul":
# C++: (3 * CSSPixels::from_raw(33)).raw_value()
assert((i64)(mul_int_css_pixels(3, css_pixels_from_raw(33)).raw_value()) == 99)
test "pixel_units: double_mul":
# C++: (0.1 * CSSPixels::from_raw(33))
assert((mul_f64(0.1, css_pixels_from_raw(33))).bits() == 0x3faa666666666667) # 0.051562500000000004
test "pixel_units: div_int":
# C++: CSSPixels(CSSPixels(10) / 4).raw_value()
let f = div_css_pixels_int(css_pixels_from_int(10), 4)
assert((i64)(css_pixel_fraction_to_css_pixels(&f).raw_value()) == 160)
test "pixel_units: div_float":
# C++: (CSSPixels(10) / 3.0f)
assert((div_css_pixels_f32(css_pixels_from_int(10), 3.0)).bits() == 0x40555555) # 3.33333325
test "pixel_units: abs_negative":
# C++: abs(CSSPixels::from_raw(-5)).raw_value()
assert((i64)(abs_css_pixels(css_pixels_from_raw(-5)).raw_value()) == 5)
test "pixel_units: floor_negative_raw":
# C++: floor(CSSPixels::from_raw(-1)).raw_value()
assert((i64)(floor(css_pixels_from_raw(-1)).raw_value()) == -64)
test "pixel_units: ceil_negative_raw":
# C++: ceil(CSSPixels::from_raw(-65)).raw_value()
assert((i64)(ceil(css_pixels_from_raw(-65)).raw_value()) == -64)
test "pixel_units: round_half_negative":
# C++: round(CSSPixels::from_raw(-32)).raw_value()
assert((i64)(round(css_pixels_from_raw(-32)).raw_value()) == -64)
test "pixel_units: round_just_below_half":
# C++: round(CSSPixels::from_raw(31)).raw_value()
assert((i64)(round(css_pixels_from_raw(31)).raw_value()) == 0)
test "pixel_units: sqrt_2":
# C++: sqrt(CSSPixels(2)).raw_value()
assert((i64)(sqrt(css_pixels_from_int(2)).raw_value()) == 91)
test "pixel_units: square_distance_between":
# C++: square_distance_between(CSSPixelPoint(1, 2), CSSPixelPoint(CSSPixels(4.5), CSSPixels(-2))).raw_value()
assert((i64)(square_distance_between(CssPixelPoint(css_pixels_from_int(1), css_pixels_from_int(2)), CssPixelPoint(css_pixels_from_f64(4.5), css_pixels_from_int(-2))).raw_value()) == 1808)
test "pixel_units: constrained_x":
# C++: p.x().raw_value()
let p = constrained(CssPixelPoint(css_pixels_from_int(100), css_pixels_from_int(-5)), CssPixelRect(CssPixelPoint(css_pixels_from_int(0), css_pixels_from_int(0)), CssPixelSize(css_pixels_from_int(10), css_pixels_from_int(10))))
assert((i64)(css_pixel_point_x(&p).raw_value()) == 576)
test "pixel_units: constrained_y":
# C++: p.y().raw_value()
let p = constrained(CssPixelPoint(css_pixels_from_int(100), css_pixels_from_int(-5)), CssPixelRect(CssPixelPoint(css_pixels_from_int(0), css_pixels_from_int(0)), CssPixelSize(css_pixels_from_int(10), css_pixels_from_int(10))))
assert((i64)(css_pixel_point_y(&p).raw_value()) == 0)
test "pixel_units: rect_to_rounded":
# C++: r.x().raw_value() * 1000000 + r.y().raw_value() * 10000 + r.width().raw_value() * 100 + r.height().raw_value()
let source = CssPixelRect(CssPixelPoint(css_pixels_from_f64(1.5), css_pixels_from_f64(-1.5)), CssPixelSize(css_pixels_from_f64(0.49), css_pixels_from_f64(2.51)))
let r = css_pixel_rect_to_rounded(&source)
assert((i64)((i64)css_pixel_rect_x(&r).raw_value() * 1000000 + (i64)css_pixel_rect_y(&r).raw_value() * 10000 + (i64)css_pixel_rect_width(&r).raw_value() * 100 + (i64)css_pixel_rect_height(&r).raw_value()) == 126720192)
test "pixel_units: hash":
# C++: Traits<CSSPixels>::hash(CSSPixels(3))
var traits: CssPixelsTraits
let v = css_pixels_from_int(3)
assert((i64)(traits.hash_of(&v)) == 2813460772)
test "pixel_units: device_pixels_div":
# C++: (DevicePixels(-7) / 2).value()
assert((i64)(div_i32(-7, 2)) == -3)
test "pixel_units: device_pixels_rem":
# C++: (DevicePixels(-7) % 2).value()
assert((i64)(rem(-7, 2)) == -1)
test "pixel_units: device_pixels_mul":
# C++: (3 * DevicePixels(-7)).value()
assert((i64)(mul_t_i32(3, -7)) == -21)
test "pixel_units: device_pixels_abs":
# C++: abs(DevicePixels(-7)).value()
assert((i64)(abs_i32(-7)) == 7)
test "pixel_units: device_pixels_lt":
# C++: (DevicePixels(-7) < 0)
assert((lt_distinct_numeric(-7, 0)) == true)