Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-render

Source of release 0.6.1

0.6.1 / 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)