dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / loader / tests_loader_3.lucb
#==============================================================================================
#
# tests_loader_3 - http: through the in-process RequestClient and ResourceLoader on a
# loopback server, images through the luce-png/luce-jpeg plugin, BitmapDecodedImageData,
# NavigationObserver and preloaded resources
#
# DESCRIPTION:
# The http: tests start a server on 127.0.0.1 (luce-std net, its own thread, the C heap)
# that answers each connection with a canned HTTP/1.x response chosen by the request's
# path: Content-Length, chunked and until-close bodies, Content-Encodings, a 1xx head
# before the final one, a redirect, an echo of a POST body and a truncated body. The
# image tests decode PNG and JPEG fixtures (tests/libweb) and a small RGBA PNG with
# partial alpha (its premultiplied pixels computed as Skia rounds) through the plugin.
#
#==============================================================================================
import thread
# mark: A loopback HTTP server ==================================================================
## The server's state, in the C heap: its listener, how many connections it serves, and the head and body of
## the last request it received.
struct LoaderTestServer:
var listener: net.Listener
var port: u16
var connections: usize
var last_request: u8[4096]
var last_request_length: usize
## The canned response to a request for `target`.
func loader_test_server_response(target: str) -> const u8[]:
if target == "/fixed":
return b"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 5\r\nX-Test: yes\r\n\r\nhello"
if target == "/chunked?x=1":
return b"HTTP/1.1 200 Fine\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nhello\r\n6\r\n world\r\n0\r\n\r\n"
if target == "/gzip":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: gzip\r\nContent-Length: 41\r\n\r\n\x1F\x8B\x08\x00\x00\x00\x00\x00\x02\xFF\xCB\x48\xCD\xC9\xC9\x57\x48\xAF\xCA\x2C\x50\x28\xCF\x2F\xCA\x49\xD1\x51\xC8\x40\x13\x01\x00\xA0\x7D\xCC\x30\x22\x00\x00\x00"
if target == "/deflate":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: deflate\r\nContent-Length: 27\r\n\r\n\x78\x9C\xCB\x48\xCD\xC9\xC9\x57\x48\x49\x4D\xCB\x49\x2C\x49\x55\x28\xCF\x2F\xCA\x49\x01\x00\x48\xA9\x07\x52"
# Content-Encoding (tests_loader_4.lucb).
if target == "/br":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: br\r\nContent-Length: 33\r\n\r\n\x1B\x25\x00\xF8\x1D\xA9\x53\x9F\xBB\x70\x2D\x56\x86\x26\x27\x41\xD8\xE8\x92\x2D\xED\xAD\x94\x19\xA8\x46\x78\xA9\x99\xF1\xAB\x1D\x1C"
if target == "/stacked":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: gzip, br\r\nContent-Length: 44\r\n\r\n\x8B\x13\x80\x1F\x8B\x08\x00\x00\x00\x00\x00\x02\xFF\x2B\x2E\x49\x4C\xCE\x4E\x4D\x51\x48\xAF\xCA\x2C\x50\x28\xC9\x48\xCD\x53\x48\x2A\x02\x00\x1B\x1A\x94\x21\x14\x00\x00\x00\x03"
if target == "/stacked-fields":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: GZIP\r\nContent-Length: 44\r\nContent-Encoding: identity ,br\r\n\r\n\x8B\x13\x80\x1F\x8B\x08\x00\x00\x00\x00\x00\x02\xFF\x2B\x2E\x49\x4C\xCE\x4E\x4D\x51\x48\xAF\xCA\x2C\x50\x28\xC9\x48\xCD\x53\x48\x2A\x02\x00\x1B\x1A\x94\x21\x14\x00\x00\x00\x03"
if target == "/identity":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: identity, identity, none, identity\r\nContent-Length: 5\r\n\r\nplain"
if target == "/too-many":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: identity, identity, identity, identity, identity\r\nContent-Length: 5\r\n\r\nplain"
if target == "/raw-deflate":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: deflate\r\nContent-Length: 19\r\n\r\n\xCB\x48\xCD\xC9\xC9\x57\x28\x4A\x2C\x57\x48\x49\x4D\xCB\x49\x2C\x49\x05\x00"
if target == "/x-gzip-zlib":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: x-gzip\r\nContent-Length: 24\r\n\r\n\x78\x9C\xAB\xCA\xC9\x4C\x52\xC8\xCC\x2B\xCE\x4C\x49\x55\x48\xAF\xCA\x2C\x00\x00\x34\x64\x06\x28"
if target == "/unknown":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: zstd\r\nContent-Length: 3\r\n\r\nabc"
if target == "/unknown-empty":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: zstd\r\nContent-Length: 0\r\n\r\n"
if target == "/not-modified":
return b"HTTP/1.1 304 Not Modified\r\nContent-Encoding: a, b, c, d, e\r\n\r\n"
if target == "/corrupt-gzip":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: gzip\r\nContent-Length: 36\r\n\r\n\x1F\x8B\x08\x00\x00\x00\x00\x00\x02\xFF\xCB\x48\xCD\xC9\xC9\x57\x48\xAF\xCA\x2C\x50\x28\xCF\x2F\xCA\x49\x01\x00\x94\x7D\xE8\xB7\x10\x00\x00\x00"
if target == "/corrupt-br":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: br\r\nContent-Length: 33\r\n\r\n\xE4\x25\x00\xF8\x1D\xA9\x53\x9F\xBB\x70\x2D\x56\x86\x26\x27\x41\xD8\xE8\x92\x2D\xED\xAD\x94\x19\xA8\x46\x78\xA9\x99\xF1\xAB\x1D\x1C"
if target == "/trailing-gzip":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: gzip\r\nContent-Length: 40\r\n\r\n\x1F\x8B\x08\x00\x00\x00\x00\x00\x02\xFF\xCB\x48\xCD\xC9\xC9\x57\x48\xAF\xCA\x2C\x50\x28\xCF\x2F\xCA\x49\x01\x00\x6B\x7D\xE8\xB7\x10\x00\x00\x00\x6A\x75\x6E\x6B"
if target == "/truncated-br":
return b"HTTP/1.1 200 OK\r\nContent-Encoding: br\r\nContent-Length: 28\r\n\r\n\x1B\x57\x00\xF8\x45\x37\x86\xA9\x2E\x57\x5F\x10\x44\x41\x66\x30\xAE\x8A\x12\xBA\xDC\x6B\x13\x86\x43\x77\x58\x09"
if target == "/eof":
return b"HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\nuntil close"
if target == "/continue":
return b"HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 404 Not Found\r\nContent-Length: 2\r\n\r\nno"
if target == "/redirect":
return b"HTTP/1.1 302 Found\r\nLocation: /fixed\r\nContent-Length: 0\r\n\r\n"
if target == "/truncated":
return b"HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\nabc"
return b"HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\n\r\n"
## The value of the Content-Length line of a request head, or zero.
func loader_test_server_content_length(head: const u8[]) -> usize:
let name = "content-length:"
var index: usize = 0
while index + name.length < head.length:
var matches = true
for offset in 0..<name.length:
var byte = head[index + offset]
if byte >= 'A' and byte <= 'Z':
byte += 32
if byte != name.bytes[offset]:
matches = false
break
if matches:
var value: usize = 0
var at = index + name.length
while at < head.length and head[at] == ' ':
at += 1
while at < head.length and head[at] >= '0' and head[at] <= '9':
value = value * 10 + (usize)(head[at] - '0')
at += 1
return value
index += 1
return 0
## The server thread: serves its connections one after another.
func loader_test_server_main(context: void*?):
let server = (LoaderTestServer*)(context else trap("no server"))
for _ in 0..<server.connections:
var connection = server.listener.accept() catch:
return
var used: usize = 0
var head_end: usize? = none
while head_end == none and used < server.last_request.length:
let count = connection.read(server.last_request[used..]) catch:
break
if count == 0:
break
used += count
head_end = net.http_head_end(server.last_request[..<used])
if let end = head_end:
let body_length = loader_test_server_content_length(server.last_request[..<end])
while used < end + body_length and used < server.last_request.length:
let count = connection.read(server.last_request[used..]) catch:
break
if count == 0:
break
used += count
server.last_request_length = used
# The target: between the first two spaces of the request line.
var first: usize = 0
while first < end and server.last_request[first] != ' ':
first += 1
var second = first + 1
while second < end and server.last_request[second] != ' ':
second += 1
let target = (str)server.last_request[first + 1..<second]
if target == "/echo":
var head: u8[64] = ---
let prefix = "HTTP/1.1 200 OK\r\nContent-Length: "
memory.copy(head, prefix.bytes, prefix.length)
var length = prefix.length
let body = server.last_request[end..<used]
head[length] = '0' + (u8)(body.length // 10)
head[length + 1] = '0' + (u8)(body.length % 10)
head[length + 2] = '\r'
head[length + 3] = '\n'
head[length + 4] = '\r'
head[length + 5] = '\n'
length += 6
_ = connection.write(head[..<length]) catch: recover 0
_ = connection.write(body) catch: recover 0
else:
let response = loader_test_server_response(target)
_ = connection.write(response) catch: recover 0
connection.shutdown() catch:
_ = 0
connection.destroy()
## A server on 127.0.0.1 that serves `connections` connections, running on its own thread.
func loader_test_server_start(connections: usize) -> (LoaderTestServer*, thread.Handle):
with memory.heap:
let listener = net.Listener.bind(net.SocketAddress.loopback(0)) else trap("the server's listener")
let address = listener.address() else trap("the server's address")
let server = new LoaderTestServer(listener = listener, port = address.port, connections = connections) else trap("out of memory")
let handle = thread.spawn(loader_test_server_main, server, name = "p2d-http-server") else trap("the server's thread")
return (server, handle)
## The end of a server: its thread joined, its listener closed.
func loader_test_server_stop(server: LoaderTestServer*, handle: thread.Handle):
var joined = handle
joined.join() else trap("the server's thread joins")
server.listener.destroy()
free(server) in memory.heap
## `http://127.0.0.1:<port><path>`.
func loader_test_server_url(server: const LoaderTestServer*, path: str) -> ak.ByteString:
var builder = ak.string_builder_new()
ak.string_builder_append(&builder, "http://127.0.0.1:")
loader_test_append_number(&builder, (i64)server.port)
ak.string_builder_append(&builder, path)
return ak.string_builder_to_byte_string(&builder)
## The last request the server received, as text.
func loader_test_server_last_request(server: const LoaderTestServer*) -> ak.StringView:
return ak.string_view_from_bytes(server.last_request[..<server.last_request_length])
# mark: http: ===================================================================================
test "the in-process RequestClient: http: requests on a loopback server: bodies, encodings, 1xx, redirects, POST, errors":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
var event_loop = LoaderTestEventLoop()
loader_test_install_event_loop(&event_loop)
defer loader_test_remove_event_loop()
let client = in_process_request_client_create(vm_heap(vm))
let (server, handle) = loader_test_server_start(9)
# A Content-Length body; the request's head as sent.
let fixed_url = loader_test_server_url(server, "/fixed")
let request_headers = http_header_list_create()
http_header_list_append(request_headers, http_header_create(ak.sv("Accept"), ak.sv("text/plain")))
let (fixed, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&fixed_url)), "GET", request_headers)
loader_test_drain(&event_loop)
assert(fixed.finishes == 1 and fixed.network_error == none and fixed.status_code == 200)
let fixed_reason = fixed.reason_phrase else trap("a reason phrase")
assert(ak.string_eq_string_view(&fixed_reason, ak.sv("OK")))
assert(fixed.received("hello") and fixed.total_size == 5)
let x_test = fixed.header("X-Test") else trap("the X-Test header")
assert(loader_test_byte_string_is(x_test, "yes"))
let sent = loader_test_server_last_request(server)
var expected_head = ak.string_builder_new()
ak.string_builder_append(&expected_head, "GET /fixed HTTP/1.1\r\nHost: 127.0.0.1:")
loader_test_append_number(&expected_head, (i64)server.port)
ak.string_builder_append(&expected_head, "\r\nAccept: text/plain\r\nAccept-Encoding: deflate, gzip, br\r\n\r\n")
assert(ak.string_view_eq_string_view(&sent, ak.string_builder_string_view(&expected_head)))
# A chunked body (and the query in the request target), a body until the connection closes.
let chunked_url = loader_test_server_url(server, "/chunked?x=1")
let (chunked, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&chunked_url)))
let eof_url = loader_test_server_url(server, "/eof")
let (until_close, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&eof_url)))
loader_test_drain(&event_loop)
assert(chunked.finishes == 1 and chunked.network_error == none and chunked.received("hello world"))
let chunked_reason = chunked.reason_phrase else trap("a reason phrase")
assert(ak.string_eq_string_view(&chunked_reason, ak.sv("Fine")))
assert(until_close.finishes == 1 and until_close.network_error == none and until_close.received("until close"))
# gzip and deflate bodies, decoded.
let gzip_url = loader_test_server_url(server, "/gzip")
let (gzip, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&gzip_url)))
let deflate_url = loader_test_server_url(server, "/deflate")
let (deflate, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&deflate_url)))
loader_test_drain(&event_loop)
assert(gzip.finishes == 1 and gzip.network_error == none and gzip.received("hello gzip world, hello gzip world") and gzip.total_size == 34)
assert(deflate.finishes == 1 and deflate.network_error == none and deflate.received("hello deflate world"))
# A 100 Continue head before the final one; a redirect is delivered as it is (Fetch follows it).
let continue_url = loader_test_server_url(server, "/continue")
let (after_continue, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&continue_url)))
let redirect_url = loader_test_server_url(server, "/redirect")
let (redirect, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&redirect_url)))
loader_test_drain(&event_loop)
assert(after_continue.status_code == 404 and after_continue.received("no") and after_continue.network_error == none)
assert(redirect.status_code == 302 and redirect.finishes == 1 and ak.byte_buffer_size(&redirect.data) == 0)
let location = redirect.header("Location") else trap("a Location header")
assert(loader_test_byte_string_is(location, "/fixed"))
# A POST: its body and Content-Length sent, echoed.
let echo_url = loader_test_server_url(server, "/echo")
let (echo, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&echo_url)), "POST", none, b"posted body")
loader_test_drain(&event_loop)
assert(echo.finishes == 1 and echo.received("posted body"))
let posted = loader_test_server_last_request(server)
assert(ak.string_view_find_string_view(&posted, ak.sv("POST /echo HTTP/1.1\r\n")) == 0)
assert(ak.string_view_find_string_view(&posted, ak.sv("\r\nContent-Length: 11\r\n")) != none)
# A body cut short: the bytes that came, then the error.
let truncated_url = loader_test_server_url(server, "/truncated")
let (truncated, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&truncated_url)))
loader_test_drain(&event_loop)
assert(truncated.finishes == 1 and truncated.network_error == RequestsNetworkError.incomplete_content and truncated.received("abc"))
loader_test_server_stop(server, handle)
# Nothing listens on the port any more: the connection is refused.
let (refused, _) = loader_test_start(client, ak.string_view_text(ak.byte_string_view(&fixed_url)))
loader_test_drain(&event_loop)
assert(refused.finishes == 1 and refused.network_error == RequestsNetworkError.unable_to_connect and refused.headers == none)
test "ResourceLoader::load: http: through the RequestClient: the page's notifications, the active request until it completes":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
var event_loop = LoaderTestEventLoop()
loader_test_install_event_loop(&event_loop)
defer loader_test_remove_event_loop()
_ = loader_test_initialize_resource_loader(vm)
# The VM's heap is the current allocator, as the engine runs: the load's captures are managed, kept by what holds them.
let allocator: memory.Allocator = vm_heap(vm)
with allocator:
let page = loader_test_create_page(vm)
let (server, handle) = loader_test_server_start(2)
let fixed_url = loader_test_server_url(server, "/fixed")
let (load, protocol_request) = loader_test_load(vm, ak.string_view_text(ak.byte_string_view(&fixed_url)), page)
let request = protocol_request else trap("a network load answers its request")
let loader = resource_loader_the()
assert(resource_loader_pending_loads(loader) == 1 and ak.hash_map_size(&loader.m_active_requests) == 1)
assert(loader_test_network_started == 1 and load.completions == 0)
# The request is rooted while it is active: a collection keeps it.
let weak = gc.make_weak[RequestsRequest](request)
gc.heap_collect_garbage(vm_heap(vm))
assert(gc.weak_ptr(&weak) == request)
loader_test_drain(&event_loop)
assert(load.completions == 1 and load.success and loader_test_received(load, "hello"))
assert(load.status_code == 200)
let reason = load.reason_phrase else trap("a reason phrase")
assert(ak.string_eq_string_view(&reason, ak.sv("OK")))
assert(loader_test_network_finished == 1)
assert(resource_loader_pending_loads(loader) == 0 and ak.hash_map_size(&loader.m_active_requests) == 0)
# An error after the headers: on_complete hears the network error's text.
let truncated_url = loader_test_server_url(server, "/truncated")
let (truncated, _) = loader_test_load(vm, ak.string_view_text(ak.byte_string_view(&truncated_url)), page)
loader_test_drain(&event_loop)
assert(loader_test_failed_with(truncated, "Request finished with error: Connection was closed before entire response was received"))
loader_test_server_stop(server, handle)
# mark: Images ==================================================================================
## A 3x1 RGBA PNG: (200, 100, 50, 128), (10, 20, 30, 255), (255, 255, 255, 0) (written by Pillow).
let loader_test_rgba_png: u8[78] = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x01, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1B, 0xE0, 0x14, 0xB4, 0x00, 0x00, 0x00, 0x15, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, 0x63, 0x38, 0x91,
0x62, 0xD4, 0xC0, 0x25, 0x22, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0x0C, 0x00, 0x23, 0xAF, 0x06, 0x17, 0xF4, 0x45, 0xF0, 0x3C, 0x00, 0x00, 0x00,
0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82]
## The pixel at (x, y) of a decoded image's bitmap (premultiplied BGRA8888, as a u32).
func loader_test_pixel(bitmap: const gfx.Bitmap*, x: i32, y: i32) -> u32:
let row = gfx.bitmap_scanline_const(bitmap, y) else trap("a row")
return row[(usize)x]
## Whether the channel of `pixel` at `shift` is within `tolerance` of `expected`.
func loader_test_channel_near(pixel: u32, shift: u32, expected: u32, tolerance: u32) -> bool:
let value = (pixel >> shift) & 0xff
return (value - expected if value >= expected else expected - value) <= tolerance
## The bytes of a fixture of tests/libweb.
func loader_test_fixture(path: str) -> ak.ByteBuffer:
var full = ak.string_builder_new()
ak.string_builder_append(&full, "tests/libweb/")
ak.string_builder_append(&full, path)
return core_mapped_file_map(ak.string_builder_string_view(&full)) else trap("the fixture reads")
test "the luce-png/luce-jpeg ImageCodecPlugin: PNG and JPEG decoded to premultiplied BGRA8888 bitmaps":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
# Partial alpha, premultiplied with Skia's rounding.
let rgba = luce_image_codec_plugin_decode(loader_test_rgba_png) else trap("the PNG decodes")
assert(rgba.frame_count == 1 and not rgba.is_animated and rgba.session_id == 0 and ak.vector_size(&rgba.frames) == 1)
let rgba_bitmap = ak.vector_at_const(&rgba.frames, 0).bitmap else trap("a bitmap")
assert(gfx.bitmap_width(rgba_bitmap) == 3 and gfx.bitmap_height(rgba_bitmap) == 1)
assert(gfx.bitmap_format(rgba_bitmap) == gfx.BitmapFormat.bgra8888 and gfx.bitmap_alpha_type(rgba_bitmap) == gfx.AlphaType.premultiplied)
assert(loader_test_pixel(rgba_bitmap, 0, 0) == 0x80643219)
assert(loader_test_pixel(rgba_bitmap, 1, 0) == 0xff0a141e)
assert(loader_test_pixel(rgba_bitmap, 2, 0) == 0)
# A palette PNG with tRNS (smiley.png), as Pillow decodes it.
let smiley_bytes = loader_test_fixture("Ref/data/smiley.png")
let smiley = luce_image_codec_plugin_decode(ak.byte_buffer_bytes_const(&smiley_bytes)) else trap("smiley.png decodes")
let smiley_bitmap = ak.vector_at_const(&smiley.frames, 0).bitmap else trap("a bitmap")
assert(gfx.bitmap_width(smiley_bitmap) == 50 and gfx.bitmap_height(smiley_bitmap) == 50)
assert(loader_test_pixel(smiley_bitmap, 0, 0) == 0xffffa300)
assert(loader_test_pixel(smiley_bitmap, 2, 2) == 0xfefe0000)
assert(loader_test_pixel(smiley_bitmap, 3, 2) == 0xf0f00000)
assert(loader_test_pixel(smiley_bitmap, 25, 25) == 0)
# A baseline JPEG, within 4 of libjpeg's (Pillow's) samples, opaque.
let jpeg_bytes = loader_test_fixture("Text/input/wpt-import/html/canvas/element/manual/imagebitmap/resources/squares_1.jpg")
let squares = luce_image_codec_plugin_decode(ak.byte_buffer_bytes_const(&jpeg_bytes)) else trap("squares_1.jpg decodes")
let squares_bitmap = ak.vector_at_const(&squares.frames, 0).bitmap else trap("a bitmap")
assert(gfx.bitmap_width(squares_bitmap) == 160 and gfx.bitmap_height(squares_bitmap) == 320)
let center = loader_test_pixel(squares_bitmap, 80, 160)
assert(center >> 24 == 255 and loader_test_channel_near(center, 16, 129, 4) and loader_test_channel_near(center, 8, 255, 4) and loader_test_channel_near(center, 0, 129, 4))
let corner = loader_test_pixel(squares_bitmap, 159, 319)
assert(loader_test_channel_near(corner, 16, 254, 4) and loader_test_channel_near(corner, 8, 128, 4) and loader_test_channel_near(corner, 0, 129, 4))
assert(loader_test_pixel(squares_bitmap, 5, 5) == 0xff000000)
# What the plugin decodes no format of fails (platform/tests_image_codec_plugin_luce has the others).
let unsupported: PlatformDecodedImage? = luce_image_codec_plugin_decode(b"\x00\x00\x00\x1CftypavifXXXX") catch failure:
assert(failure.code == luce_image_codec_unsupported)
recover none
assert(unsupported == none)
let broken: PlatformDecodedImage? = luce_image_codec_plugin_decode(loader_test_rgba_png[..<40]) catch:
recover none
assert(broken == none)
## What decode_image's handlers heard.
struct LoaderTestDecodeLog:
var resolved: i32
var rejected: i32
var width: i32
static func on_resolved(context: void*?, image: PlatformDecodedImage*):
let log = (LoaderTestDecodeLog*)(context else trap("no log"))
log.resolved += 1
log.width = gfx.bitmap_width(ak.vector_at(&image.frames, 0).bitmap else trap("a bitmap"))
static func on_rejected(context: void*?, error_: ak.AkError*):
let log = (LoaderTestDecodeLog*)(context else trap("no log"))
log.rejected += 1
test "the luce-png/luce-jpeg ImageCodecPlugin: decode_image settles its promise on the next turn of the event loop":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
var event_loop = LoaderTestEventLoop()
loader_test_install_event_loop(&event_loop)
defer loader_test_remove_event_loop()
platform_s_the = none
luce_image_codec_plugin_install()
defer platform_s_the = none
let log = new LoaderTestDecodeLog() else trap("out of memory")
let plugin = platform_image_codec_plugin_the()
let handlers_resolved = ak.Function1[PlatformDecodedImage*, unit](call = LoaderTestDecodeLog.on_resolved, context = log)
let handlers_rejected = ak.Function1[ak.AkError*, unit](call = LoaderTestDecodeLog.on_rejected, context = log)
let good = platform_image_codec_plugin_decode_image(plugin, loader_test_rgba_png, handlers_resolved, handlers_rejected)
let bad = platform_image_codec_plugin_decode_image(plugin, b"not an image", handlers_resolved, handlers_rejected)
assert(log.resolved == 0 and log.rejected == 0 and not core_promise_is_resolved(good))
loader_test_drain(&event_loop)
assert(log.resolved == 1 and log.width == 3 and log.rejected == 1)
assert(core_promise_is_resolved(good) and core_promise_is_rejected(bad))
# No animation was decoded: a session that is not open is ignored.
platform_image_codec_plugin_request_animation_frames(plugin, 1, 0, 4)
platform_image_codec_plugin_stop_animation_decode(plugin, 1)
assert(ak.vector_is_empty(&event_loop.deferred))
test "BitmapDecodedImageData: its frames, durations, intrinsic size and frame rects":
let vm = web_test_create_vm()
defer web_test_destroy_vm(vm)
let realm = web_test_create_realm(vm)
let decoded = luce_image_codec_plugin_decode(loader_test_rgba_png) else trap("the PNG decodes")
let bitmap = ak.vector_at_const(&decoded.frames, 0).bitmap else trap("a bitmap")
var frames: ak.Vector[HtmlBitmapDecodedImageDataFrame]
ak.vector_append_t(&frames, HtmlBitmapDecodedImageDataFrame(bitmap = gfx.immutable_bitmap_create_color_space(bitmap, decoded.color_space), duration = 40))
ak.vector_append_t(&frames, HtmlBitmapDecodedImageDataFrame(bitmap = gfx.immutable_bitmap_create_color_space(bitmap, decoded.color_space), duration = 60))
let data = html_bitmap_decoded_image_data_create(realm, frames, 3, true) else trap("create")
assert(is_html_bitmap_decoded_image_data(data))
assert(html_decoded_image_data_frame_count(data) == 2 and html_decoded_image_data_loop_count(data) == 3 and html_decoded_image_data_is_animated(data))
assert(html_decoded_image_data_frame_duration(data, 1) == 60 and html_decoded_image_data_frame_duration(data, 2) == 0)
assert(html_decoded_image_data_bitmap(data, 0, gfx.IntSize()) != none and html_decoded_image_data_bitmap(data, 2, gfx.IntSize()) == none)
let width = html_decoded_image_data_intrinsic_width(data) else trap("an intrinsic width")
let height = html_decoded_image_data_intrinsic_height(data) else trap("an intrinsic height")
assert(width.m_value == gfx.CssPixels.from_int(3).m_value and height.m_value == gfx.CssPixels.from_int(1).m_value)
let ratio = html_decoded_image_data_intrinsic_aspect_ratio(data) else trap("an aspect ratio")
assert(ratio.m_numerator.m_value == gfx.CssPixels.from_int(3).m_value and ratio.m_denominator.m_value == gfx.CssPixels.from_int(1).m_value)
let rect = html_decoded_image_data_frame_rect(data, 0) else trap("a frame rect")
assert(rect.m_size.m_width == 3 and rect.m_size.m_height == 1)