Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / html / tests_html_media_2.lucb

#==============================================================================================
#
#   tests_html_media_2 - tests of the media elements' track lists, text tracks, TimeRanges,
#                        MediaError, and of LibMedia's stream and playback manager seam
#
#   DESCRIPTION:
#       Ladybird has no unit tests for these files (they are tested through Tests/LibWeb/Text,
#       which needs scripting), so these pin the C++ behaviour a page without scripting
#       reaches: the element factory's media elements with their (empty) track lists, a
#       <track>'s text track and its readiness observer, HTML's TimeRanges and MediaError,
#       IncrementallyPopulatedStream's chunks, and the PlaybackManager of the seam reporting
#       every media source as an unsupported format on the event loop.
#
#       Copyright (c) 2026 the luce-browser authors.
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Track lists =============================================================================

## A media element made by the element factory (initialized: its track lists exist).
func test_media_create(document: DomDocument*, local_name: str) -> HtmlMediaElement*:
    return as_html_media_element(test_html_create(document, local_name))

test "media elements from the factory: empty audio, video and text track lists":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    _ = realm
    for name in ["video", "audio"]:
        let element = test_media_create(document, name)
        defer test_media_forget(element)
        let audio_tracks = html_media_element_audio_tracks(element)
        let video_tracks = html_media_element_video_tracks(element)
        let text_tracks = html_media_element_text_tracks(element)
        assert(is_html_audio_track_list(audio_tracks) and is_html_video_track_list(video_tracks) and is_html_text_track_list(text_tracks))
        assert(html_audio_track_list_length(audio_tracks) == 0 and not html_audio_track_list_has_enabled_track(audio_tracks))
        assert(html_video_track_list_length(video_tracks) == 0 and html_video_track_list_selected_index(video_tracks) == -1)
        assert(video_tracks.m_media_element == element)
        assert(html_text_track_list_length(text_tracks) == 0)
        assert(html_audio_track_list_get_track_by_id(audio_tracks, ak.sv("1")) == none and html_text_track_list_get_track_by_id(text_tracks, ak.sv("")) == none)
        # forget_media_resource_specific_tracks on empty lists.
        html_audio_track_list_remove_all_tracks(audio_tracks)
        html_video_track_list_remove_all_tracks(video_tracks)

# mark: Text tracks =============================================================================

## Counts the readiness states a TextTrackObserver reports.
struct TestReadinessLog:
    var calls: i32
    var last: HtmlTextTrackReadinessState

    static func observe(context: void*?, state: HtmlTextTrackReadinessState):
        let log = (TestReadinessLog*)(context else trap("no log"))
        log.calls += 1
        log.last = state

test "TextTrack: defaults, kinds from the kind attribute, setters and the readiness observer":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    _ = document
    let track = html_text_track_create(realm)
    assert(html_text_track_kind(track) == BindTextTrackKind.subtitles and html_text_track_mode(track) == BindTextTrackMode.disabled)
    assert(html_text_track_readiness_state(track) == HtmlTextTrackReadinessState.not_loaded)

    let kinds: (str, BindTextTrackKind)[8] = [("", BindTextTrackKind.subtitles), ("SUBTITLES", BindTextTrackKind.subtitles), ("captions", BindTextTrackKind.captions),
                                              ("Descriptions", BindTextTrackKind.descriptions), ("chapters", BindTextTrackKind.chapters), ("metadata", BindTextTrackKind.metadata),
                                              ("karaoke", BindTextTrackKind.metadata), ("caption", BindTextTrackKind.metadata)]
    for (value, kind) in kinds:
        assert(html_text_track_kind_from_string(ak.string_from_str(value)) == kind)

    html_text_track_set_id(track, ak.string_from_str("en-captions"))
    html_text_track_set_mode(track, BindTextTrackMode.hidden)
    let id = html_text_track_id(track)
    assert(ak.string_eq_string_view(&id, ak.sv("en-captions")) and html_text_track_mode(track) == BindTextTrackMode.hidden)

    var log = TestReadinessLog(calls = 0, last = HtmlTextTrackReadinessState.not_loaded)
    let observer = realm_create_html_text_track_observer(realm, realm, track)
    assert(ak.vector_size(&track.m_observers) == 1)
    html_text_track_set_readiness_state(track, HtmlTextTrackReadinessState.loading)
    assert(log.calls == 0, "no callback yet")
    html_text_track_observer_set_track_readiness_observer(observer, ak.Function1[HtmlTextTrackReadinessState, unit](call = TestReadinessLog.observe, context = &log))
    html_text_track_set_readiness_state(track, HtmlTextTrackReadinessState.loaded)
    assert(log.calls == 1 and log.last == HtmlTextTrackReadinessState.loaded)
    html_text_track_observer_set_track_readiness_observer(observer, none)
    html_text_track_set_readiness_state(track, HtmlTextTrackReadinessState.failed_to_load)
    assert(log.calls == 1 and html_text_track_readiness_state(track) == HtmlTextTrackReadinessState.failed_to_load)

    # Finalizing the observer unregisters it from its track (TextTrackObserver::finalize).
    html_text_track_observer_finalize_impl(observer.cell())
    assert(ak.vector_is_empty(&track.m_observers))
    # The collection that destroys the VM finalizes it again: it gets PlatformObject's table.
    observer.cell().vtable = (const gc.CellVTable*)&bind_platform_object_vtable

test "<track> from the factory: its text track takes the kind, label and language attributes":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    _ = realm
    let element = as_html_track_element(test_html_create(document, "track"))
    let track = html_track_element_text_track(element)
    assert(html_text_track_kind(track) == BindTextTrackKind.subtitles)
    dom_element_set_attribute_value(element.dom_element(), ak.fly_string_from_str("kind"), ak.string_from_str("Captions"))
    dom_element_set_attribute_value(element.dom_element(), ak.fly_string_from_str("label"), ak.string_from_str("English"))
    dom_element_set_attribute_value(element.dom_element(), ak.fly_string_from_str("srclang"), ak.string_from_str("en"))
    let label = html_text_track_label(track)
    let language = html_text_track_language(track)
    assert(html_text_track_kind(track) == BindTextTrackKind.captions)
    assert(ak.string_eq_string_view(&label, ak.sv("English")) and ak.string_eq_string_view(&language, ak.sv("en")))

# mark: TimeRanges and MediaError ===============================================================

test "HTML TimeRanges: ranges in order, in_range and IndexSizeError past the end; MediaError":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    _ = document
    let ranges = realm_create_html_time_ranges(realm, realm)
    assert(html_time_ranges_length(ranges) == 0 and not html_time_ranges_in_range(ranges, 0.0))
    html_time_ranges_add_range(ranges, 0.0, 1.5)
    html_time_ranges_add_range(ranges, 3.0, 4.0)
    assert(html_time_ranges_length(ranges) == 2)
    assert((html_time_ranges_start(ranges, 1) else trap("start")) == 3.0 and (html_time_ranges_end(ranges, 0) else trap("end")) == 1.5)
    assert(html_time_ranges_in_range(ranges, 1.5) and html_time_ranges_in_range(ranges, 3.0) and not html_time_ranges_in_range(ranges, 2.0))
    _ = html_time_ranges_start(ranges, 2) catch failure:
        let name = test_media_exception_name()
        assert(ak.fly_string_eq_string_view(&name, ak.sv("IndexSizeError")))
    _ = html_time_ranges_end(ranges, 7) catch failure:
        let name = test_media_exception_name()
        assert(ak.fly_string_eq_string_view(&name, ak.sv("IndexSizeError")))

    let error_ = realm_create_html_media_error(realm, realm, HtmlMediaErrorCode.src_not_supported, ak.string_from_str("Unsupported format"))
    let message = html_media_error_message(error_)
    assert(html_media_error_code(error_) == HtmlMediaErrorCode.src_not_supported and ak.string_eq_string_view(&message, ak.sv("Unsupported format")))

# mark: LibMedia ================================================================================

## Records the offsets an IncrementallyPopulatedStream asks for.
struct TestDataRequests:
    var calls: i32
    var offset: u64

    static func request(context: void*?, offset: u64):
        let requests = (TestDataRequests*)(context else trap("no requests"))
        requests.calls += 1
        requests.offset = offset

test "IncrementallyPopulatedStream: chunks join, a covered chunk asks for the data after it, close sets the size":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    _ = realm
    _ = document
    let previous_event_loop = core_event_loop_installed
    defer core_event_loop_installed = previous_event_loop
    let event_loop = install_test_event_loop()
    let bytes: u8[16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
    let stream = media_incrementally_populated_stream_create_empty()
    var requests = TestDataRequests(calls = 0, offset = 0)
    media_incrementally_populated_stream_set_data_request_callback(stream, ak.Function1[u64, unit](call = TestDataRequests.request, context = &requests))
    assert(media_incrementally_populated_stream_expected_size(stream) == none)

    media_incrementally_populated_stream_add_chunk_at(stream, 0, bytes[0..<10])
    media_incrementally_populated_stream_add_chunk_at(stream, 10, bytes[10..<16])
    assert(media_incrementally_populated_stream_next_chunk_start(stream) == 16)
    let joined = ak.red_black_tree_find(&stream.m_chunks, 0) else trap("no chunk at 0")
    assert(ak.byte_buffer_size(&joined.m_data) == 16 and ak.byte_buffer_bytes(&joined.m_data)[15] == 15)

    media_incrementally_populated_stream_add_chunk_at(stream, 100, bytes[0..<4])
    assert(ak.red_black_tree_find(&stream.m_chunks, 100) != none and media_incrementally_populated_stream_next_chunk_start(stream) == 104)

    # A chunk inside data the stream has: skip until after it, asking (on the event loop) for the data from 16.
    media_incrementally_populated_stream_add_chunk_at(stream, 2, bytes[2..<5])
    assert(requests.calls == 0)
    _ = event_loop.pump(CoreEventLoopPumpMode.wait_for_events)
    assert(requests.calls == 1 and requests.offset == 16)
    assert(media_incrementally_populated_stream_next_chunk_start(stream) == 16)

    media_incrementally_populated_stream_set_expected_size(stream, 200)
    assert(media_incrementally_populated_stream_expected_size(stream) == 200)
    media_incrementally_populated_stream_close(stream)
    assert(media_incrementally_populated_stream_expected_size(stream) == 16)

## Records the unsupported-format errors a PlaybackManager reports.
struct TestFormatErrors:
    var calls: i32
    var category: MediaDecoderErrorCategory

    static func report(context: void*?, error_: MediaDecoderError):
        let errors = (TestFormatErrors*)(context else trap("no errors"))
        errors.calls += 1
        errors.category = media_decoder_error_category(&error_)

test "PlaybackManager without demuxers: Starting state, and every source an unsupported format on the event loop":
    let (vm, realm, document) = test_html_setup()
    defer web_test_destroy_vm(vm)
    _ = realm
    _ = document
    let previous_event_loop = core_event_loop_installed
    defer core_event_loop_installed = previous_event_loop
    let event_loop = install_test_event_loop()

    let manager = media_playback_manager_create()
    assert(media_playback_manager_state(manager) == MediaPlaybackState.starting)
    assert(media_playback_manager_available_data(manager) == MediaAvailableData.none_)
    assert(not media_playback_manager_is_playing(manager))
    media_playback_manager_play(manager)
    assert(media_playback_manager_is_playing(manager))
    media_playback_manager_pause(manager)
    assert(not media_playback_manager_is_playing(manager))
    let current_time = media_playback_manager_current_time(manager)
    let buffered = media_playback_manager_buffered_time_ranges(manager)
    assert(ak.duration_is_zero(&current_time) and media_time_ranges_is_empty(&buffered))
    let audio_tracks = media_playback_manager_audio_tracks(manager)
    assert(ak.vector_is_empty(&audio_tracks) and media_playback_manager_preferred_video_track(manager) == none)

    var errors = TestFormatErrors(calls = 0, category = MediaDecoderErrorCategory.unknown)
    media_playback_manager_set_on_unsupported_format_error(manager, ak.Function1[MediaDecoderError, unit](call = TestFormatErrors.report, context = &errors))
    media_playback_manager_add_media_source(manager, media_incrementally_populated_stream_create_empty())
    assert(errors.calls == 0, "the error is reported on the event loop")
    _ = event_loop.pump(CoreEventLoopPumpMode.wait_for_events)
    assert(errors.calls == 1 and errors.category == MediaDecoderErrorCategory.not_implemented)

    # A manager destroyed before its error is reported says nothing (the weak link is revoked).
    let second = media_playback_manager_create()
    media_playback_manager_set_on_unsupported_format_error(second, ak.Function1[MediaDecoderError, unit](call = TestFormatErrors.report, context = &errors))
    media_playback_manager_add_media_source(second, media_incrementally_populated_stream_create_empty())
    media_playback_manager_destruct(second)
    _ = event_loop.pump(CoreEventLoopPumpMode.wait_for_events)
    assert(errors.calls == 1)