mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-20 06:21:16 +01:00
AnchorMatrix's offset array size was multiplied in unsigned arithmetic. A small vertex with 46341 rows could therefore be accepted as a 46341-column matrix, leading to excessive work and allocation during subtable splitting. PairPosFormat2 had the same problem on 32-bit platforms. Use the existing size_t saturating multiply helper and compare against the payload length after checking the header. This preserves the width of PairPosFormat2's size computation and avoids overflow in the header addition as well. Add bounded internal vertex tests for wrapping dimensions, exact valid sizes, truncated payloads and headers, and empty matrices. The anchor regression fails against the unchanged code without large allocations. Discovered by Anthropic's OSS Scanner, as vulnerability ANT-2026-7E6A2QQS. Testing: meson compile -C build -j4; meson test -C build (all 274 tests passed). Assisted-by: OpenAI Codex
3215 lines
91 KiB
C++
3215 lines
91 KiB
C++
/*
|
|
* Copyright © 2020 Google, Inc.
|
|
*
|
|
* This is part of HarfBuzz, a text shaping library.
|
|
*
|
|
* Permission is hereby granted, without written agreement and without
|
|
* license or royalty fees, to use, copy, modify, and distribute this
|
|
* software and its documentation for any purpose, provided that the
|
|
* above copyright notice and the following two paragraphs appear in
|
|
* all copies of this software.
|
|
*
|
|
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
|
|
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
|
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
|
|
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
|
* DAMAGE.
|
|
*
|
|
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
|
|
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
|
|
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
|
|
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
|
|
*
|
|
* Google Author(s): Garret Rieger
|
|
*/
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
|
|
#include "hb-repacker.hh"
|
|
#include "hb-open-type.hh"
|
|
#include "graph/serialize.hh"
|
|
|
|
static void extend (const char* value,
|
|
unsigned len,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
char* obj = c->allocate_size<char> (len);
|
|
hb_memcpy (obj, value, len);
|
|
}
|
|
|
|
static void start_object(const char* tag,
|
|
unsigned len,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
c->push ();
|
|
extend (tag, len, c);
|
|
}
|
|
|
|
static unsigned add_object(const char* tag,
|
|
unsigned len,
|
|
hb_serialize_context_t* c,
|
|
bool shared = false)
|
|
{
|
|
start_object (tag, len, c);
|
|
return c->pop_pack (shared);
|
|
}
|
|
|
|
|
|
static void add_offset (unsigned id,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
OT::Offset16* offset = c->start_embed<OT::Offset16> ();
|
|
c->extend_min (offset);
|
|
c->add_link (*offset, id);
|
|
}
|
|
|
|
static void add_24_offset (unsigned id,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
OT::Offset24* offset = c->start_embed<OT::Offset24> ();
|
|
c->extend_min (offset);
|
|
c->add_link (*offset, id);
|
|
}
|
|
|
|
static void add_wide_offset (unsigned id,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
OT::Offset32* offset = c->start_embed<OT::Offset32> ();
|
|
c->extend_min (offset);
|
|
c->add_link (*offset, id);
|
|
}
|
|
|
|
static void add_gsubgpos_header (unsigned lookup_list,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
char header[] = {
|
|
0, 1, // major
|
|
0, 0, // minor
|
|
0, 0, // script list
|
|
0, 0, // feature list
|
|
};
|
|
|
|
start_object (header, 8, c);
|
|
add_offset (lookup_list, c);
|
|
c->pop_pack (false);
|
|
}
|
|
|
|
static void add_gsubgpos_header_1_2 (unsigned lookup_list,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
char header[] = {
|
|
0, 1, 0, 2, // version
|
|
0, 0, // script list
|
|
0, 0, // feature list
|
|
0, 0, // lookup list
|
|
0, 0, 0, 0, // feature variations
|
|
0, 0, 0, 0, // script list 2
|
|
0, 0, 0, 0, // feature list 2
|
|
};
|
|
|
|
start_object (header, sizeof (header), c);
|
|
add_wide_offset (lookup_list, c);
|
|
c->pop_pack (false);
|
|
}
|
|
|
|
static unsigned add_lookup_list (const unsigned* lookups,
|
|
char count,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
char lookup_count[] = {0, count};
|
|
start_object ((char *) &lookup_count, 2, c);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
add_offset (lookups[i], c);
|
|
|
|
return c->pop_pack (false);
|
|
}
|
|
|
|
static unsigned add_lookup_list_1_2 (const unsigned* lookups,
|
|
char count,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
char lookup_count[] = {0, count};
|
|
start_object ((char *) &lookup_count, 2, c);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
add_wide_offset (lookups[i], c);
|
|
|
|
return c->pop_pack (false);
|
|
}
|
|
|
|
static void start_lookup (int8_t type,
|
|
int8_t num_subtables,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
char lookup[] = {
|
|
0, (char)type, // type
|
|
0, (char)2, // flag
|
|
0, (char)num_subtables, // num subtables
|
|
};
|
|
|
|
start_object (lookup, 6, c);
|
|
}
|
|
|
|
static unsigned finish_lookup (hb_serialize_context_t* c)
|
|
{
|
|
char filter[] = {0, 0};
|
|
extend (filter, 2, c);
|
|
return c->pop_pack (false);
|
|
}
|
|
|
|
static unsigned add_extension (unsigned child,
|
|
uint8_t type,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
char ext[] = {
|
|
0, 1,
|
|
0, (char) type,
|
|
};
|
|
|
|
start_object (ext, 4, c);
|
|
add_wide_offset (child, c);
|
|
|
|
return c->pop_pack (false);
|
|
|
|
}
|
|
|
|
// Adds coverage table fro [start, end]
|
|
static unsigned add_coverage (unsigned start, unsigned end,
|
|
hb_serialize_context_t* c,
|
|
bool shared = false)
|
|
{
|
|
if (end - start == 0) {
|
|
uint8_t coverage[] = {
|
|
0, 1, // format
|
|
0, 1, // count
|
|
|
|
(uint8_t) ((start >> 8) & 0xFF),
|
|
(uint8_t) (start & 0xFF), // glyph[0]
|
|
};
|
|
return add_object ((char*) coverage, 6, c, shared);
|
|
}
|
|
|
|
if (end - start == 1)
|
|
{
|
|
uint8_t coverage[] = {
|
|
0, 1, // format
|
|
0, 2, // count
|
|
|
|
(uint8_t) ((start >> 8) & 0xFF),
|
|
(uint8_t) (start & 0xFF), // glyph[0]
|
|
|
|
(uint8_t) ((end >> 8) & 0xFF),
|
|
(uint8_t) (end & 0xFF), // glyph[1]
|
|
};
|
|
return add_object ((char*) coverage, 8, c, shared);
|
|
}
|
|
|
|
uint8_t coverage[] = {
|
|
0, 2, // format
|
|
0, 1, // range count
|
|
|
|
(uint8_t) ((start >> 8) & 0xFF),
|
|
(uint8_t) (start & 0xFF), // start
|
|
|
|
(uint8_t) ((end >> 8) & 0xFF),
|
|
(uint8_t) (end & 0xFF), // end
|
|
|
|
0, 0,
|
|
};
|
|
return add_object ((char*) coverage, 10, c, shared);
|
|
}
|
|
|
|
|
|
template<typename It>
|
|
static unsigned add_coverage (It it,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
c->push ();
|
|
OT::Layout::Common::Coverage_serialize (c, it);
|
|
return c->pop_pack (false);
|
|
}
|
|
|
|
// Adds a class that maps glyphs from [start_glyph, end_glyph)
|
|
// to classes 1...n
|
|
static unsigned add_class_def (uint16_t start_glyph,
|
|
uint16_t end_glyph,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
unsigned count = end_glyph - start_glyph;
|
|
uint8_t header[] = {
|
|
0, 1, // format
|
|
|
|
(uint8_t) ((start_glyph >> 8) & 0xFF),
|
|
(uint8_t) (start_glyph & 0xFF), // start_glyph
|
|
|
|
(uint8_t) ((count >> 8) & 0xFF),
|
|
(uint8_t) (count & 0xFF), // count
|
|
};
|
|
|
|
start_object ((char*) header, 6, c);
|
|
for (uint16_t i = 1; i <= count; i++)
|
|
{
|
|
uint8_t class_value[] = {
|
|
(uint8_t) ((i >> 8) & 0xFF),
|
|
(uint8_t) (i & 0xFF), // count
|
|
};
|
|
extend ((char*) class_value, 2, c);
|
|
}
|
|
|
|
return c->pop_pack (false);
|
|
}
|
|
|
|
static unsigned add_pair_pos_1 (unsigned* pair_sets,
|
|
char count,
|
|
unsigned coverage,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
char format[] = {
|
|
0, 1
|
|
};
|
|
|
|
start_object (format, 2, c);
|
|
add_offset (coverage, c);
|
|
|
|
char value_format[] = {
|
|
0, 0,
|
|
0, 0,
|
|
0, count,
|
|
};
|
|
extend (value_format, 6, c);
|
|
|
|
for (char i = 0; i < count; i++)
|
|
add_offset (pair_sets[(unsigned) i], c);
|
|
|
|
return c->pop_pack (false);
|
|
}
|
|
|
|
static void add_liga_set_header (char liga_count,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
uint8_t liga_count_bytes[] = {
|
|
(uint8_t) (0xFF & (liga_count >> 8)),
|
|
(uint8_t) (0xFF & liga_count),
|
|
};
|
|
|
|
start_object ((const char*) liga_count_bytes, 2, c);
|
|
}
|
|
|
|
static void add_liga_header (unsigned coverage, unsigned liga_set_count, hb_serialize_context_t* c)
|
|
{
|
|
uint8_t format[] = {0, 1};
|
|
start_object ((const char*) format, 2, c);
|
|
add_offset(coverage, c);
|
|
|
|
uint8_t liga_set_count_bytes[] = {
|
|
(uint8_t) (0xFF & (liga_set_count >> 8)),
|
|
(uint8_t) (0xFF & liga_set_count),
|
|
};
|
|
|
|
extend((const char *) liga_set_count_bytes, 2, c);
|
|
}
|
|
|
|
static unsigned add_pair_pos_2 (unsigned starting_class,
|
|
unsigned coverage,
|
|
unsigned class_def_1, uint16_t class_def_1_count,
|
|
unsigned class_def_2, uint16_t class_def_2_count,
|
|
unsigned* device_tables,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
uint8_t format[] = {
|
|
0, 2
|
|
};
|
|
|
|
start_object ((char*) format, 2, c);
|
|
add_offset (coverage, c);
|
|
|
|
unsigned num_values = 4;
|
|
uint8_t format1 = 0x01 | 0x02 | 0x08;
|
|
uint8_t format2 = 0x04;
|
|
if (device_tables) {
|
|
format2 |= 0x20;
|
|
num_values += 1;
|
|
}
|
|
uint8_t value_format[] = {
|
|
0, format1,
|
|
0, format2,
|
|
};
|
|
|
|
extend ((char*) value_format, 4, c);
|
|
|
|
add_offset (class_def_1, c);
|
|
add_offset (class_def_2, c);
|
|
|
|
uint8_t class_counts[] = {
|
|
(uint8_t) ((class_def_1_count >> 8) & 0xFF),
|
|
(uint8_t) (class_def_1_count & 0xFF),
|
|
(uint8_t) ((class_def_2_count >> 8) & 0xFF),
|
|
(uint8_t) (class_def_2_count & 0xFF),
|
|
};
|
|
extend ((char*) class_counts, 4, c);
|
|
|
|
unsigned num_bytes_per_record = class_def_2_count * num_values * 2;
|
|
uint8_t* record = (uint8_t*) calloc (1, num_bytes_per_record);
|
|
int device_index = 0;
|
|
for (uint16_t i = 0; i < class_def_1_count; i++)
|
|
{
|
|
|
|
for (uint16_t j = 0; j < class_def_2_count; j++)
|
|
{
|
|
for (int k = 0; k < 4; k++) {
|
|
uint8_t value[] = {
|
|
(uint8_t) (i + starting_class),
|
|
(uint8_t) (i + starting_class),
|
|
};
|
|
extend ((char*) value, 2, c);
|
|
}
|
|
|
|
if (device_tables) {
|
|
add_offset (device_tables[device_index++], c);
|
|
}
|
|
}
|
|
}
|
|
free (record);
|
|
|
|
return c->pop_pack (false);
|
|
}
|
|
|
|
static unsigned add_mark_base_pos_1 (unsigned mark_coverage,
|
|
unsigned base_coverage,
|
|
unsigned mark_array,
|
|
unsigned base_array,
|
|
unsigned class_count,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
uint8_t format[] = {
|
|
0, 1
|
|
};
|
|
|
|
start_object ((char*) format, 2, c);
|
|
add_offset (mark_coverage, c);
|
|
add_offset (base_coverage, c);
|
|
|
|
uint8_t count[] = {
|
|
(uint8_t) ((class_count >> 8) & 0xFF),
|
|
(uint8_t) (class_count & 0xFF),
|
|
};
|
|
extend ((char*) count, 2, c);
|
|
|
|
add_offset (mark_array, c);
|
|
add_offset (base_array, c);
|
|
|
|
return c->pop_pack (false);
|
|
}
|
|
|
|
template<int mark_count,
|
|
int class_count,
|
|
int base_count,
|
|
int table_count>
|
|
struct MarkBasePosBuffers
|
|
{
|
|
unsigned base_anchors[class_count * base_count];
|
|
unsigned mark_anchors[mark_count];
|
|
uint8_t anchor_buffers[class_count * base_count + 100];
|
|
uint8_t class_buffer[class_count * 2];
|
|
|
|
MarkBasePosBuffers(hb_serialize_context_t* c)
|
|
{
|
|
for (unsigned i = 0; i < sizeof(anchor_buffers) / 2; i++)
|
|
{
|
|
OT::HBUINT16* value = (OT::HBUINT16*) (&anchor_buffers[2*i]);
|
|
*value = i;
|
|
}
|
|
|
|
for (unsigned i = 0; i < class_count * base_count; i++)
|
|
{
|
|
base_anchors[i] = add_object ((char*) &anchor_buffers[i], 100, c);
|
|
if (i < class_count) {
|
|
class_buffer[i*2] = (uint8_t) ((i >> 8) & 0xFF);
|
|
class_buffer[i*2 + 1] = (uint8_t) (i & 0xFF);
|
|
}
|
|
}
|
|
|
|
for (unsigned i = 0; i < mark_count; i++)
|
|
{
|
|
mark_anchors[i] = add_object ((char*) &anchor_buffers[i], 4, c);
|
|
}
|
|
}
|
|
|
|
unsigned create_mark_base_pos_1 (unsigned table_index, hb_serialize_context_t* c)
|
|
{
|
|
unsigned class_per_table = class_count / table_count;
|
|
unsigned mark_per_class = mark_count / class_count;
|
|
unsigned start_class = class_per_table * table_index;
|
|
unsigned end_class = class_per_table * (table_index + 1) - 1;
|
|
|
|
// baseArray
|
|
uint8_t base_count_buffer[] = {
|
|
(uint8_t) ((base_count >> 8) & 0xFF),
|
|
(uint8_t) (base_count & 0xFF),
|
|
|
|
};
|
|
start_object ((char*) base_count_buffer, 2, c);
|
|
for (unsigned base = 0; base < base_count; base++)
|
|
{
|
|
for (unsigned klass = start_class; klass <= end_class; klass++)
|
|
{
|
|
unsigned i = base * class_count + klass;
|
|
add_offset (base_anchors[i], c);
|
|
}
|
|
}
|
|
unsigned base_array = c->pop_pack (false);
|
|
|
|
// markArray
|
|
unsigned num_marks = class_per_table * mark_per_class;
|
|
uint8_t mark_count_buffer[] = {
|
|
(uint8_t) ((num_marks >> 8) & 0xFF),
|
|
(uint8_t) (num_marks & 0xFF),
|
|
};
|
|
start_object ((char*) mark_count_buffer, 2, c);
|
|
for (unsigned mark = 0; mark < mark_count; mark++)
|
|
{
|
|
unsigned klass = mark % class_count;
|
|
if (klass < start_class || klass > end_class) continue;
|
|
klass -= start_class;
|
|
|
|
extend ((char*) &class_buffer[2 * klass], 2, c);
|
|
add_offset (mark_anchors[mark], c);
|
|
}
|
|
unsigned mark_array = c->pop_pack (false);
|
|
|
|
// markCoverage
|
|
auto it =
|
|
+ hb_range ((hb_codepoint_t) mark_count)
|
|
| hb_filter ([&] (hb_codepoint_t mark) {
|
|
unsigned klass = mark % class_count;
|
|
return klass >= class_per_table * table_index &&
|
|
klass < class_per_table * (table_index + 1);
|
|
})
|
|
;
|
|
unsigned mark_coverage = add_coverage (it, c);
|
|
|
|
// baseCoverage
|
|
unsigned base_coverage = add_coverage (10, 10 + base_count - 1, c);
|
|
|
|
return add_mark_base_pos_1 (mark_coverage,
|
|
base_coverage,
|
|
mark_array,
|
|
base_array,
|
|
class_per_table,
|
|
c);
|
|
}
|
|
};
|
|
|
|
static void run_resolve_overflow_test (const char* name,
|
|
hb_serialize_context_t& overflowing,
|
|
hb_serialize_context_t& expected,
|
|
unsigned num_iterations = 0,
|
|
bool recalculate_extensions = false,
|
|
hb_tag_t tag = HB_TAG ('G', 'S', 'U', 'B'),
|
|
bool check_binary_equivalence = false)
|
|
{
|
|
printf (">>> Testing overflowing resolution for %s\n",
|
|
name);
|
|
|
|
graph_t graph = graph_t::create (overflowing.object_graph ()).value ();
|
|
|
|
graph_t expected_graph = graph_t::create (expected.object_graph ()).value ();
|
|
if (graph::will_overflow (expected_graph).value ())
|
|
{
|
|
if (check_binary_equivalence) {
|
|
printf("when binary equivalence checking is enabled, the expected graph cannot overflow.");
|
|
hb_always_assert(!check_binary_equivalence);
|
|
}
|
|
hb_always_assert (expected_graph.assign_spaces ().is_ok ());
|
|
hb_always_assert (expected_graph.sort_shortest_distance ().is_ok ());
|
|
}
|
|
|
|
// Check that overflow resolution succeeds
|
|
hb_always_assert (overflowing.offset_overflow ());
|
|
auto r = hb_resolve_graph_overflows (tag,
|
|
num_iterations,
|
|
recalculate_extensions,
|
|
graph);
|
|
if (r.is_err())
|
|
printf("run_resolve_overflow_test: overflow resolution failed, cause: %s\n", graph::to_string(r.error()));
|
|
hb_always_assert (r.is_ok());
|
|
|
|
// Check the graphs can be serialized.
|
|
hb_blob_t* out1 = graph::serialize (graph).value ();
|
|
hb_always_assert (out1);
|
|
hb_blob_t* out2 = graph::serialize (expected_graph).value ();
|
|
hb_always_assert (out2);
|
|
if (check_binary_equivalence) {
|
|
unsigned l1, l2;
|
|
const char* d1 = hb_blob_get_data(out1, &l1);
|
|
const char* d2 = hb_blob_get_data(out2, &l2);
|
|
|
|
bool match = (l1 == l2) && (memcmp(d1, d2, l1) == 0);
|
|
if (!match) {
|
|
printf("## Result:\n");
|
|
graph.print();
|
|
printf("## Expected:\n");
|
|
expected_graph.print();
|
|
hb_always_assert(match);
|
|
}
|
|
}
|
|
|
|
hb_blob_destroy (out1);
|
|
hb_blob_destroy (out2);
|
|
|
|
// Check the graphs are equivalent
|
|
graph.normalize ();
|
|
expected_graph.normalize ();
|
|
if (!(graph == expected_graph)) {
|
|
printf("## Expected:\n");
|
|
expected_graph.print();
|
|
printf("## Result:\n");
|
|
graph.print();
|
|
}
|
|
hb_always_assert (graph == expected_graph);
|
|
}
|
|
|
|
static void add_virtual_offset (unsigned id,
|
|
hb_serialize_context_t* c)
|
|
{
|
|
c->add_virtual_link (id);
|
|
}
|
|
|
|
static void
|
|
populate_serializer_simple (hb_serialize_context_t* c)
|
|
{
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_1 = add_object ("ghi", 3, c);
|
|
unsigned obj_2 = add_object ("def", 3, c);
|
|
|
|
start_object ("abc", 3, c);
|
|
add_offset (obj_2, c);
|
|
add_offset (obj_1, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_virtual (hb_serialize_context_t* c, bool with_overflow)
|
|
{
|
|
std::string large_string(50000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_4, obj_5;
|
|
if (with_overflow) {
|
|
obj_5 = add_object("55555", 5, c);
|
|
obj_4 = add_object(large_string.c_str(), 50000, c);
|
|
} else {
|
|
obj_4 = add_object(large_string.c_str(), 50000, c);
|
|
obj_5 = add_object("55555", 5, c);
|
|
}
|
|
|
|
start_object(large_string.c_str(), 20000, c);
|
|
add_offset(obj_5, c);
|
|
unsigned obj_3 = c->pop_pack(false);
|
|
|
|
start_object("2", 2, c);
|
|
add_virtual_offset(obj_5, c);
|
|
unsigned obj_2 = c->pop_pack(false);
|
|
|
|
// obj 1
|
|
start_object("1", 1, c);
|
|
add_offset(obj_2, c);
|
|
add_offset(obj_3, c);
|
|
add_offset(obj_4, c);
|
|
c->pop_pack(false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_overflow (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(50000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_1 = add_object (large_string.c_str(), 10000, c);
|
|
unsigned obj_2 = add_object (large_string.c_str(), 20000, c);
|
|
unsigned obj_3 = add_object (large_string.c_str(), 50000, c);
|
|
|
|
start_object ("abc", 3, c);
|
|
add_offset (obj_3, c);
|
|
add_offset (obj_2, c);
|
|
add_offset (obj_1, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_priority_overflow (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(50000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_e = add_object ("e", 1, c);
|
|
unsigned obj_d = add_object ("d", 1, c);
|
|
|
|
start_object (large_string.c_str (), 50000, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str (), 20000, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_offset (obj_b, c);
|
|
add_offset (obj_c, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_priority_overflow_expected (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(50000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_e = add_object ("e", 1, c);
|
|
|
|
start_object (large_string.c_str (), 50000, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
unsigned obj_d = add_object ("d", 1, c);
|
|
|
|
start_object (large_string.c_str (), 20000, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_offset (obj_b, c);
|
|
add_offset (obj_c, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
|
|
static void
|
|
populate_serializer_with_dedup_overflow (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_1 = add_object ("def", 3, c);
|
|
|
|
start_object (large_string.c_str(), 60000, c);
|
|
add_offset (obj_1, c);
|
|
unsigned obj_2 = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 10000, c);
|
|
add_offset (obj_2, c);
|
|
add_offset (obj_1, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_multiple_dedup_overflow (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned leaf = add_object("def", 3, c);
|
|
|
|
constexpr unsigned num_mid_nodes = 20;
|
|
unsigned mid_nodes[num_mid_nodes];
|
|
for (unsigned i = 0; i < num_mid_nodes; i++) {
|
|
start_object(large_string.c_str(), 10000 + i, c);
|
|
add_offset(leaf, c);
|
|
mid_nodes[i] = c->pop_pack(false);
|
|
}
|
|
|
|
start_object("abc", 3, c);
|
|
for (unsigned i = 0; i < num_mid_nodes; i++) {
|
|
add_wide_offset(mid_nodes[i], c);
|
|
}
|
|
c->pop_pack(false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_isolation_overflow (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_4 = add_object ("4", 1, c);
|
|
|
|
start_object (large_string.c_str(), 60000, c);
|
|
add_offset (obj_4, c);
|
|
unsigned obj_3 = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 10000, c);
|
|
add_offset (obj_4, c);
|
|
unsigned obj_2 = c->pop_pack (false);
|
|
|
|
start_object ("1", 1, c);
|
|
add_wide_offset (obj_3, c);
|
|
add_offset (obj_2, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_isolation_overflow_complex (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_f = add_object ("f", 1, c);
|
|
|
|
start_object ("e", 1, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
start_object ("c", 1, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object ("d", 1, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 60000, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_h = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 60000, c);
|
|
add_offset (obj_c, c);
|
|
add_offset (obj_h, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 10000, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_g = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 11000, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_i = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_wide_offset (obj_b, c);
|
|
add_offset (obj_g, c);
|
|
add_offset (obj_i, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_isolation_overflow_complex_expected (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
|
|
// space 1
|
|
|
|
unsigned obj_f_prime = add_object ("f", 1, c);
|
|
|
|
start_object ("e", 1, c);
|
|
add_offset (obj_f_prime, c);
|
|
unsigned obj_e_prime = c->pop_pack (false);
|
|
|
|
start_object ("d", 1, c);
|
|
add_offset (obj_e_prime, c);
|
|
unsigned obj_d_prime = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 60000, c);
|
|
add_offset (obj_d_prime, c);
|
|
unsigned obj_h = c->pop_pack (false);
|
|
|
|
start_object ("c", 1, c);
|
|
add_offset (obj_e_prime, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 60000, c);
|
|
add_offset (obj_c, c);
|
|
add_offset (obj_h, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
// space 0
|
|
|
|
unsigned obj_f = add_object ("f", 1, c);
|
|
|
|
start_object ("e", 1, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
|
|
start_object ("d", 1, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 11000, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_i = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 10000, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_g = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_wide_offset (obj_b, c);
|
|
add_offset (obj_g, c);
|
|
add_offset (obj_i, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_isolation_overflow_spaces (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_d = add_object ("f", 1, c);
|
|
unsigned obj_e = add_object ("f", 1, c);
|
|
|
|
start_object (large_string.c_str(), 60000, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_b = c->pop_pack ();
|
|
|
|
start_object (large_string.c_str(), 60000, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack ();
|
|
|
|
|
|
start_object ("a", 1, c);
|
|
add_wide_offset (obj_b, c);
|
|
add_wide_offset (obj_c, c);
|
|
c->pop_pack ();
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_repack_last (hb_serialize_context_t* c, bool with_overflow)
|
|
{
|
|
std::string large_string(70000, 'c');
|
|
c->start_serialize<char> ();
|
|
c->push();
|
|
|
|
// Obj E
|
|
unsigned obj_e_1, obj_e_2;
|
|
if (with_overflow) {
|
|
obj_e_1 = add_object("a", 1, c);
|
|
obj_e_2 = obj_e_1;
|
|
} else {
|
|
obj_e_2 = add_object("a", 1, c);
|
|
}
|
|
|
|
// Obj D
|
|
c->push();
|
|
add_offset(obj_e_2, c);
|
|
extend(large_string.c_str(), 30000, c);
|
|
unsigned obj_d = c->pop_pack(false);
|
|
|
|
add_offset(obj_d, c);
|
|
hb_always_assert(c->last_added_child_index() == obj_d);
|
|
|
|
if (!with_overflow) {
|
|
obj_e_1 = add_object("a", 1, c);
|
|
}
|
|
|
|
// Obj C
|
|
c->push();
|
|
add_offset(obj_e_1, c);
|
|
extend(large_string.c_str(), 40000, c);
|
|
unsigned obj_c = c->pop_pack(false);
|
|
|
|
add_offset(obj_c, c);
|
|
|
|
// Obj B
|
|
unsigned obj_b = add_object("b", 1, c);
|
|
add_offset(obj_b, c);
|
|
|
|
// Obj A
|
|
c->repack_last(obj_d);
|
|
c->pop_pack(false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_spaces (hb_serialize_context_t* c, bool with_overflow)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_i;
|
|
|
|
if (with_overflow)
|
|
obj_i = add_object ("i", 1, c);
|
|
|
|
// Space 2
|
|
unsigned obj_h = add_object ("h", 1, c);
|
|
|
|
start_object (large_string.c_str(), 30000, c);
|
|
add_offset (obj_h, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
// Space 1
|
|
if (!with_overflow)
|
|
obj_i = add_object ("i", 1, c);
|
|
|
|
start_object (large_string.c_str(), 30000, c);
|
|
add_offset (obj_i, c);
|
|
unsigned obj_g = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 30000, c);
|
|
add_offset (obj_i, c);
|
|
unsigned obj_f = c->pop_pack (false);
|
|
|
|
start_object ("d", 1, c);
|
|
add_offset (obj_g, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
start_object ("c", 1, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_wide_offset (obj_b, c);
|
|
add_wide_offset (obj_c, c);
|
|
add_wide_offset (obj_d, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_spaces_16bit_connection (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_g = add_object ("g", 1, c);
|
|
unsigned obj_h = add_object ("h", 1, c);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_g, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_h, c);
|
|
unsigned obj_f = c->pop_pack (false);
|
|
|
|
start_object ("c", 1, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object ("d", 1, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_e, c);
|
|
add_offset (obj_h, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_offset (obj_b, c);
|
|
add_wide_offset (obj_c, c);
|
|
add_wide_offset (obj_d, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_spaces_16bit_connection_expected (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_g_prime = add_object ("g", 1, c);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_g_prime, c);
|
|
unsigned obj_e_prime = c->pop_pack (false);
|
|
|
|
start_object ("c", 1, c);
|
|
add_offset (obj_e_prime, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
unsigned obj_h_prime = add_object ("h", 1, c);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_h_prime, c);
|
|
unsigned obj_f = c->pop_pack (false);
|
|
|
|
start_object ("d", 1, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
unsigned obj_g = add_object ("g", 1, c);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_g, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
unsigned obj_h = add_object ("h", 1, c);
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_e, c);
|
|
add_offset (obj_h, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_offset (obj_b, c);
|
|
add_wide_offset (obj_c, c);
|
|
add_wide_offset (obj_d, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize ();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_short_and_wide_subgraph_root (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_e = add_object ("e", 1, c);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_c, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_c, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_offset (obj_b, c);
|
|
add_wide_offset (obj_c, c);
|
|
add_wide_offset (obj_d, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_short_and_wide_subgraph_root_expected (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_e_prime = add_object ("e", 1, c);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_e_prime, c);
|
|
unsigned obj_c_prime = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_c_prime, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
unsigned obj_e = add_object ("e", 1, c);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_c, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_offset (obj_b, c);
|
|
add_wide_offset (obj_c_prime, c);
|
|
add_wide_offset (obj_d, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_split_spaces (hb_serialize_context_t* c)
|
|
{
|
|
// Overflow needs to be resolved by splitting the single space
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_f = add_object ("f", 1, c);
|
|
|
|
start_object (large_string.c_str(), 40000, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 40000, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object ("c", 1, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_wide_offset (obj_b, c);
|
|
add_wide_offset (obj_c, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_split_spaces_2 (hb_serialize_context_t* c)
|
|
{
|
|
// Overflow needs to be resolved by splitting the single space
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_f = add_object ("f", 1, c);
|
|
|
|
start_object (large_string.c_str(), 40000, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str(), 40000, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object ("c", 1, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_offset (obj_b, c);
|
|
add_wide_offset (obj_b, c);
|
|
add_wide_offset (obj_c, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_split_spaces_expected (hb_serialize_context_t* c)
|
|
{
|
|
// Overflow needs to be resolved by splitting the single space
|
|
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_f_prime = add_object ("f", 1, c);
|
|
|
|
start_object (large_string.c_str(), 40000, c);
|
|
add_offset (obj_f_prime, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
unsigned obj_f = add_object ("f", 1, c);
|
|
|
|
start_object (large_string.c_str(), 40000, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
start_object ("c", 1, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_wide_offset (obj_b, c);
|
|
add_wide_offset (obj_c, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_split_spaces_expected_2 (hb_serialize_context_t* c)
|
|
{
|
|
// Overflow needs to be resolved by splitting the single space
|
|
|
|
std::string large_string(70000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
// Space 2
|
|
|
|
unsigned obj_f_double_prime = add_object ("f", 1, c);
|
|
|
|
start_object (large_string.c_str(), 40000, c);
|
|
add_offset (obj_f_double_prime, c);
|
|
unsigned obj_d_prime = c->pop_pack (false);
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_d_prime, c);
|
|
unsigned obj_b_prime = c->pop_pack (false);
|
|
|
|
// Space 1
|
|
|
|
unsigned obj_f_prime = add_object ("f", 1, c);
|
|
|
|
start_object (large_string.c_str(), 40000, c);
|
|
add_offset (obj_f_prime, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
start_object ("c", 1, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
// Space 0
|
|
|
|
unsigned obj_f = add_object ("f", 1, c);
|
|
|
|
start_object (large_string.c_str(), 40000, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
// Root
|
|
start_object ("a", 1, c);
|
|
add_offset (obj_b, c);
|
|
add_wide_offset (obj_b_prime, c);
|
|
add_wide_offset (obj_c, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_complex_2 (hb_serialize_context_t* c)
|
|
{
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_5 = add_object ("mn", 2, c);
|
|
|
|
unsigned obj_4 = add_object ("jkl", 3, c);
|
|
|
|
start_object ("ghi", 3, c);
|
|
add_offset (obj_4, c);
|
|
unsigned obj_3 = c->pop_pack (false);
|
|
|
|
start_object ("def", 3, c);
|
|
add_offset (obj_3, c);
|
|
unsigned obj_2 = c->pop_pack (false);
|
|
|
|
start_object ("abc", 3, c);
|
|
add_offset (obj_2, c);
|
|
add_offset (obj_4, c);
|
|
add_offset (obj_5, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_complex_3 (hb_serialize_context_t* c)
|
|
{
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_6 = add_object ("opqrst", 6, c);
|
|
|
|
unsigned obj_5 = add_object ("mn", 2, c);
|
|
|
|
start_object ("jkl", 3, c);
|
|
add_offset (obj_6, c);
|
|
unsigned obj_4 = c->pop_pack (false);
|
|
|
|
start_object ("ghi", 3, c);
|
|
add_offset (obj_4, c);
|
|
unsigned obj_3 = c->pop_pack (false);
|
|
|
|
start_object ("def", 3, c);
|
|
add_offset (obj_3, c);
|
|
unsigned obj_2 = c->pop_pack (false);
|
|
|
|
start_object ("abc", 3, c);
|
|
add_offset (obj_2, c);
|
|
add_offset (obj_4, c);
|
|
add_offset (obj_5, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_virtual_link (hb_serialize_context_t* c)
|
|
{
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_d = add_object ("d", 1, c);
|
|
|
|
start_object ("b", 1, c);
|
|
add_offset (obj_d, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object ("e", 1, c);
|
|
add_virtual_offset (obj_b, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
start_object ("c", 1, c);
|
|
add_offset (obj_e, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_offset (obj_b, c);
|
|
add_offset (obj_c, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_24_and_32_bit_offsets (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(60000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned obj_f = add_object ("f", 1, c);
|
|
unsigned obj_g = add_object ("g", 1, c);
|
|
unsigned obj_j = add_object ("j", 1, c);
|
|
unsigned obj_k = add_object ("k", 1, c);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_f, c);
|
|
unsigned obj_c = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_g, c);
|
|
unsigned obj_d = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_j, c);
|
|
unsigned obj_h = c->pop_pack (false);
|
|
|
|
start_object (large_string.c_str (), 40000, c);
|
|
add_offset (obj_k, c);
|
|
unsigned obj_i = c->pop_pack (false);
|
|
|
|
start_object ("e", 1, c);
|
|
add_wide_offset (obj_h, c);
|
|
add_wide_offset (obj_i, c);
|
|
unsigned obj_e = c->pop_pack (false);
|
|
|
|
start_object ("b", 1, c);
|
|
add_24_offset (obj_c, c);
|
|
add_24_offset (obj_d, c);
|
|
add_24_offset (obj_e, c);
|
|
unsigned obj_b = c->pop_pack (false);
|
|
|
|
start_object ("a", 1, c);
|
|
add_24_offset (obj_b, c);
|
|
c->pop_pack (false);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_extension_promotion (hb_serialize_context_t* c,
|
|
int num_extensions = 0,
|
|
bool shared_subtables = false,
|
|
bool version_1_2 = false)
|
|
{
|
|
constexpr int num_lookups = 5;
|
|
constexpr int num_subtables = num_lookups * 2;
|
|
unsigned int lookups[num_lookups];
|
|
unsigned int subtables[num_subtables];
|
|
unsigned int extensions[num_subtables];
|
|
|
|
std::string large_string(60000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
|
|
for (int i = num_subtables - 1; i >= 0; i--)
|
|
subtables[i] = add_object(large_string.c_str (), 15000 + i, c);
|
|
|
|
for (int i = num_subtables - 1;
|
|
i >= (num_lookups - num_extensions) * 2;
|
|
i--)
|
|
{
|
|
extensions[i] = add_extension (subtables[i], 5, c);
|
|
}
|
|
|
|
for (int i = num_lookups - 1; i >= 0; i--)
|
|
{
|
|
bool is_ext = (i >= (num_lookups - num_extensions));
|
|
|
|
start_lookup (is_ext ? (char) 7 : (char) 5,
|
|
shared_subtables && i > 2 ? 3 : 2,
|
|
c);
|
|
|
|
if (is_ext) {
|
|
if (shared_subtables && i > 2) {
|
|
add_offset (extensions[i * 2 - 1], c);
|
|
}
|
|
add_offset (extensions[i * 2], c);
|
|
add_offset (extensions[i * 2 + 1], c);
|
|
} else {
|
|
if (shared_subtables && i > 2) {
|
|
add_offset (subtables[i * 2 - 1], c);
|
|
}
|
|
add_offset (subtables[i * 2], c);
|
|
add_offset (subtables[i * 2 + 1], c);
|
|
}
|
|
|
|
lookups[i] = finish_lookup (c);
|
|
}
|
|
|
|
unsigned lookup_list = version_1_2
|
|
? add_lookup_list_1_2 (lookups, num_lookups, c)
|
|
: add_lookup_list (lookups, num_lookups, c);
|
|
|
|
if (version_1_2)
|
|
add_gsubgpos_header_1_2 (lookup_list, c);
|
|
else
|
|
add_gsubgpos_header (lookup_list, c);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
template<int num_pair_pos_1, int num_pair_set>
|
|
static void
|
|
populate_serializer_with_large_pair_pos_1 (hb_serialize_context_t* c,
|
|
bool as_extension = false)
|
|
{
|
|
std::string large_string(60000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
constexpr int total_pair_set = num_pair_pos_1 * num_pair_set;
|
|
unsigned pair_set[total_pair_set];
|
|
unsigned coverage[num_pair_pos_1];
|
|
unsigned pair_pos_1[num_pair_pos_1];
|
|
|
|
for (int i = num_pair_pos_1 - 1; i >= 0; i--)
|
|
{
|
|
for (int j = (i + 1) * num_pair_set - 1; j >= i * num_pair_set; j--)
|
|
pair_set[j] = add_object (large_string.c_str (), 30000 + j, c);
|
|
|
|
coverage[i] = add_coverage (i * num_pair_set,
|
|
(i + 1) * num_pair_set - 1, c);
|
|
|
|
pair_pos_1[i] = add_pair_pos_1 (&pair_set[i * num_pair_set],
|
|
num_pair_set,
|
|
coverage[i],
|
|
c);
|
|
}
|
|
|
|
unsigned pair_pos_2 = add_object (large_string.c_str(), 200, c);
|
|
|
|
if (as_extension) {
|
|
pair_pos_2 = add_extension (pair_pos_2, 2, c);
|
|
for (int i = num_pair_pos_1 - 1; i >= 0; i--)
|
|
pair_pos_1[i] = add_extension (pair_pos_1[i], 2, c);
|
|
}
|
|
|
|
start_lookup (as_extension ? 9 : 2, 1 + num_pair_pos_1, c);
|
|
|
|
for (int i = 0; i < num_pair_pos_1; i++)
|
|
add_offset (pair_pos_1[i], c);
|
|
add_offset (pair_pos_2, c);
|
|
|
|
unsigned lookup = finish_lookup (c);
|
|
|
|
unsigned lookup_list = add_lookup_list (&lookup, 1, c);
|
|
|
|
add_gsubgpos_header (lookup_list, c);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
template<int num_pair_pos_2, int num_class_1, int num_class_2>
|
|
static void
|
|
populate_serializer_with_large_pair_pos_2 (hb_serialize_context_t* c,
|
|
bool as_extension = false,
|
|
bool with_device_tables = false,
|
|
bool extra_table = true)
|
|
{
|
|
std::string large_string(100000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned coverage[num_pair_pos_2];
|
|
unsigned class_def_1[num_pair_pos_2];
|
|
unsigned class_def_2[num_pair_pos_2];
|
|
unsigned pair_pos_2[num_pair_pos_2];
|
|
|
|
unsigned* device_tables = (unsigned*) calloc (num_pair_pos_2 * num_class_1 * num_class_2,
|
|
sizeof(unsigned));
|
|
|
|
// Total glyphs = num_class_1 * num_pair_pos_2
|
|
for (int i = num_pair_pos_2 - 1; i >= 0; i--)
|
|
{
|
|
unsigned start_glyph = 5 + i * num_class_1;
|
|
if (num_class_2 >= num_class_1)
|
|
{
|
|
class_def_2[i] = add_class_def (11,
|
|
10 + num_class_2, c);
|
|
class_def_1[i] = add_class_def (start_glyph + 1,
|
|
start_glyph + num_class_1,
|
|
c);
|
|
} else {
|
|
class_def_1[i] = add_class_def (start_glyph + 1,
|
|
start_glyph + num_class_1,
|
|
c);
|
|
class_def_2[i] = add_class_def (11,
|
|
10 + num_class_2, c);
|
|
}
|
|
|
|
coverage[i] = add_coverage (start_glyph,
|
|
start_glyph + num_class_1 - 1,
|
|
c);
|
|
|
|
if (with_device_tables)
|
|
{
|
|
for(int j = (i + 1) * num_class_1 * num_class_2 - 1;
|
|
j >= i * num_class_1 * num_class_2;
|
|
j--)
|
|
{
|
|
uint8_t table[] = {
|
|
(uint8_t) ((j >> 8) & 0xFF),
|
|
(uint8_t) (j & 0xFF),
|
|
};
|
|
device_tables[j] = add_object ((char*) table, 2, c);
|
|
}
|
|
}
|
|
|
|
pair_pos_2[i] = add_pair_pos_2 (1 + i * num_class_1,
|
|
coverage[i],
|
|
class_def_1[i], num_class_1,
|
|
class_def_2[i], num_class_2,
|
|
with_device_tables
|
|
? &device_tables[i * num_class_1 * num_class_2]
|
|
: nullptr,
|
|
c);
|
|
}
|
|
|
|
|
|
unsigned pair_pos_1 = 0;
|
|
if (extra_table) pair_pos_1 = add_object (large_string.c_str(), 100000, c);
|
|
|
|
if (as_extension) {
|
|
for (int i = num_pair_pos_2 - 1; i >= 0; i--)
|
|
pair_pos_2[i] = add_extension (pair_pos_2[i], 2, c);
|
|
|
|
if (extra_table)
|
|
pair_pos_1 = add_extension (pair_pos_1, 2, c);
|
|
}
|
|
|
|
start_lookup (as_extension ? 9 : 2, 1 + num_pair_pos_2, c);
|
|
|
|
if (extra_table)
|
|
add_offset (pair_pos_1, c);
|
|
|
|
for (int i = 0; i < num_pair_pos_2; i++)
|
|
add_offset (pair_pos_2[i], c);
|
|
|
|
unsigned lookup = finish_lookup (c);
|
|
|
|
unsigned lookup_list = add_lookup_list (&lookup, 1, c);
|
|
|
|
add_gsubgpos_header (lookup_list, c);
|
|
|
|
c->end_serialize();
|
|
|
|
free (device_tables);
|
|
}
|
|
|
|
template<int mark_count,
|
|
int class_count,
|
|
int base_count,
|
|
int table_count>
|
|
static void
|
|
populate_serializer_with_large_mark_base_pos_1 (hb_serialize_context_t* c)
|
|
{
|
|
c->start_serialize<char> ();
|
|
|
|
MarkBasePosBuffers<mark_count, class_count, base_count, table_count> buffers (c);
|
|
|
|
unsigned mark_base_pos[table_count];
|
|
for (unsigned i = 0; i < table_count; i++)
|
|
mark_base_pos[i] = buffers.create_mark_base_pos_1 (i, c);
|
|
|
|
for (int i = 0; i < table_count; i++)
|
|
mark_base_pos[i] = add_extension (mark_base_pos[i], 4, c);
|
|
|
|
start_lookup (9, table_count, c);
|
|
|
|
for (int i = 0; i < table_count; i++)
|
|
add_offset (mark_base_pos[i], c);
|
|
|
|
unsigned lookup = finish_lookup (c);
|
|
|
|
unsigned lookup_list = add_lookup_list (&lookup, 1, c);
|
|
|
|
add_gsubgpos_header (lookup_list, c);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
template<unsigned LigSubstCount,
|
|
unsigned LigaSetCount,
|
|
unsigned LigaPerSetCount,
|
|
unsigned LigaSize>
|
|
static void populate_serializer_with_large_ligsubst(hb_serialize_context_t* c,
|
|
bool sequential_liga_sets,
|
|
bool shared,
|
|
unsigned *liga_subst_id,
|
|
bool unique_lig_str = false)
|
|
{
|
|
char ch = 'a';
|
|
|
|
unsigned liga[LigaSetCount * LigaPerSetCount];
|
|
unsigned liga_set[LigaSetCount];
|
|
for (unsigned l = 0; l < LigSubstCount; l++) {
|
|
unsigned coverage_start = 0;
|
|
unsigned coverage_end = LigaSetCount - 1;
|
|
if (sequential_liga_sets) {
|
|
coverage_start = l * LigaSetCount;
|
|
coverage_end = (l + 1) * LigaSetCount - 1;
|
|
}
|
|
unsigned coverage = add_coverage(coverage_start, coverage_end, c, shared);
|
|
|
|
for (unsigned i = 0; i < LigaSetCount; i++) {
|
|
for (unsigned j = 0; j < LigaPerSetCount; j++)
|
|
{
|
|
std::string large_string(100000, ch);
|
|
start_object (large_string.c_str(), LigaSize, c);
|
|
if (unique_lig_str)
|
|
ch += 1;
|
|
add_virtual_offset(coverage, c);
|
|
liga[i * LigaPerSetCount + j] = c->pop_pack (shared);
|
|
}
|
|
|
|
add_liga_set_header(LigaPerSetCount, c);
|
|
add_virtual_offset(coverage, c);
|
|
for (unsigned j = 0; j < LigaPerSetCount; j++)
|
|
{
|
|
add_offset(liga[i * LigaPerSetCount + j], c);
|
|
}
|
|
|
|
liga_set[i] = c->pop_pack(shared);
|
|
}
|
|
|
|
add_liga_header(coverage, LigaSetCount, c);
|
|
for (unsigned i = 0; i < LigaSetCount; i++)
|
|
{
|
|
add_offset(liga_set[i], c);
|
|
}
|
|
|
|
liga_subst_id[l] = c->pop_pack(shared);
|
|
}
|
|
|
|
for (unsigned l = 0; l < LigSubstCount; l++) {
|
|
liga_subst_id[l] = add_extension(liga_subst_id[l], 4, c);
|
|
}
|
|
}
|
|
|
|
template<unsigned liga_subst_count,
|
|
unsigned liga_set_count,
|
|
unsigned liga_per_set_count,
|
|
unsigned liga_size>
|
|
static void
|
|
populate_serializer_with_large_liga (hb_serialize_context_t* c, bool sequential_liga_sets)
|
|
{
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned liga_subst[liga_subst_count];
|
|
populate_serializer_with_large_ligsubst<liga_subst_count, liga_set_count, liga_per_set_count, liga_size>(c, sequential_liga_sets, false, liga_subst);
|
|
|
|
start_lookup (7, liga_subst_count, c);
|
|
for (unsigned l = 0; l < liga_subst_count; l++) {
|
|
add_offset(liga_subst[l], c);
|
|
}
|
|
|
|
unsigned lookup = finish_lookup (c);
|
|
|
|
unsigned lookup_list = add_lookup_list (&lookup, 1, c);
|
|
|
|
add_gsubgpos_header (lookup_list, c);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_large_liga_overlapping_clone_result (hb_serialize_context_t* c)
|
|
{
|
|
std::string large_string(100000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
constexpr unsigned liga_size = 30000;
|
|
|
|
unsigned liga[6];
|
|
unsigned liga_subst[3];
|
|
unsigned liga_set[2];
|
|
|
|
// LigaSubst 3
|
|
unsigned coverage = add_coverage(1, 1, c);
|
|
for (int i = 1; i >= 0; i--) {
|
|
start_object (large_string.c_str(), liga_size, c);
|
|
add_virtual_offset(coverage, c);
|
|
liga[i] = c->pop_pack (false);
|
|
}
|
|
|
|
add_liga_set_header(2, c);
|
|
add_virtual_offset(coverage, c);
|
|
for (unsigned i = 0; i < 2; i++)
|
|
add_offset(liga[i], c);
|
|
liga_set[0] = c->pop_pack(false);
|
|
|
|
add_liga_header(coverage, 1, c);
|
|
add_offset(liga_set[0], c);
|
|
liga_subst[2] = c->pop_pack(false);
|
|
|
|
// LigaSubst 2
|
|
coverage = add_coverage(0, 1, c);
|
|
for (int i = 1; i >= 0; i--) {
|
|
start_object (large_string.c_str(), liga_size, c);
|
|
add_virtual_offset(coverage, c);
|
|
liga[i] = c->pop_pack (false);
|
|
}
|
|
|
|
add_liga_set_header(1, c);
|
|
add_virtual_offset(coverage, c);
|
|
add_offset(liga[1], c);
|
|
liga_set[1] = c->pop_pack(false);
|
|
|
|
add_liga_set_header(1, c);
|
|
add_virtual_offset(coverage, c);
|
|
add_offset(liga[0], c);
|
|
liga_set[0] = c->pop_pack(false);
|
|
|
|
add_liga_header(coverage, 2, c);
|
|
add_offset(liga_set[0], c);
|
|
add_offset(liga_set[1], c);
|
|
liga_subst[1] = c->pop_pack(false);
|
|
|
|
// LigaSubst 1
|
|
coverage = add_coverage(0, 0, c);
|
|
for (int i = 1; i >= 0; i--) {
|
|
start_object (large_string.c_str(), liga_size, c);
|
|
add_virtual_offset(coverage, c);
|
|
liga[i] = c->pop_pack (false);
|
|
}
|
|
|
|
add_liga_set_header(2, c);
|
|
add_virtual_offset(coverage, c);
|
|
for (unsigned i = 0; i < 2; i++)
|
|
add_offset(liga[i], c);
|
|
liga_set[0] = c->pop_pack(false);
|
|
|
|
add_liga_header(coverage, 1, c);
|
|
add_offset(liga_set[0], c);
|
|
liga_subst[0] = c->pop_pack(false);
|
|
|
|
for (int l = 2; l >= 0; l--) {
|
|
liga_subst[l] = add_extension(liga_subst[l], 4, c);
|
|
}
|
|
|
|
start_lookup (7, 3, c);
|
|
for (unsigned l = 0; l < 3; l++) {
|
|
add_offset(liga_subst[l], c);
|
|
}
|
|
|
|
unsigned lookup = finish_lookup (c);
|
|
|
|
unsigned lookup_list = add_lookup_list (&lookup, 1, c);
|
|
|
|
add_gsubgpos_header (lookup_list, c);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void
|
|
populate_serializer_with_large_liga_null_offsets (hb_serialize_context_t* c, bool split)
|
|
{
|
|
std::string large_string(100000, 'a');
|
|
c->start_serialize<char> ();
|
|
|
|
constexpr unsigned liga_size = 30000;
|
|
const char null_offsets[6] = {0};
|
|
|
|
unsigned liga[3];
|
|
unsigned liga_subst[2];
|
|
unsigned liga_set[2];
|
|
unsigned liga_subst_count = split ? 2 : 1;
|
|
unsigned coverage;
|
|
|
|
if (split) {
|
|
// LigaSubst 2
|
|
coverage = add_coverage(1, 1, c);
|
|
start_object (large_string.c_str(), liga_size, c);
|
|
add_virtual_offset(coverage, c);
|
|
liga[2] = c->pop_pack (false);
|
|
|
|
add_liga_set_header(1, c);
|
|
add_virtual_offset(coverage, c);
|
|
add_offset(liga[2], c);
|
|
liga_set[0] = c->pop_pack(false);
|
|
|
|
add_liga_header(coverage, 1, c);
|
|
add_offset(liga_set[0], c);
|
|
liga_subst[1] = c->pop_pack(false);
|
|
}
|
|
|
|
// LigaSubst 1
|
|
coverage = add_coverage(0, 1, c);
|
|
for (int i = split ? 1 : 2; i >= 0; i--) {
|
|
start_object (large_string.c_str(), liga_size, c);
|
|
add_virtual_offset(coverage, c);
|
|
liga[i] = c->pop_pack (false);
|
|
}
|
|
|
|
add_liga_set_header(split ? 1 : 2, c);
|
|
add_virtual_offset(coverage, c);
|
|
add_offset(liga[1], c);
|
|
if (!split)
|
|
add_offset(liga[2], c);
|
|
liga_set[1] = c->pop_pack(false);
|
|
|
|
// One liga followed by three null offsets.
|
|
add_liga_set_header(4, c);
|
|
add_virtual_offset(coverage, c);
|
|
add_offset(liga[0], c);
|
|
extend(null_offsets, 6, c);
|
|
liga_set[0] = c->pop_pack(false);
|
|
|
|
add_liga_header(coverage, 2, c);
|
|
add_offset(liga_set[0], c);
|
|
add_offset(liga_set[1], c);
|
|
liga_subst[0] = c->pop_pack(false);
|
|
|
|
for (int l = liga_subst_count - 1; l >= 0; l--) {
|
|
liga_subst[l] = add_extension(liga_subst[l], 4, c);
|
|
}
|
|
|
|
start_lookup (7, liga_subst_count, c);
|
|
for (unsigned l = 0; l < liga_subst_count; l++) {
|
|
add_offset(liga_subst[l], c);
|
|
}
|
|
|
|
unsigned lookup = finish_lookup (c);
|
|
|
|
unsigned lookup_list = add_lookup_list (&lookup, 1, c);
|
|
|
|
add_gsubgpos_header (lookup_list, c);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
template<unsigned liga_subst_count,
|
|
unsigned liga_set_count,
|
|
unsigned liga_per_set_count,
|
|
unsigned liga_size>
|
|
static void
|
|
populate_serializer_with_shared_large_liga (hb_serialize_context_t* c, bool sequential_liga_sets)
|
|
{
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned lookups[2];
|
|
// Lookup
|
|
// LigSubst: shared with another Lookup table, needs splitting
|
|
unsigned liga_subst_idx[liga_subst_count];
|
|
populate_serializer_with_large_ligsubst<liga_subst_count, liga_set_count, liga_per_set_count, liga_size>(c, sequential_liga_sets, true, liga_subst_idx, true);
|
|
|
|
start_lookup (7, liga_subst_count, c);
|
|
for (unsigned l = 0; l < liga_subst_count; l++) {
|
|
add_offset(liga_subst_idx[l], c);
|
|
}
|
|
|
|
lookups[0] = finish_lookup (c);
|
|
|
|
// Lookup with 2 LigSubst tables
|
|
unsigned liga_subst[liga_subst_count + 1];
|
|
// LigSubst: small one, not shared, no split
|
|
populate_serializer_with_large_ligsubst<1, 1, 1, 10>(c, sequential_liga_sets, false, liga_subst);
|
|
|
|
// LigSubst: shared, needs splitting
|
|
populate_serializer_with_large_ligsubst<liga_subst_count, liga_set_count, liga_per_set_count, liga_size>(c, sequential_liga_sets, true, &liga_subst[1], true);
|
|
|
|
start_lookup (7, liga_subst_count + 1, c);
|
|
for (unsigned l = 0; l <= liga_subst_count; l++) {
|
|
add_offset(liga_subst[l], c);
|
|
}
|
|
|
|
lookups[1] = finish_lookup (c);
|
|
|
|
unsigned lookup_list = add_lookup_list (lookups, 2, c);
|
|
add_gsubgpos_header (lookup_list, c);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
template<unsigned liga_subst_count,
|
|
unsigned liga_set_count,
|
|
unsigned liga_per_set_count,
|
|
unsigned liga_size>
|
|
static void
|
|
populate_serializer_with_liga_shared_coverage (hb_serialize_context_t* c)
|
|
{
|
|
c->start_serialize<char> ();
|
|
|
|
unsigned liga_subst[liga_subst_count + 1];
|
|
// LigSubst: small one, no split, coverage shared
|
|
populate_serializer_with_large_ligsubst<1, 6, 2, 10>(c, true, true, liga_subst, true);
|
|
|
|
// LigSubst: shared coverage, needs splitting
|
|
populate_serializer_with_large_ligsubst<liga_subst_count, liga_set_count, liga_per_set_count, liga_size>(c, true, true, &liga_subst[1], true);
|
|
|
|
start_lookup (7, liga_subst_count + 1, c);
|
|
for (unsigned l = 0; l <= liga_subst_count; l++) {
|
|
add_offset(liga_subst[l], c);
|
|
}
|
|
|
|
unsigned lookup = finish_lookup (c);
|
|
|
|
unsigned lookup_list = add_lookup_list (&lookup, 1, c);
|
|
add_gsubgpos_header (lookup_list, c);
|
|
|
|
c->end_serialize();
|
|
}
|
|
|
|
static void test_sort_shortest ()
|
|
{
|
|
size_t buffer_size = 100;
|
|
void* buffer_a = malloc (buffer_size);
|
|
void* buffer_e = malloc (buffer_size);
|
|
hb_serialize_context_t a (buffer_a, buffer_size);
|
|
hb_serialize_context_t e (buffer_e, buffer_size);
|
|
populate_serializer_complex_2 (&a);
|
|
|
|
graph_t graph = graph_t::create (a.object_graph ()).value ();
|
|
hb_always_assert (graph.sort_shortest_distance ().is_ok());
|
|
graph.normalize();
|
|
|
|
// Expected graph
|
|
e.start_serialize();
|
|
unsigned jkl = add_object ("jkl", 3, &e);
|
|
|
|
start_object("ghi", 3, &e);
|
|
add_offset(jkl, &e);
|
|
unsigned ghi = e.pop_pack(false);
|
|
|
|
start_object("def", 3, &e);
|
|
add_offset(ghi, &e);
|
|
unsigned def = e.pop_pack(false);
|
|
|
|
unsigned mn = add_object("mn", 2, &e);
|
|
|
|
start_object ("abc", 3, &e);
|
|
add_offset (def, &e);
|
|
add_offset (jkl, &e);
|
|
add_offset (mn, &e);
|
|
e.pop_pack (false);
|
|
e.end_serialize();
|
|
|
|
graph_t expected = graph_t::create (e.object_graph ()).value ();
|
|
expected.normalize();
|
|
|
|
assert(expected == graph);
|
|
|
|
free (buffer_a);
|
|
free (buffer_e);
|
|
}
|
|
|
|
static void test_duplicate_leaf ()
|
|
{
|
|
size_t buffer_size = 100;
|
|
void* buffer_a = malloc (buffer_size);
|
|
void* buffer_e = malloc (buffer_size);
|
|
hb_serialize_context_t a (buffer_a, buffer_size);
|
|
hb_serialize_context_t e (buffer_e, buffer_size);
|
|
populate_serializer_complex_2 (&a);
|
|
|
|
graph_t graph = graph_t::create (a.object_graph ()).value ();
|
|
hb_always_assert (graph.duplicate (4, 1, false).is_ok ());
|
|
graph.normalize();
|
|
|
|
e.start_serialize();
|
|
unsigned mn = add_object("mn", 2, &e);
|
|
unsigned jkl_2 = add_object("jkl", 3, &e);
|
|
|
|
start_object("ghi", 3, &e);
|
|
add_offset(jkl_2, &e);
|
|
unsigned ghi = e.pop_pack(false);
|
|
|
|
start_object("def", 3, &e);
|
|
add_offset(ghi, &e);
|
|
unsigned def = e.pop_pack(false);
|
|
|
|
unsigned jkl_1 = add_object("jkl", 3, &e);
|
|
|
|
start_object("abc", 3, &e);
|
|
add_offset(def, &e);
|
|
add_offset(jkl_1, &e);
|
|
add_offset(mn, &e);
|
|
e.pop_pack(false);
|
|
|
|
graph_t expected = graph_t::create (e.object_graph ()).value ();
|
|
expected.normalize();
|
|
|
|
assert(expected == graph);
|
|
|
|
free (buffer_a);
|
|
free (buffer_e);
|
|
}
|
|
|
|
static void test_duplicate_interior ()
|
|
{
|
|
size_t buffer_size = 100;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_complex_3 (&c);
|
|
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
hb_always_assert (graph.duplicate (3, 2, false).is_ok ());
|
|
|
|
hb_always_assert(strncmp (graph.object (6).head, "jkl", 3) == 0);
|
|
hb_always_assert(graph.object (6).real_links.length == 1);
|
|
hb_always_assert(graph.object (6).real_links[0].objidx == 0);
|
|
|
|
hb_always_assert(strncmp (graph.object (5).head, "abc", 3) == 0);
|
|
hb_always_assert(graph.object (5).real_links.length == 3);
|
|
hb_always_assert(graph.object (5).real_links[0].objidx == 4);
|
|
hb_always_assert(graph.object (5).real_links[1].objidx == 2);
|
|
hb_always_assert(graph.object (5).real_links[2].objidx == 1);
|
|
|
|
hb_always_assert(strncmp (graph.object (4).head, "def", 3) == 0);
|
|
hb_always_assert(graph.object (4).real_links.length == 1);
|
|
hb_always_assert(graph.object (4).real_links[0].objidx == 3);
|
|
|
|
hb_always_assert(strncmp (graph.object (3).head, "ghi", 3) == 0);
|
|
hb_always_assert(graph.object (3).real_links.length == 1);
|
|
hb_always_assert(graph.object (3).real_links[0].objidx == 6);
|
|
|
|
hb_always_assert(strncmp (graph.object (2).head, "jkl", 3) == 0);
|
|
hb_always_assert(graph.object (2).real_links.length == 1);
|
|
hb_always_assert(graph.object (2).real_links[0].objidx == 0);
|
|
|
|
hb_always_assert(strncmp (graph.object (1).head, "mn", 2) == 0);
|
|
hb_always_assert(graph.object (1).real_links.length == 0);
|
|
|
|
hb_always_assert(strncmp (graph.object (0).head, "opqrst", 6) == 0);
|
|
hb_always_assert(graph.object (0).real_links.length == 0);
|
|
|
|
free (buffer);
|
|
}
|
|
|
|
static void
|
|
test_serialize ()
|
|
{
|
|
size_t buffer_size = 100;
|
|
void* buffer_1 = malloc (buffer_size);
|
|
hb_serialize_context_t c1 (buffer_1, buffer_size);
|
|
populate_serializer_simple (&c1);
|
|
hb_bytes_t expected = c1.copy_bytes ();
|
|
|
|
graph_t graph = graph_t::create (c1.object_graph ()).value ();
|
|
hb_blob_t* out = graph::serialize (graph).value ();
|
|
free (buffer_1);
|
|
|
|
hb_bytes_t actual = out->as_bytes ();
|
|
hb_always_assert (actual == expected);
|
|
expected.fini ();
|
|
hb_blob_destroy (out);
|
|
}
|
|
|
|
static void test_will_overflow_1 ()
|
|
{
|
|
size_t buffer_size = 100;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
|
|
populate_serializer_complex_2 (&c);
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
hb_always_assert (!graph::will_overflow (graph, nullptr).value ());
|
|
|
|
free (buffer);
|
|
}
|
|
|
|
static void test_will_overflow_2 ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_overflow (&c);
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
hb_always_assert (graph::will_overflow (graph, nullptr).value ());
|
|
|
|
free (buffer);
|
|
}
|
|
|
|
static void test_will_overflow_3 ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_dedup_overflow (&c);
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
hb_always_assert (graph::will_overflow (graph, nullptr).value ());
|
|
|
|
free (buffer);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_sort ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_overflow (&c);
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE);
|
|
hb_always_assert (out);
|
|
hb_bytes_t result = out->as_bytes ();
|
|
hb_always_assert (result.length == (80000 + 3 + 3 * 2));
|
|
|
|
free (buffer);
|
|
hb_blob_destroy (out);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_duplication ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_dedup_overflow (&c);
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE);
|
|
hb_always_assert (out);
|
|
hb_bytes_t result = out->as_bytes ();
|
|
hb_always_assert (result.length == (10000 + 2 * 2 + 60000 + 2 + 3 * 2));
|
|
|
|
free (buffer);
|
|
hb_blob_destroy (out);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_multiple_duplications ()
|
|
{
|
|
size_t buffer_size = 300000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_multiple_dedup_overflow (&c);
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE, 5);
|
|
hb_always_assert (out);
|
|
|
|
free (buffer);
|
|
hb_blob_destroy (out);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_space_assignment ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_spaces (&c, true);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_spaces (&e, false);
|
|
|
|
run_resolve_overflow_test ("test_resolve_overflows_via_space_assignment",
|
|
c,
|
|
e);
|
|
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_isolation ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_isolation_overflow (&c);
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
hb_always_assert (c.offset_overflow ());
|
|
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG ('G', 'S', 'U', 'B'), 0);
|
|
hb_always_assert (out);
|
|
hb_bytes_t result = out->as_bytes ();
|
|
hb_always_assert (result.length == (1 + 10000 + 60000 + 1 + 1
|
|
+ 4 + 3 * 2));
|
|
|
|
free (buffer);
|
|
hb_blob_destroy (out);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_isolation_with_recursive_duplication ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_isolation_overflow_complex (&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_isolation_overflow_complex_expected (&e);
|
|
|
|
run_resolve_overflow_test ("test_resolve_overflows_via_isolation_with_recursive_duplication",
|
|
c,
|
|
e);
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_isolating_16bit_space ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_spaces_16bit_connection (&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_spaces_16bit_connection_expected (&e);
|
|
|
|
run_resolve_overflow_test ("test_resolve_overflows_via_isolating_16bit_space",
|
|
c,
|
|
e);
|
|
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_isolating_16bit_space_2 ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_short_and_wide_subgraph_root (&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_short_and_wide_subgraph_root_expected (&e);
|
|
|
|
run_resolve_overflow_test ("test_resolve_overflows_via_isolating_16bit_space_2",
|
|
c,
|
|
e);
|
|
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_isolation_spaces ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_isolation_overflow_spaces (&c);
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
hb_always_assert (c.offset_overflow ());
|
|
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG ('G', 'S', 'U', 'B'), 0);
|
|
hb_always_assert (out);
|
|
hb_bytes_t result = out->as_bytes ();
|
|
|
|
unsigned expected_length = 3 + 2 * 60000; // objects
|
|
expected_length += 2 * 4 + 2 * 2; // links
|
|
hb_always_assert (result.length == expected_length);
|
|
|
|
free (buffer);
|
|
hb_blob_destroy (out);
|
|
}
|
|
|
|
static void test_resolve_mixed_overflows_via_isolation_spaces ()
|
|
{
|
|
size_t buffer_size = 200000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_24_and_32_bit_offsets (&c);
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
hb_always_assert (c.offset_overflow ());
|
|
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG ('G', 'S', 'U', 'B'), 0);
|
|
hb_always_assert (out);
|
|
hb_bytes_t result = out->as_bytes ();
|
|
|
|
unsigned expected_length =
|
|
// Objects
|
|
7 +
|
|
4 * 40000;
|
|
|
|
expected_length +=
|
|
// Links
|
|
2 * 4 + // 32
|
|
4 * 3 + // 24
|
|
4 * 2; // 16
|
|
|
|
hb_always_assert (result.length == expected_length);
|
|
|
|
free (buffer);
|
|
hb_blob_destroy (out);
|
|
}
|
|
|
|
static void test_resolve_with_extension_promotion ()
|
|
{
|
|
size_t buffer_size = 200000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_extension_promotion (&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_extension_promotion (&e, 3);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_extension_promotion",
|
|
c,
|
|
e,
|
|
20,
|
|
true);
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_shared_extension_promotion ()
|
|
{
|
|
size_t buffer_size = 200000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_extension_promotion (&c, 0, true);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_extension_promotion (&e, 3, true);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_extension_promotion",
|
|
c,
|
|
e,
|
|
20,
|
|
true);
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
#ifndef HB_NO_BEYOND_64K
|
|
static void test_resolve_with_extension_promotion_1_2 ()
|
|
{
|
|
size_t buffer_size = 200000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_extension_promotion (&c, 0, false, true);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_extension_promotion (&e, 3, false, true);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_extension_promotion_1_2",
|
|
c,
|
|
e,
|
|
20,
|
|
true);
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
#endif
|
|
|
|
static void test_resolve_with_repeated_extension_promotion ()
|
|
{
|
|
size_t buffer_size = 1000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
|
|
c.start_serialize<char> ();
|
|
unsigned subtable = add_object ("subt", 4, &c);
|
|
start_lookup (5, 2, &c);
|
|
add_offset (subtable, &c);
|
|
add_offset (subtable, &c);
|
|
unsigned lookup = finish_lookup (&c);
|
|
unsigned lookup_list = add_lookup_list (&lookup, 1, &c);
|
|
add_gsubgpos_header (lookup_list, &c);
|
|
c.end_serialize ();
|
|
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
auto context = graph::gsubgpos_graph_context_t::create (HB_TAG ('G', 'S', 'U', 'B'),
|
|
graph).value ();
|
|
hb_always_assert (context.lookups.get_population () == 1);
|
|
unsigned lookup_index = *context.lookups.keys ();
|
|
graph::Lookup* lookup_table = context.lookups.get (lookup_index);
|
|
hb_always_assert (lookup_table->make_extension (context, lookup_index).is_ok ());
|
|
|
|
const auto& lookup_vertex = graph.vertices_[lookup_index];
|
|
hb_always_assert (lookup_vertex.obj ().real_links.length == 2);
|
|
unsigned extension_index = lookup_vertex.obj ().real_links[0].objidx;
|
|
hb_always_assert (lookup_vertex.obj ().real_links[1].objidx == extension_index);
|
|
|
|
auto* extension = graph.vertices_[extension_index].as<
|
|
graph::ExtensionFormat1<OT::Layout::GSUB_impl::ExtensionSubst>*> ();
|
|
unsigned promoted_subtable = extension->get_subtable_index (graph, extension_index).value ();
|
|
hb_always_assert (graph.vertices_[promoted_subtable].table_size () == 4);
|
|
hb_always_assert (graph.update_parents ().is_ok ());
|
|
hb_always_assert (graph.vertices_[extension_index].incoming_edges () == 2);
|
|
hb_always_assert (graph.vertices_[promoted_subtable].incoming_edges () == 1);
|
|
|
|
hb_blob_t* out = graph::serialize (graph).value ();
|
|
hb_blob_destroy (out);
|
|
free (buffer);
|
|
}
|
|
|
|
static void test_resolve_with_basic_pair_pos_1_split ()
|
|
{
|
|
size_t buffer_size = 200000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_large_pair_pos_1 <1, 4>(&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_large_pair_pos_1 <2, 2>(&e, true);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_basic_pair_pos_1_split",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'P', 'O', 'S'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_extension_pair_pos_1_split ()
|
|
{
|
|
size_t buffer_size = 200000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_large_pair_pos_1 <1, 4>(&c, true);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_large_pair_pos_1 <2, 2>(&e, true);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_extension_pair_pos_1_split",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'P', 'O', 'S'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_basic_pair_pos_2_split ()
|
|
{
|
|
size_t buffer_size = 300000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_large_pair_pos_2 <1, 4, 3000>(&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_large_pair_pos_2 <2, 2, 3000>(&e, true);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_basic_pair_pos_2_split",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'P', 'O', 'S'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_close_to_limit_pair_pos_2_split ()
|
|
{
|
|
size_t buffer_size = 300000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_large_pair_pos_2 <1, 1636, 10>(&c, true, false, false);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_large_pair_pos_2 <2, 818, 10>(&e, true, false, false);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_close_to_limit_pair_pos_2_split",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'P', 'O', 'S'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_pair_pos_2_split_with_device_tables ()
|
|
{
|
|
size_t buffer_size = 300000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_large_pair_pos_2 <1, 4, 2000>(&c, false, true);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_large_pair_pos_2 <2, 2, 2000>(&e, true, true);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_pair_pos_2_split_with_device_tables",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'P', 'O', 'S'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_basic_mark_base_pos_1_split ()
|
|
{
|
|
size_t buffer_size = 200000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_large_mark_base_pos_1 <40, 10, 110, 1>(&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_large_mark_base_pos_1 <40, 10, 110, 2>(&e);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_basic_mark_base_pos_1_split",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'P', 'O', 'S'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_basic_liga_split ()
|
|
{
|
|
size_t buffer_size = 200000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_large_liga<1, 1, 2, 40000>(&c, false);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_large_liga<2, 1, 1, 40000>(&e, false);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_basic_liga_split",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'S', 'U', 'B'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_liga_split_move ()
|
|
{
|
|
size_t buffer_size = 400000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_large_liga<1, 6, 2, 16000>(&c, true);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_large_liga<3, 2, 2, 16000>(&e, true);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_liga_split_move",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'S', 'U', 'B'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_liga_split_overlapping_clone ()
|
|
{
|
|
size_t buffer_size = 400000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_large_liga<1, 2, 3, 30000>(&c, true);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_large_liga_overlapping_clone_result(&e);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_liga_split_overlapping_clone",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'S', 'U', 'B'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_liga_split_null_offsets ()
|
|
{
|
|
size_t buffer_size = 400000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_large_liga_null_offsets(&c, false);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_large_liga_null_offsets(&e, true);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_liga_split_null_offsets",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'S', 'U', 'B'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_liga_split_shared_table ()
|
|
{
|
|
size_t buffer_size = 400000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_shared_large_liga<1, 6, 2, 16000>(&c, true);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_shared_large_liga<3, 2, 2, 16000>(&e, true);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_liga_split_shared_table",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'S', 'U', 'B'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_with_liga_split_shared_coverage ()
|
|
{
|
|
size_t buffer_size = 400000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_liga_shared_coverage<1, 6, 2, 16000>(&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_liga_shared_coverage<3, 2, 2, 16000>(&e);
|
|
|
|
run_resolve_overflow_test ("test_resolve_with_liga_split_shared_coverage",
|
|
c,
|
|
e,
|
|
20,
|
|
true,
|
|
HB_TAG('G', 'S', 'U', 'B'));
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_splitting_spaces ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_split_spaces (&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_split_spaces_expected (&e);
|
|
|
|
run_resolve_overflow_test ("test_resolve_overflows_via_splitting_spaces",
|
|
c,
|
|
e,
|
|
1);
|
|
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
|
|
}
|
|
|
|
static void test_resolve_overflows_via_splitting_spaces_2 ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_split_spaces_2 (&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_split_spaces_expected_2 (&e);
|
|
|
|
run_resolve_overflow_test ("test_resolve_overflows_via_splitting_spaces_2",
|
|
c,
|
|
e,
|
|
1);
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void test_resolve_overflows_via_priority ()
|
|
{
|
|
size_t buffer_size = 160000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_priority_overflow (&c);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_priority_overflow_expected (&e);
|
|
|
|
run_resolve_overflow_test ("test_resolve_overflows_via_priority",
|
|
c,
|
|
e,
|
|
3);
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
|
|
static void test_virtual_link ()
|
|
{
|
|
size_t buffer_size = 100;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_virtual_link (&c);
|
|
|
|
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE);
|
|
hb_always_assert (out);
|
|
|
|
hb_bytes_t result = out->as_bytes ();
|
|
hb_always_assert (result.length == 5 + 4 * 2);
|
|
hb_always_assert (result[0] == 'a');
|
|
hb_always_assert (result[5] == 'c');
|
|
hb_always_assert (result[8] == 'e');
|
|
hb_always_assert (result[9] == 'b');
|
|
hb_always_assert (result[12] == 'd');
|
|
|
|
free (buffer);
|
|
hb_blob_destroy (out);
|
|
}
|
|
|
|
static void
|
|
test_shared_node_with_virtual_links ()
|
|
{
|
|
size_t buffer_size = 100;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
|
|
c.start_serialize<char> ();
|
|
|
|
unsigned obj_b = add_object ("b", 1, &c);
|
|
unsigned obj_c = add_object ("c", 1, &c);
|
|
|
|
start_object ("d", 1, &c);
|
|
add_virtual_offset (obj_b, &c);
|
|
unsigned obj_d_1 = c.pop_pack ();
|
|
|
|
start_object ("d", 1, &c);
|
|
add_virtual_offset (obj_c, &c);
|
|
unsigned obj_d_2 = c.pop_pack ();
|
|
|
|
hb_always_assert (obj_d_1 == obj_d_2);
|
|
|
|
start_object ("a", 1, &c);
|
|
add_offset (obj_b, &c);
|
|
add_offset (obj_c, &c);
|
|
add_offset (obj_d_1, &c);
|
|
add_offset (obj_d_2, &c);
|
|
c.pop_pack ();
|
|
c.end_serialize ();
|
|
|
|
hb_always_assert(c.object_graph() [obj_d_1]->virtual_links.length == 2);
|
|
hb_always_assert(c.object_graph() [obj_d_1]->virtual_links[0].objidx == obj_b);
|
|
hb_always_assert(c.object_graph() [obj_d_1]->virtual_links[1].objidx == obj_c);
|
|
free(buffer);
|
|
}
|
|
|
|
static void
|
|
test_repack_last ()
|
|
{
|
|
size_t buffer_size = 200000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_with_repack_last (&c, true);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_with_repack_last (&e, false);
|
|
|
|
run_resolve_overflow_test ("test_repack_last",
|
|
c,
|
|
e,
|
|
20,
|
|
false,
|
|
HB_TAG('a', 'b', 'c', 'd'),
|
|
true);
|
|
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void
|
|
test_dont_duplicate_virtual ()
|
|
{
|
|
size_t buffer_size = 200000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_always_assert (buffer);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_virtual (&c, true);
|
|
|
|
void* expected_buffer = malloc (buffer_size);
|
|
hb_always_assert (expected_buffer);
|
|
hb_serialize_context_t e (expected_buffer, buffer_size);
|
|
populate_serializer_virtual (&e, false);
|
|
|
|
run_resolve_overflow_test ("test_dont_duplicate_virtual",
|
|
c,
|
|
e,
|
|
20,
|
|
false,
|
|
HB_TAG('a', 'b', 'c', 'd'),
|
|
true);
|
|
|
|
free (buffer);
|
|
free (expected_buffer);
|
|
}
|
|
|
|
static void
|
|
test_deep_graph_traversal ()
|
|
{
|
|
size_t buffer_size = 1000000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
|
|
c.start_serialize ();
|
|
unsigned prev = add_object ("leaf", 4, &c);
|
|
for (unsigned i = 0; i < 2000; i++)
|
|
{
|
|
start_object ("node", 4, &c);
|
|
add_offset (prev, &c);
|
|
prev = c.pop_pack (false);
|
|
}
|
|
c.end_serialize ();
|
|
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
// Test find_subgraph (set)
|
|
hb_set_t visited_set;
|
|
hb_always_assert (graph.find_subgraph (graph.root_idx (), visited_set).is_ok ());
|
|
hb_always_assert (visited_set.get_population () == 2001);
|
|
|
|
// Test find_subgraph_size
|
|
hb_set_t size_set;
|
|
size_t sz = graph.find_subgraph_size (graph.root_idx (), size_set).value ();
|
|
hb_always_assert (sz == 4 + 2000 * 6);
|
|
|
|
// Test find_subgraph (map)
|
|
hb_map_t map;
|
|
map.set (graph.root_idx (), 1);
|
|
hb_always_assert (graph.find_subgraph (graph.root_idx (), map).is_ok ());
|
|
hb_always_assert (map.get_population () == 2001);
|
|
|
|
// Test assign_spaces (which exercises find_connected_nodes and find_space_roots)
|
|
hb_always_assert (graph.assign_spaces ().is_ok ());
|
|
|
|
// Test duplicate_subgraph
|
|
hb_map_t index_map;
|
|
hb_always_assert (graph.duplicate_subgraph (graph.root_idx (), index_map).is_ok ());
|
|
hb_always_assert (index_map.get_population () == 2001);
|
|
|
|
free (buffer);
|
|
}
|
|
|
|
static void
|
|
test_32bit_roots_traversal ()
|
|
{
|
|
size_t buffer_size = 1000;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
|
|
c.start_serialize ();
|
|
unsigned leaf1 = add_object ("l1", 2, &c);
|
|
unsigned leaf2 = add_object ("l2", 2, &c);
|
|
|
|
start_object ("mid", 3, &c);
|
|
add_wide_offset (leaf1, &c);
|
|
unsigned mid = c.pop_pack (false);
|
|
|
|
start_object ("root", 4, &c);
|
|
add_offset (mid, &c);
|
|
add_wide_offset (leaf2, &c);
|
|
c.pop_pack (false);
|
|
c.end_serialize ();
|
|
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
hb_set_t roots;
|
|
hb_always_assert (graph.find_32bit_roots (graph.root_idx (), roots).is_ok ());
|
|
hb_always_assert (roots.has (leaf1 - 1));
|
|
hb_always_assert (roots.has (leaf2 - 1));
|
|
hb_always_assert (!roots.has (mid - 1));
|
|
hb_always_assert (roots.get_population () == 2);
|
|
|
|
free (buffer);
|
|
|
|
// Test case where DFS fails but BFS succeeds:
|
|
// root -16-> a
|
|
// root -32-> a
|
|
// a -32-> b
|
|
//
|
|
// DFS will first explore the 16 bit link to a and then recurse the 32 bit link from a to b
|
|
// and consider b a root. However, b should not be a root since it's not a top level 32 bit link.
|
|
// BFS will handle this correctly by discovering a as a top level root and then avoiding further
|
|
// exploring it.
|
|
buffer_size = 1000;
|
|
buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c2 (buffer, buffer_size);
|
|
|
|
c2.start_serialize ();
|
|
unsigned b = add_object ("b", 1, &c2);
|
|
|
|
start_object ("a", 1, &c2);
|
|
add_wide_offset (b, &c2);
|
|
unsigned a = c2.pop_pack (false);
|
|
|
|
start_object ("r", 1, &c2);
|
|
add_offset (a, &c2);
|
|
add_wide_offset (a, &c2);
|
|
c2.pop_pack (false);
|
|
|
|
c2.end_serialize ();
|
|
|
|
graph_t graph2 = graph_t::create (c2.object_graph ()).value ();
|
|
|
|
hb_set_t roots2;
|
|
hb_always_assert (graph2.find_32bit_roots (graph2.root_idx (), roots2).is_ok ());
|
|
hb_always_assert (roots2.get_population () == 1);
|
|
hb_always_assert (roots2.has (a - 1));
|
|
hb_always_assert (!roots2.has (b - 1));
|
|
|
|
free (buffer);
|
|
}
|
|
|
|
static void test_invalid_link_objidx ()
|
|
{
|
|
size_t buffer_size = 100;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_complex_2 (&c);
|
|
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
// Poison a link to point to (unsigned) -1
|
|
auto links = graph.vertices_[graph.root_idx ()].real_links_writer();
|
|
links->objidx = (unsigned) -1;
|
|
|
|
// Running Dijkstra / shortest distance sorting must not crash or OOB access,
|
|
// and must return an error.
|
|
hb_always_assert (!graph.sort_shortest_distance ().is_ok ());
|
|
|
|
free (buffer);
|
|
}
|
|
|
|
static void test_invalid_link_add_and_move ()
|
|
{
|
|
size_t buffer_size = 100;
|
|
void* buffer = malloc (buffer_size);
|
|
hb_serialize_context_t c (buffer, buffer_size);
|
|
populate_serializer_complex_2 (&c);
|
|
|
|
graph_t graph = graph_t::create (c.object_graph ()).value ();
|
|
|
|
// add_link with out-of-bounds child
|
|
OT::Offset16 dummy;
|
|
hb_always_assert (!graph.add_link (&dummy, 0, (unsigned) -1).is_ok ());
|
|
|
|
// move_child with non-existent offset
|
|
auto res = graph.move_child (0, &dummy, 1, &dummy);
|
|
hb_always_assert (!res.is_ok ());
|
|
|
|
free (buffer);
|
|
}
|
|
|
|
static void test_anchor_matrix_sanitize_size_overflow ()
|
|
{
|
|
// 2 * 46341 * 46341 wraps around to 9266 in 32-bit arithmetic.
|
|
const unsigned count = 46341;
|
|
std::string buffer (graph::AnchorMatrix::min_size + 2 * count, '\0');
|
|
auto* matrix = reinterpret_cast<graph::AnchorMatrix*> (&buffer[0]);
|
|
matrix->rows = count;
|
|
graph_t::vertex_t vertex;
|
|
vertex.set_buffer (&buffer[0], &buffer[0] + buffer.size ());
|
|
|
|
hb_always_assert (matrix->sanitize (vertex, 1).is_ok ());
|
|
hb_always_assert (!matrix->sanitize (vertex, 2).is_ok ());
|
|
hb_always_assert (!matrix->sanitize (vertex, count).is_ok ());
|
|
|
|
matrix->rows = 0;
|
|
hb_always_assert (matrix->sanitize (vertex, count).is_ok ());
|
|
vertex.set_buffer (&buffer[0], &buffer[0] + graph::AnchorMatrix::min_size - 1);
|
|
hb_always_assert (!matrix->sanitize (vertex, count).is_ok ());
|
|
}
|
|
|
|
static void test_pair_pos_format_2_sanitize_size_overflow ()
|
|
{
|
|
// 32769 * 65535 * 4 wraps around to 131068 in 32-bit arithmetic.
|
|
struct pair_pos_t : graph::PairPosFormat2
|
|
{
|
|
using graph::PairPosFormat2::valueFormat1;
|
|
using graph::PairPosFormat2::valueFormat2;
|
|
using graph::PairPosFormat2::class1Count;
|
|
using graph::PairPosFormat2::class2Count;
|
|
};
|
|
const unsigned min_size = pair_pos_t::min_size;
|
|
std::string buffer (min_size + 131068, '\0');
|
|
auto* pair_pos = reinterpret_cast<pair_pos_t*> (&buffer[0]);
|
|
pair_pos->valueFormat1 = 1;
|
|
pair_pos->valueFormat2 = 1;
|
|
pair_pos->class1Count = 32769;
|
|
pair_pos->class2Count = 65535;
|
|
graph_t::vertex_t vertex;
|
|
vertex.set_buffer (&buffer[0], &buffer[0] + buffer.size ());
|
|
|
|
hb_always_assert (!pair_pos->sanitize (vertex).is_ok ());
|
|
|
|
pair_pos->class1Count = 3;
|
|
pair_pos->class2Count = 2;
|
|
vertex.set_buffer (&buffer[0], &buffer[0] + min_size + 3 * 2 * 4);
|
|
hb_always_assert (pair_pos->sanitize (vertex).is_ok ());
|
|
vertex.shrink_buffer (1);
|
|
hb_always_assert (!pair_pos->sanitize (vertex).is_ok ());
|
|
|
|
pair_pos->class1Count = 0;
|
|
vertex.set_buffer (&buffer[0], &buffer[0] + min_size);
|
|
hb_always_assert (pair_pos->sanitize (vertex).is_ok ());
|
|
vertex.shrink_buffer (1);
|
|
hb_always_assert (!pair_pos->sanitize (vertex).is_ok ());
|
|
}
|
|
|
|
// TODO(garretrieger): update will_overflow tests to check the overflows array.
|
|
// TODO(garretrieger): add tests for priority raising.
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
test_anchor_matrix_sanitize_size_overflow ();
|
|
test_pair_pos_format_2_sanitize_size_overflow ();
|
|
test_invalid_link_objidx ();
|
|
test_invalid_link_add_and_move ();
|
|
test_serialize ();
|
|
test_sort_shortest ();
|
|
test_will_overflow_1 ();
|
|
test_will_overflow_2 ();
|
|
test_will_overflow_3 ();
|
|
test_resolve_overflows_via_sort ();
|
|
test_resolve_overflows_via_duplication ();
|
|
test_resolve_overflows_via_multiple_duplications ();
|
|
test_resolve_overflows_via_priority ();
|
|
test_resolve_overflows_via_space_assignment ();
|
|
test_resolve_overflows_via_isolation ();
|
|
test_resolve_overflows_via_isolation_with_recursive_duplication ();
|
|
test_resolve_overflows_via_isolation_spaces ();
|
|
test_resolve_overflows_via_isolating_16bit_space ();
|
|
test_resolve_overflows_via_isolating_16bit_space_2 ();
|
|
test_resolve_overflows_via_splitting_spaces ();
|
|
test_resolve_overflows_via_splitting_spaces_2 ();
|
|
test_resolve_mixed_overflows_via_isolation_spaces ();
|
|
test_duplicate_leaf ();
|
|
test_duplicate_interior ();
|
|
test_virtual_link ();
|
|
test_repack_last();
|
|
test_shared_node_with_virtual_links ();
|
|
test_resolve_with_extension_promotion ();
|
|
test_resolve_with_shared_extension_promotion ();
|
|
#ifndef HB_NO_BEYOND_64K
|
|
test_resolve_with_extension_promotion_1_2 ();
|
|
#endif
|
|
test_resolve_with_repeated_extension_promotion ();
|
|
test_resolve_with_basic_pair_pos_1_split ();
|
|
test_resolve_with_extension_pair_pos_1_split ();
|
|
test_resolve_with_basic_pair_pos_2_split ();
|
|
test_resolve_with_pair_pos_2_split_with_device_tables ();
|
|
test_resolve_with_close_to_limit_pair_pos_2_split ();
|
|
test_resolve_with_basic_mark_base_pos_1_split ();
|
|
test_resolve_with_basic_liga_split ();
|
|
test_resolve_with_liga_split_move ();
|
|
test_dont_duplicate_virtual ();
|
|
test_resolve_with_liga_split_overlapping_clone ();
|
|
test_resolve_with_liga_split_null_offsets ();
|
|
test_resolve_with_liga_split_shared_table ();
|
|
test_resolve_with_liga_split_shared_coverage ();
|
|
test_deep_graph_traversal ();
|
|
test_32bit_roots_traversal ();
|
|
|
|
// TODO(grieger): have run overflow tests compare graph equality not final packed binary.
|
|
// TODO(grieger): split test where multiple subtables in one lookup are split to test link ordering.
|
|
// TODO(grieger): split test where coverage table in subtable that is being split is shared.
|
|
// TODO(grieger): test with extensions already mixed in as well.
|
|
// TODO(grieger): test two layer ext promotion setup.
|
|
// TODO(grieger): test sorting by subtables per byte in ext. promotion.
|
|
}
|