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(¤t_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)