walkero
/
harfbuzz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
harfbuzz/src/test-repacker.cc

1362 lines
35 KiB
C++
Raw Normal View History

[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
/*
* 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
*/
Implement will_overflow ().
2020-11-02 23:51:39 +01:00
#include <string>
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
#include "hb-repacker.hh"
#include "hb-open-type.hh"
[repacker] Begin splitting up the repacker implementation into several files.
2022-06-24 20:58:17 +02:00
#include "graph/serialize.hh"
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
[subset] finish up BFS sort implementation.
2020-10-29 22:58:34 +01:00
static void start_object(const char* tag,
unsigned len,
hb_serialize_context_t* c)
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
{
c->push ();
[subset] finish up BFS sort implementation.
2020-10-29 22:58:34 +01:00
char* obj = c->allocate_size<char> (len);
strncpy (obj, tag, len);
}
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
[subset] finish up BFS sort implementation.
2020-10-29 22:58:34 +01:00
static unsigned add_object(const char* tag,
unsigned len,
hb_serialize_context_t* c)
{
start_object (tag, len, c);
return c->pop_pack (false);
}
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
[subset] finish up BFS sort implementation.
2020-10-29 22:58:34 +01:00
static void add_offset (unsigned id,
hb_serialize_context_t* c)
{
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
OT::Offset16* offset = c->start_embed<OT::Offset16> ();
c->extend_min (offset);
[subset] finish up BFS sort implementation.
2020-10-29 22:58:34 +01:00
c->add_link (*offset, id);
}
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
[repacker] add tests for special casing of 24bit offsets.
2022-07-06 21:18:27 +02:00
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);
}
[repacker] Add repacker test for subgraph isolation.
2021-09-09 00:07:02 +02:00
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);
}
[repacker] refactor resolve overflow tests to use a helper.
2021-10-05 22:10:01 +02:00
static void run_resolve_overflow_test (const char* name,
hb_serialize_context_t& overflowing,
hb_serialize_context_t& expected,
unsigned num_iterations = 0)
{
printf (">>> Testing overflowing resolution for %s\n",
name);
graph_t graph (overflowing.object_graph ());
assert (overflowing.offset_overflow ());
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_t* out = hb_resolve_overflows (overflowing.object_graph (),
HB_TAG ('G', 'S', 'U', 'B'), num_iterations);
assert (out);
hb_bytes_t result = out->as_bytes ();
[repacker] refactor resolve overflow tests to use a helper.
2021-10-05 22:10:01 +02:00
assert (!expected.offset_overflow ());
hb_bytes_t expected_result = expected.copy_bytes ();
assert (result.length == expected_result.length);
for (unsigned i = 0; i < expected_result.length; i++)
{
assert (result[i] == expected_result[i]);
}
expected_result.fini ();
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_destroy (out);
[repacker] refactor resolve overflow tests to use a helper.
2021-10-05 22:10:01 +02:00
}
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
static void add_virtual_offset (unsigned id,
hb_serialize_context_t* c)
{
[repacker] remove VirtualOffset struct. Make and add_virtual_link () specialization of add_link() instead.
2021-09-23 23:45:20 +02:00
c->add_virtual_link (id);
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
}
[subset] finish up BFS sort implementation.
2020-10-29 22:58:34 +01:00
static void
populate_serializer_simple (hb_serialize_context_t* c)
{
c->start_serialize<char> ();
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
[subset] finish up BFS sort implementation.
2020-10-29 22:58:34 +01:00
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);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
c->pop_pack (false);
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
c->end_serialize();
}
Implement will_overflow ().
2020-11-02 23:51:39 +01:00
static void
populate_serializer_with_overflow (hb_serialize_context_t* c)
{
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
std::string large_string(50000, 'a');
Implement will_overflow ().
2020-11-02 23:51:39 +01:00
c->start_serialize<char> ();
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
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);
Implement will_overflow ().
2020-11-02 23:51:39 +01:00
start_object ("abc", 3, c);
add_offset (obj_3, c);
add_offset (obj_2, c);
add_offset (obj_1, c);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
c->pop_pack (false);
Implement will_overflow ().
2020-11-02 23:51:39 +01:00
c->end_serialize();
}
[repacker] add test case for using max priority to resolve an overflow.
2021-12-10 01:38:05 +01:00
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();
}
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
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();
}
[repacker] Add repacker test for subgraph isolation.
2021-09-09 00:07:02 +02:00
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);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
unsigned obj_3 = c->pop_pack (false);
[repacker] Add repacker test for subgraph isolation.
2021-09-09 00:07:02 +02:00
start_object (large_string.c_str(), 10000, c);
add_offset (obj_4, c);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
unsigned obj_2 = c->pop_pack (false);
[repacker] Add repacker test for subgraph isolation.
2021-09-09 00:07:02 +02:00
start_object ("1", 1, c);
add_wide_offset (obj_3, c);
add_offset (obj_2, c);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
c->pop_pack (false);
[repacker] Add repacker test for subgraph isolation.
2021-09-09 00:07:02 +02:00
c->end_serialize();
}
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
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);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
unsigned obj_e = c->pop_pack (false);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
start_object ("c", 1, c);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
add_offset (obj_e, c);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
unsigned obj_c = c->pop_pack (false);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
start_object ("d", 1, c);
add_offset (obj_e, c);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
unsigned obj_d = c->pop_pack (false);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
start_object (large_string.c_str(), 60000, c);
add_offset (obj_d, c);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
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);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
start_object (large_string.c_str(), 10000, c);
add_offset (obj_d, c);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
unsigned obj_g = c->pop_pack (false);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
start_object (large_string.c_str(), 11000, c);
add_offset (obj_d, c);
unsigned obj_i = c->pop_pack (false);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
start_object ("a", 1, c);
add_wide_offset (obj_b, c);
add_offset (obj_g, c);
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
add_offset (obj_i, c);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
c->pop_pack (false);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
c->end_serialize();
}
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
static void
populate_serializer_with_isolation_overflow_complex_expected (hb_serialize_context_t* c)
{
std::string large_string(70000, 'a');
c->start_serialize<char> ();
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
// space 1
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
unsigned obj_f_prime = add_object ("f", 1, c);
start_object ("e", 1, c);
add_offset (obj_f_prime, c);
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
unsigned obj_e_prime = c->pop_pack (false);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
start_object ("d", 1, c);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
add_offset (obj_e_prime, c);
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
unsigned obj_d_prime = c->pop_pack (false);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
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);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
add_offset (obj_e_prime, c);
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
unsigned obj_c = c->pop_pack (false);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
start_object (large_string.c_str(), 60000, c);
add_offset (obj_c, c);
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
add_offset (obj_h, c);
unsigned obj_b = c->pop_pack (false);
// space 0
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
unsigned obj_f = add_object ("f", 1, c);
start_object ("e", 1, c);
add_offset (obj_f, c);
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
unsigned obj_e = c->pop_pack (false);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
start_object ("d", 1, c);
add_offset (obj_e, c);
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
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);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
start_object (large_string.c_str(), 10000, c);
add_offset (obj_d, c);
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
unsigned obj_g = c->pop_pack (false);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
start_object ("a", 1, c);
add_wide_offset (obj_b, c);
add_offset (obj_g, c);
[repacker] when assigning each connected subgraph a space, also isolate it. This will break any links coming from space 0 (ie. the 16 bit offset only space).
2021-09-28 22:36:06 +02:00
add_offset (obj_i, c);
c->pop_pack (false);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
c->end_serialize();
}
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
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();
}
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
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();
}
[repacker] restrict 32 bit subgraph connected component search to only nodes reachable via directed links.
2021-09-29 01:04:27 +02:00
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 ();
}
[repacker] Handle the case where a subgraph root has an incoming 32 and 16 bit edge. In this case the entire subgraph from that root will be duplicated.
2021-09-29 23:28:27 +02:00
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();
}
[repacker] add test for splitting spaces.
2021-10-05 20:30:04 +02:00
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();
}
[repacker] Add additional splitting spaces test. Fix issues it uncovered.
2021-10-05 21:46:59 +02:00
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();
}
[repacker] add test for splitting spaces.
2021-10-05 20:30:04 +02:00
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();
}
[repacker] Handle the case where a subgraph root has an incoming 32 and 16 bit edge. In this case the entire subgraph from that root will be duplicated.
2021-09-29 23:28:27 +02:00
[repacker] Add additional splitting spaces test. Fix issues it uncovered.
2021-10-05 21:46:59 +02:00
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();
}
[subset] Implement Kahn's algo for topological sorting instead of BFS.
2020-10-30 18:29:51 +01:00
static void
populate_serializer_complex_2 (hb_serialize_context_t* c)
{
c->start_serialize<char> ();
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
unsigned obj_5 = add_object ("mn", 2, c);
[subset] Implement Kahn's algo for topological sorting instead of BFS.
2020-10-30 18:29:51 +01:00
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);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
c->pop_pack (false);
[subset] Implement Kahn's algo for topological sorting instead of BFS.
2020-10-30 18:29:51 +01:00
c->end_serialize();
}
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
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);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
c->pop_pack (false);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
c->end_serialize();
}
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
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);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
unsigned obj_b = c->pop_pack (false);
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
start_object ("e", 1, c);
add_virtual_offset (obj_b, c);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
unsigned obj_e = c->pop_pack (false);
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
start_object ("c", 1, c);
add_offset (obj_e, c);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
unsigned obj_c = c->pop_pack (false);
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
start_object ("a", 1, c);
add_offset (obj_b, c);
add_offset (obj_c, c);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
c->pop_pack (false);
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
c->end_serialize();
}
[repacker] add tests for special casing of 24bit offsets.
2022-07-06 21:18:27 +02:00
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();
}
[subset] add topological sort by closest distance via Dijkstra's algorithm.
2020-11-03 01:16:27 +01:00
static void test_sort_shortest ()
{
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 (c.object_graph ());
graph.sort_shortest_distance ();
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (4).head, "abc", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (4).real_links.length == 3);
assert(graph.object (4).real_links[0].objidx == 2);
assert(graph.object (4).real_links[1].objidx == 0);
assert(graph.object (4).real_links[2].objidx == 3);
[subset] add topological sort by closest distance via Dijkstra's algorithm.
2020-11-03 01:16:27 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (3).head, "mn", 2) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (3).real_links.length == 0);
[subset] add topological sort by closest distance via Dijkstra's algorithm.
2020-11-03 01:16:27 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (2).head, "def", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (2).real_links.length == 1);
assert(graph.object (2).real_links[0].objidx == 1);
[subset] add topological sort by closest distance via Dijkstra's algorithm.
2020-11-03 01:16:27 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (1).head, "ghi", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (1).real_links.length == 1);
assert(graph.object (1).real_links[0].objidx == 0);
[subset] add topological sort by closest distance via Dijkstra's algorithm.
2020-11-03 01:16:27 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (0).head, "jkl", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (0).real_links.length == 0);
[subset] fix memory leaks in test-repacker.
2020-11-11 22:55:35 +01:00
free (buffer);
[subset] add topological sort by closest distance via Dijkstra's algorithm.
2020-11-03 01:16:27 +01:00
}
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
static void test_duplicate_leaf ()
{
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 (c.object_graph ());
graph.duplicate (4, 1);
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (5).head, "abc", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (5).real_links.length == 3);
assert(graph.object (5).real_links[0].objidx == 3);
assert(graph.object (5).real_links[1].objidx == 4);
assert(graph.object (5).real_links[2].objidx == 0);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (4).head, "jkl", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (4).real_links.length == 0);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (3).head, "def", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (3).real_links.length == 1);
assert(graph.object (3).real_links[0].objidx == 2);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (2).head, "ghi", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (2).real_links.length == 1);
assert(graph.object (2).real_links[0].objidx == 1);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (1).head, "jkl", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (1).real_links.length == 0);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (0).head, "mn", 2) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (0).real_links.length == 0);
[subset] fix memory leaks in test-repacker.
2020-11-11 22:55:35 +01:00
free (buffer);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
}
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 (c.object_graph ());
graph.duplicate (3, 2);
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (6).head, "abc", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (6).real_links.length == 3);
assert(graph.object (6).real_links[0].objidx == 4);
assert(graph.object (6).real_links[1].objidx == 2);
assert(graph.object (6).real_links[2].objidx == 1);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (5).head, "jkl", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (5).real_links.length == 1);
assert(graph.object (5).real_links[0].objidx == 0);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (4).head, "def", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (4).real_links.length == 1);
assert(graph.object (4).real_links[0].objidx == 3);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (3).head, "ghi", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (3).real_links.length == 1);
assert(graph.object (3).real_links[0].objidx == 5);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (2).head, "jkl", 3) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (2).real_links.length == 1);
assert(graph.object (2).real_links[0].objidx == 0);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (1).head, "mn", 2) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (1).real_links.length == 0);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
[subset] refactor repacker graph to cache edge count and distances of vertices.
2020-11-07 00:37:05 +01:00
assert(strncmp (graph.object (0).head, "opqrst", 6) == 0);
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
assert(graph.object (0).real_links.length == 0);
[subset] fix memory leaks in test-repacker.
2020-11-11 22:55:35 +01:00
free (buffer);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
}
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
static void
test_serialize ()
{
size_t buffer_size = 100;
void* buffer_1 = malloc (buffer_size);
hb_serialize_context_t c1 (buffer_1, buffer_size);
[subset] finish up BFS sort implementation.
2020-10-29 22:58:34 +01:00
populate_serializer_simple (&c1);
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
hb_bytes_t expected = c1.copy_bytes ();
graph_t graph (c1.object_graph ());
[repacker] Begin splitting up the repacker implementation into several files.
2022-06-24 20:58:17 +02:00
hb_blob_t* out = graph::serialize (graph);
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
free (buffer_1);
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_bytes_t actual = out->as_bytes ();
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
assert (actual == expected);
Rename misc uses of "free" In preparation for fixing https://github.com/harfbuzz/harfbuzz/issues/3044
2021-07-08 18:53:45 +02:00
expected.fini ();
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_destroy (out);
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
}
Implement will_overflow ().
2020-11-02 23:51:39 +01:00
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 (c.object_graph ());
[repacker] extract graph serialization code into a seperate file.
2022-06-24 21:20:20 +02:00
assert (!graph::will_overflow (graph, nullptr));
[subset] fix memory leaks in test-repacker.
2020-11-11 22:55:35 +01:00
free (buffer);
Implement will_overflow ().
2020-11-02 23:51:39 +01:00
}
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 (c.object_graph ());
[repacker] extract graph serialization code into a seperate file.
2022-06-24 21:20:20 +02:00
assert (graph::will_overflow (graph, nullptr));
[subset] fix memory leaks in test-repacker.
2020-11-11 22:55:35 +01:00
free (buffer);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
}
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 (c.object_graph ());
[repacker] extract graph serialization code into a seperate file.
2022-06-24 21:20:20 +02:00
assert (graph::will_overflow (graph, nullptr));
[subset] fix memory leaks in test-repacker.
2020-11-11 22:55:35 +01:00
free (buffer);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
}
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 (c.object_graph ());
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE);
assert (out);
hb_bytes_t result = out->as_bytes ();
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
assert (result.length == (80000 + 3 + 3 * 2));
free (buffer);
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_destroy (out);
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
}
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 (c.object_graph ());
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE);
assert (out);
hb_bytes_t result = out->as_bytes ();
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
assert (result.length == (10000 + 2 * 2 + 60000 + 2 + 3 * 2));
free (buffer);
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_destroy (out);
Implement will_overflow ().
2020-11-02 23:51:39 +01:00
}
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
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);
[repacker] refactor resolve overflow tests to use a helper.
2021-10-05 22:10:01 +02:00
run_resolve_overflow_test ("test_resolve_overflows_via_space_assignment",
c,
e);
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
free (buffer);
free (expected_buffer);
}
[repacker] Add repacker test for subgraph isolation.
2021-09-09 00:07:02 +02:00
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 (c.object_graph ());
assert (c.offset_overflow ());
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG ('G', 'S', 'U', 'B'), 0);
assert (out);
hb_bytes_t result = out->as_bytes ();
[repacker] Add repacker test for subgraph isolation.
2021-09-09 00:07:02 +02:00
assert (result.length == (1 + 10000 + 60000 + 1 + 1
+ 4 + 3 * 2));
free (buffer);
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_destroy (out);
[repacker] Add repacker test for subgraph isolation.
2021-09-09 00:07:02 +02:00
}
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
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);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
void* expected_buffer = malloc (buffer_size);
hb_serialize_context_t e (expected_buffer, buffer_size);
populate_serializer_with_isolation_overflow_complex_expected (&e);
[repacker] refactor resolve overflow tests to use a helper.
2021-10-05 22:10:01 +02:00
run_resolve_overflow_test ("test_resolve_overflows_via_isolation_with_recursive_duplication",
c,
e);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
free (buffer);
[repacker] fix bug in subgraph isolation. Prior to this fix id remapping at the end of the isolation operation was fed the old subgraph instead of the new one. Which results in object indices being remapped for the nodes outside of the new subgraph. Adds a test which detects this problem.
2021-09-25 01:28:34 +02:00
free (expected_buffer);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
}
[repacker] restrict 32 bit subgraph connected component search to only nodes reachable via directed links.
2021-09-29 01:04:27 +02:00
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);
[repacker] refactor resolve overflow tests to use a helper.
2021-10-05 22:10:01 +02:00
run_resolve_overflow_test ("test_resolve_overflows_via_isolating_16bit_space",
c,
e);
[repacker] restrict 32 bit subgraph connected component search to only nodes reachable via directed links.
2021-09-29 01:04:27 +02:00
free (buffer);
free (expected_buffer);
}
[repacker] Handle the case where a subgraph root has an incoming 32 and 16 bit edge. In this case the entire subgraph from that root will be duplicated.
2021-09-29 23:28:27 +02:00
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);
[repacker] refactor resolve overflow tests to use a helper.
2021-10-05 22:10:01 +02:00
run_resolve_overflow_test ("test_resolve_overflows_via_isolating_16bit_space_2",
c,
e);
[repacker] Handle the case where a subgraph root has an incoming 32 and 16 bit edge. In this case the entire subgraph from that root will be duplicated.
2021-09-29 23:28:27 +02:00
free (buffer);
free (expected_buffer);
}
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
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 (c.object_graph ());
assert (c.offset_overflow ());
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG ('G', 'S', 'U', 'B'), 0);
assert (out);
hb_bytes_t result = out->as_bytes ();
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
unsigned expected_length = 3 + 2 * 60000; // objects
expected_length += 2 * 4 + 2 * 2; // links
assert (result.length == expected_length);
free (buffer);
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_destroy (out);
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
}
[repacker] put each 32 bit subgraph into it's own packing space. Each subgraph pointed to by a 32 bit offset should be packed into it's own space. This adds a space property to vertices which affects the distance calculation. This effectively places the distances for all of the nodes of a 32 bit subgraph into a distinct range. Thus all of the nodes of the subgraph will be packed together.
2021-09-09 01:08:48 +02:00
[repacker] add tests for special casing of 24bit offsets.
2022-07-06 21:18:27 +02:00
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 (c.object_graph ());
assert (c.offset_overflow ());
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG ('G', 'S', 'U', 'B'), 0);
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
assert (result.length == expected_length);
free (buffer);
hb_blob_destroy (out);
}
[repacker] add test for splitting spaces.
2021-10-05 20:30:04 +02:00
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);
[repacker] refactor resolve overflow tests to use a helper.
2021-10-05 22:10:01 +02:00
run_resolve_overflow_test ("test_resolve_overflows_via_splitting_spaces",
c,
e,
1);
[repacker] add test for splitting spaces.
2021-10-05 20:30:04 +02:00
free (buffer);
free (expected_buffer);
}
[repacker] Add additional splitting spaces test. Fix issues it uncovered.
2021-10-05 21:46:59 +02:00
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);
[repacker] refactor resolve overflow tests to use a helper.
2021-10-05 22:10:01 +02:00
run_resolve_overflow_test ("test_resolve_overflows_via_splitting_spaces_2",
c,
e,
1);
[repacker] Add additional splitting spaces test. Fix issues it uncovered.
2021-10-05 21:46:59 +02:00
free (buffer);
free (expected_buffer);
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
}
[repacker] add test case for using max priority to resolve an overflow.
2021-12-10 01:38:05 +01:00
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);
}
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
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);
[repacker] Add additional splitting spaces test. Fix issues it uncovered.
2021-10-05 21:46:59 +02:00
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_t* out = hb_resolve_overflows (c.object_graph (), HB_TAG_NONE);
assert (out);
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_bytes_t result = out->as_bytes ();
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
assert (result.length == 5 + 4 * 2);
assert (result[0] == 'a');
assert (result[5] == 'c');
assert (result[8] == 'e');
assert (result[9] == 'b');
assert (result[12] == 'd');
free (buffer);
[repacker] create repacker output buffer after final length is known. Don't rely on a buffer provided by the caller, as it may not be large enough.
2021-12-06 21:54:19 +01:00
hb_blob_destroy (out);
[repacker] Add additional splitting spaces test. Fix issues it uncovered.
2021-10-05 21:46:59 +02:00
}
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
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 ();
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 ();
assert(c.object_graph() [obj_d_1]->virtual_links.length == 2);
assert(c.object_graph() [obj_d_1]->virtual_links[0].objidx == obj_b);
assert(c.object_graph() [obj_d_1]->virtual_links[1].objidx == obj_c);
free(buffer);
}
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
// TODO(garretrieger): update will_overflow tests to check the overflows array.
[subset] Add prioritization offset resolution. Vertices can now be prioritized to force them to sort closer to their parent. The resolver will attempt to use this for overflows on non-shared vertices.
2020-11-07 01:22:48 +01:00
// TODO(garretrieger): add tests for priority raising.
[subset] re-write compute distances to use an array lookup for the distance map.
2020-11-05 18:21:25 +01:00
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
int
main (int argc, char **argv)
{
test_serialize ();
[subset] add topological sort by closest distance via Dijkstra's algorithm.
2020-11-03 01:16:27 +01:00
test_sort_shortest ();
Implement will_overflow ().
2020-11-02 23:51:39 +01:00
test_will_overflow_1 ();
test_will_overflow_2 ();
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
test_will_overflow_3 ();
test_resolve_overflows_via_sort ();
test_resolve_overflows_via_duplication ();
[repacker] add test case for using max priority to resolve an overflow.
2021-12-10 01:38:05 +01:00
test_resolve_overflows_via_priority ();
[repacker] add space assignment based on connected components. Assign each connected component that is underneath one or more 32 bit offsets into a unique space. This ensures that 32 bit subgraphs which are connected are packed into the same space.
2021-09-28 21:08:18 +02:00
test_resolve_overflows_via_space_assignment ();
[repacker] Add repacker test for subgraph isolation.
2021-09-09 00:07:02 +02:00
test_resolve_overflows_via_isolation ();
[repacker] add a couple more complex isolation tests.
2021-09-09 19:25:43 +02:00
test_resolve_overflows_via_isolation_with_recursive_duplication ();
test_resolve_overflows_via_isolation_spaces ();
[repacker] restrict 32 bit subgraph connected component search to only nodes reachable via directed links.
2021-09-29 01:04:27 +02:00
test_resolve_overflows_via_isolating_16bit_space ();
[repacker] Handle the case where a subgraph root has an incoming 32 and 16 bit edge. In this case the entire subgraph from that root will be duplicated.
2021-09-29 23:28:27 +02:00
test_resolve_overflows_via_isolating_16bit_space_2 ();
[repacker] add test for splitting spaces.
2021-10-05 20:30:04 +02:00
test_resolve_overflows_via_splitting_spaces ();
[repacker] Add additional splitting spaces test. Fix issues it uncovered.
2021-10-05 21:46:59 +02:00
test_resolve_overflows_via_splitting_spaces_2 ();
[repacker] add tests for special casing of 24bit offsets.
2022-07-06 21:18:27 +02:00
test_resolve_mixed_overflows_via_isolation_spaces ();
[subset] Add table duplication overflow resolution.
2020-11-06 01:39:23 +01:00
test_duplicate_leaf ();
test_duplicate_interior ();
[repacker] Add test for virtual links in the repacker.
2021-09-23 23:41:42 +02:00
test_virtual_link ();
[subset] Improve sharing of Ligature subtables. Ligature subtables use virtual links to enforce an ordering constraint between the subtables and the coverage table. Unfortunately this has the sideeffect of prevent the subtables from being shared by another Ligature with a different coverage table since object equality compares all links real and virtual. This change makes virtual links stored separately from real links and updates the equality check to only check real links. If an object is de-duped any virtual links it has are merged into the object that replaces it.
2021-11-30 22:45:22 +01:00
test_shared_node_with_virtual_links ();
[subset] Start a proof of concept implementation of the GSUB/GPOS offset overflow resolver.
2020-10-29 01:49:09 +01:00
}