mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
655 lines
24 KiB
C++
655 lines
24 KiB
C++
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <random>
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <log/log.h>
|
|
#include <minikin/CmapCoverage.h>
|
|
#include <minikin/SparseBitSet.h>
|
|
|
|
namespace minikin {
|
|
|
|
size_t writeU16(uint16_t x, uint8_t* out, size_t offset) {
|
|
out[offset] = x >> 8;
|
|
out[offset + 1] = x;
|
|
return offset + 2;
|
|
}
|
|
|
|
size_t writeI16(int16_t sx, uint8_t* out, size_t offset) {
|
|
return writeU16(static_cast<uint16_t>(sx), out, offset);
|
|
}
|
|
|
|
size_t writeU32(uint32_t x, uint8_t* out, size_t offset) {
|
|
out[offset] = x >> 24;
|
|
out[offset + 1] = x >> 16;
|
|
out[offset + 2] = x >> 8;
|
|
out[offset + 3] = x;
|
|
return offset + 4;
|
|
}
|
|
|
|
// Returns valid cmap format 4 table contents. All glyph ID is same value as
|
|
// code point. (e.g. 'a' (U+0061) is mapped to Glyph ID = 0x0061). 'range'
|
|
// should be specified with inclusive-inclusive values.
|
|
static std::vector<uint8_t> buildCmapFormat4Table(
|
|
const std::vector<uint16_t>& ranges) {
|
|
uint16_t segmentCount = ranges.size() / 2 + 1 /* +1 for end marker */;
|
|
|
|
const size_t numOfUint16 =
|
|
8 /* format, length, languages, segCountX2, searchRange, entrySelector,
|
|
rangeShift, pad */
|
|
+ segmentCount * 4 /* endCount, startCount, idRange, idRangeOffset */;
|
|
const size_t finalLength = sizeof(uint16_t) * numOfUint16;
|
|
|
|
std::vector<uint8_t> out(finalLength);
|
|
size_t head = 0;
|
|
head = writeU16(4, out.data(), head); // format
|
|
head = writeU16(finalLength, out.data(), head); // length
|
|
head = writeU16(0, out.data(), head); // langauge
|
|
|
|
const uint16_t searchRange =
|
|
2 * (1 << static_cast<int>(floor(log2(segmentCount))));
|
|
|
|
head = writeU16(segmentCount * 2, out.data(), head); // segCountX2
|
|
head = writeU16(searchRange, out.data(), head); // searchRange
|
|
head = writeU16(__builtin_ctz(searchRange) - 1, out.data(),
|
|
head); // entrySelector
|
|
head =
|
|
writeU16(segmentCount * 2 - searchRange, out.data(), head); // rangeShift
|
|
|
|
size_t endCountHead = head;
|
|
size_t startCountHead =
|
|
head + segmentCount * sizeof(uint16_t) + 2 /* padding */;
|
|
size_t idDeltaHead = startCountHead + segmentCount * sizeof(uint16_t);
|
|
size_t idRangeOffsetHead = idDeltaHead + segmentCount * sizeof(uint16_t);
|
|
|
|
for (size_t i = 0; i < ranges.size() / 2; ++i) {
|
|
const uint16_t begin = ranges[i * 2];
|
|
const uint16_t end = ranges[i * 2 + 1];
|
|
startCountHead = writeU16(begin, out.data(), startCountHead);
|
|
endCountHead = writeU16(end, out.data(), endCountHead);
|
|
// map glyph ID as the same value of the code point.
|
|
idDeltaHead = writeU16(0, out.data(), idDeltaHead);
|
|
idRangeOffsetHead =
|
|
writeU16(0 /* we don't use this */, out.data(), idRangeOffsetHead);
|
|
}
|
|
|
|
// fill end marker
|
|
endCountHead = writeU16(0xFFFF, out.data(), endCountHead);
|
|
startCountHead = writeU16(0xFFFF, out.data(), startCountHead);
|
|
idDeltaHead = writeU16(1, out.data(), idDeltaHead);
|
|
idRangeOffsetHead = writeU16(0, out.data(), idRangeOffsetHead);
|
|
LOG_ALWAYS_FATAL_IF(endCountHead > finalLength);
|
|
LOG_ALWAYS_FATAL_IF(startCountHead > finalLength);
|
|
LOG_ALWAYS_FATAL_IF(idDeltaHead > finalLength);
|
|
LOG_ALWAYS_FATAL_IF(idRangeOffsetHead != finalLength);
|
|
return out;
|
|
}
|
|
|
|
// Returns valid cmap format 4 table contents. All glyph ID is same value as
|
|
// code point. (e.g. 'a' (U+0061) is mapped to Glyph ID = 0x0061). 'range'
|
|
// should be specified with inclusive-inclusive values.
|
|
static std::vector<uint8_t> buildCmapFormat12Table(
|
|
const std::vector<uint32_t>& ranges) {
|
|
uint32_t numGroups = ranges.size() / 2;
|
|
|
|
const size_t finalLength =
|
|
2 /* format */ + 2 /* reserved */ + 4 /* length */ + 4 /* languages */ +
|
|
4 /* numGroups */ + 12 /* size of a group */ * numGroups;
|
|
|
|
std::vector<uint8_t> out(finalLength);
|
|
size_t head = 0;
|
|
head = writeU16(12, out.data(), head); // format
|
|
head = writeU16(0, out.data(), head); // reserved
|
|
head = writeU32(finalLength, out.data(), head); // length
|
|
head = writeU32(0, out.data(), head); // langauge
|
|
head = writeU32(numGroups, out.data(), head); // numGroups
|
|
|
|
for (uint32_t i = 0; i < numGroups; ++i) {
|
|
const uint32_t start = ranges[2 * i];
|
|
const uint32_t end = ranges[2 * i + 1];
|
|
head = writeU32(start, out.data(), head);
|
|
head = writeU32(end, out.data(), head);
|
|
// map glyph ID as the same value of the code point.
|
|
// TODO: Use glyph IDs lower than 65535.
|
|
// Cmap can store 32 bit glyph ID but due to the size of numGlyph, a font
|
|
// file can contain up to 65535 glyphs in a file.
|
|
head = writeU32(start, out.data(), head);
|
|
}
|
|
|
|
LOG_ALWAYS_FATAL_IF(head != finalLength);
|
|
return out;
|
|
}
|
|
|
|
class CmapBuilder {
|
|
public:
|
|
static constexpr size_t kEncodingTableHead = 4;
|
|
static constexpr size_t kEncodingTableSize = 8;
|
|
|
|
CmapBuilder(int numTables) : mNumTables(numTables), mCurrentTableIndex(0) {
|
|
const size_t headerSize =
|
|
2 /* version */ + 2 /* numTables */ + kEncodingTableSize * numTables;
|
|
out.resize(headerSize);
|
|
writeU16(0, out.data(), 0);
|
|
writeU16(numTables, out.data(), 2);
|
|
}
|
|
|
|
void appendTable(uint16_t platformId,
|
|
uint16_t encodingId,
|
|
const std::vector<uint8_t>& table) {
|
|
appendEncodingTable(platformId, encodingId, out.size());
|
|
out.insert(out.end(), table.begin(), table.end());
|
|
}
|
|
|
|
// TODO: Introduce Format 14 table builder.
|
|
|
|
std::vector<uint8_t> build() {
|
|
LOG_ALWAYS_FATAL_IF(mCurrentTableIndex != mNumTables);
|
|
return out;
|
|
}
|
|
|
|
// Helper functions.
|
|
static std::vector<uint8_t> buildSingleFormat4Cmap(
|
|
uint16_t platformId,
|
|
uint16_t encodingId,
|
|
const std::vector<uint16_t>& ranges) {
|
|
CmapBuilder builder(1);
|
|
builder.appendTable(platformId, encodingId, buildCmapFormat4Table(ranges));
|
|
return builder.build();
|
|
}
|
|
|
|
static std::vector<uint8_t> buildSingleFormat12Cmap(
|
|
uint16_t platformId,
|
|
uint16_t encodingId,
|
|
const std::vector<uint32_t>& ranges) {
|
|
CmapBuilder builder(1);
|
|
builder.appendTable(platformId, encodingId, buildCmapFormat12Table(ranges));
|
|
return builder.build();
|
|
}
|
|
|
|
private:
|
|
void appendEncodingTable(uint16_t platformId,
|
|
uint16_t encodingId,
|
|
uint32_t offset) {
|
|
LOG_ALWAYS_FATAL_IF(mCurrentTableIndex == mNumTables);
|
|
|
|
const size_t currentEncodingTableHead =
|
|
kEncodingTableHead + mCurrentTableIndex * kEncodingTableSize;
|
|
size_t head = writeU16(platformId, out.data(), currentEncodingTableHead);
|
|
head = writeU16(encodingId, out.data(), head);
|
|
head = writeU32(offset, out.data(), head);
|
|
LOG_ALWAYS_FATAL_IF((head - currentEncodingTableHead) !=
|
|
kEncodingTableSize);
|
|
mCurrentTableIndex++;
|
|
}
|
|
|
|
int mNumTables;
|
|
int mCurrentTableIndex;
|
|
std::vector<uint8_t> out;
|
|
};
|
|
|
|
TEST(CmapCoverageTest, SingleFormat4_brokenCmap) {
|
|
bool has_cmap_format_14_subtable = false;
|
|
{
|
|
SCOPED_TRACE("Reading beyond buffer size - Too small cmap size");
|
|
std::vector<uint8_t> cmap = CmapBuilder::buildSingleFormat4Cmap(
|
|
0, 0, std::vector<uint16_t>({'a', 'a'}));
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), 3 /* too small */, &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE(
|
|
"Reading beyond buffer size - space needed for tables goes beyond cmap "
|
|
"size");
|
|
std::vector<uint8_t> cmap = CmapBuilder::buildSingleFormat4Cmap(
|
|
0, 0, std::vector<uint16_t>({'a', 'a'}));
|
|
|
|
writeU16(1000, cmap.data(), 2 /* offset of num tables in cmap header */);
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE(
|
|
"Reading beyond buffer size - Invalid offset in encoding table");
|
|
std::vector<uint8_t> cmap = CmapBuilder::buildSingleFormat4Cmap(
|
|
0, 0, std::vector<uint16_t>({'a', 'a'}));
|
|
|
|
writeU16(1000, cmap.data(),
|
|
8 /* offset of the offset in the first encoding record */);
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
|
|
TEST(CmapCoverageTest, SingleFormat4) {
|
|
bool has_cmap_format_14_subtable = false;
|
|
struct TestCast {
|
|
std::string testTitle;
|
|
uint16_t platformId;
|
|
uint16_t encodingId;
|
|
} TEST_CASES[] = {
|
|
{"Platform 0, Encoding 0", 0, 0}, {"Platform 0, Encoding 1", 0, 1},
|
|
{"Platform 0, Encoding 2", 0, 2}, {"Platform 0, Encoding 3", 0, 3},
|
|
{"Platform 3, Encoding 1", 3, 1},
|
|
};
|
|
|
|
for (const auto& testCase : TEST_CASES) {
|
|
SCOPED_TRACE(testCase.testTitle.c_str());
|
|
std::vector<uint8_t> cmap = CmapBuilder::buildSingleFormat4Cmap(
|
|
testCase.platformId, testCase.encodingId,
|
|
std::vector<uint16_t>({'a', 'a'}));
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a'));
|
|
EXPECT_FALSE(coverage.get('b'));
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
|
|
TEST(CmapCoverageTest, SingleFormat12) {
|
|
bool has_cmap_format_14_subtable = false;
|
|
|
|
struct TestCast {
|
|
std::string testTitle;
|
|
uint16_t platformId;
|
|
uint16_t encodingId;
|
|
} TEST_CASES[] = {
|
|
{"Platform 0, Encoding 4", 0, 4},
|
|
{"Platform 0, Encoding 6", 0, 6},
|
|
{"Platform 3, Encoding 10", 3, 10},
|
|
};
|
|
|
|
for (const auto& testCase : TEST_CASES) {
|
|
SCOPED_TRACE(testCase.testTitle.c_str());
|
|
std::vector<uint8_t> cmap = CmapBuilder::buildSingleFormat12Cmap(
|
|
testCase.platformId, testCase.encodingId,
|
|
std::vector<uint32_t>({'a', 'a'}));
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a'));
|
|
EXPECT_FALSE(coverage.get('b'));
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
|
|
TEST(CmapCoverageTest, Format12_beyondTheUnicodeLimit) {
|
|
bool has_cmap_format_14_subtable = false;
|
|
{
|
|
SCOPED_TRACE(
|
|
"Starting range is out of Unicode code point. Should be ignored.");
|
|
std::vector<uint8_t> cmap = CmapBuilder::buildSingleFormat12Cmap(
|
|
0, 0, std::vector<uint32_t>({'a', 'a', 0x110000, 0x110000}));
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a'));
|
|
EXPECT_FALSE(coverage.get(0x110000));
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE(
|
|
"Ending range is out of Unicode code point. Should be ignored.");
|
|
std::vector<uint8_t> cmap = CmapBuilder::buildSingleFormat12Cmap(
|
|
0, 0, std::vector<uint32_t>({'a', 'a', 0x10FF00, 0x110000}));
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a'));
|
|
EXPECT_TRUE(coverage.get(0x10FF00));
|
|
EXPECT_TRUE(coverage.get(0x10FFFF));
|
|
EXPECT_FALSE(coverage.get(0x110000));
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
|
|
TEST(CmapCoverageTest, notSupportedEncodings) {
|
|
bool has_cmap_format_14_subtable = false;
|
|
|
|
struct TestCast {
|
|
std::string testTitle;
|
|
uint16_t platformId;
|
|
uint16_t encodingId;
|
|
} TEST_CASES[] = {
|
|
// Any encodings with platform 2 is not supported.
|
|
{"Platform 2, Encoding 0", 2, 0},
|
|
{"Platform 2, Encoding 1", 2, 1},
|
|
{"Platform 2, Encoding 2", 2, 2},
|
|
{"Platform 2, Encoding 3", 2, 3},
|
|
// UCS-2 or UCS-4 are supported on Platform == 3. Others are not
|
|
// supported.
|
|
{"Platform 3, Encoding 0", 3, 0}, // Symbol
|
|
{"Platform 3, Encoding 2", 3, 2}, // ShiftJIS
|
|
{"Platform 3, Encoding 3", 3, 3}, // RPC
|
|
{"Platform 3, Encoding 4", 3, 4}, // Big5
|
|
{"Platform 3, Encoding 5", 3, 5}, // Wansung
|
|
{"Platform 3, Encoding 6", 3, 6}, // Johab
|
|
{"Platform 3, Encoding 7", 3, 7}, // Reserved
|
|
{"Platform 3, Encoding 8", 3, 8}, // Reserved
|
|
{"Platform 3, Encoding 9", 3, 9}, // Reserved
|
|
// Uknown platforms
|
|
{"Platform 4, Encoding 0", 4, 0},
|
|
{"Platform 5, Encoding 1", 5, 1},
|
|
{"Platform 6, Encoding 0", 6, 0},
|
|
{"Platform 7, Encoding 1", 7, 1},
|
|
};
|
|
|
|
for (const auto& testCase : TEST_CASES) {
|
|
SCOPED_TRACE(testCase.testTitle.c_str());
|
|
CmapBuilder builder(1);
|
|
std::vector<uint8_t> cmap = CmapBuilder::buildSingleFormat4Cmap(
|
|
testCase.platformId, testCase.encodingId,
|
|
std::vector<uint16_t>({'a', 'a'}));
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
|
|
TEST(CmapCoverageTest, brokenFormat4Table) {
|
|
bool has_cmap_format_14_subtable = false;
|
|
{
|
|
SCOPED_TRACE("Too small table cmap size");
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat4Table(std::vector<uint16_t>({'a', 'a'}));
|
|
table.resize(2); // Remove trailing data.
|
|
|
|
CmapBuilder builder(1);
|
|
builder.appendTable(0, 0, table);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE("Too many segments");
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat4Table(std::vector<uint16_t>({'a', 'a'}));
|
|
writeU16(5000, table.data(),
|
|
6 /* segment count offset */); // 5000 segments.
|
|
CmapBuilder builder(1);
|
|
builder.appendTable(0, 0, table);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE("Inversed range");
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat4Table(std::vector<uint16_t>({'b', 'b'}));
|
|
// Put smaller end code point to inverse the range.
|
|
writeU16('a', table.data(), 14 /* the first element of endCount offset */);
|
|
CmapBuilder builder(1);
|
|
builder.appendTable(0, 0, table);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
|
|
TEST(CmapCoverageTest, brokenFormat12Table) {
|
|
bool has_cmap_format_14_subtable = false;
|
|
{
|
|
SCOPED_TRACE("Too small cmap size");
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat12Table(std::vector<uint32_t>({'a', 'a'}));
|
|
table.resize(2); // Remove trailing data.
|
|
|
|
CmapBuilder builder(1);
|
|
builder.appendTable(0, 0, table);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE("Too many groups");
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat12Table(std::vector<uint32_t>({'a', 'a'}));
|
|
writeU32(5000, table.data(), 12 /* num group offset */); // 5000 groups.
|
|
|
|
CmapBuilder builder(1);
|
|
builder.appendTable(0, 0, table);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE("Inversed range.");
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat12Table(std::vector<uint32_t>({'a', 'a'}));
|
|
// Put larger start code point to inverse the range.
|
|
writeU32('b', table.data(),
|
|
16 /* start code point offset in the first group */);
|
|
|
|
CmapBuilder builder(1);
|
|
builder.appendTable(0, 0, table);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE("Too large code point");
|
|
std::vector<uint8_t> cmap = CmapBuilder::buildSingleFormat12Cmap(
|
|
0, 0, std::vector<uint32_t>({0x110000, 0x110000}));
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_EQ(0U, coverage.length());
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
|
|
TEST(CmapCoverageTest, TableSelection_Priority) {
|
|
bool has_cmap_format_14_subtable = false;
|
|
std::vector<uint8_t> highestFormat12Table =
|
|
buildCmapFormat12Table(std::vector<uint32_t>({'a', 'a'}));
|
|
std::vector<uint8_t> highestFormat4Table =
|
|
buildCmapFormat4Table(std::vector<uint16_t>({'a', 'a'}));
|
|
std::vector<uint8_t> format4 =
|
|
buildCmapFormat4Table(std::vector<uint16_t>({'b', 'b'}));
|
|
std::vector<uint8_t> format12 =
|
|
buildCmapFormat12Table(std::vector<uint32_t>({'b', 'b'}));
|
|
|
|
{
|
|
SCOPED_TRACE("(platform, encoding) = (3, 10) is the highest priority.");
|
|
|
|
struct LowerPriorityTable {
|
|
uint16_t platformId;
|
|
uint16_t encodingId;
|
|
const std::vector<uint8_t>& table;
|
|
} LOWER_PRIORITY_TABLES[] = {
|
|
{0, 0, format4}, {0, 1, format4}, {0, 2, format4}, {0, 3, format4},
|
|
{0, 4, format12}, {0, 6, format12}, {3, 1, format4},
|
|
};
|
|
|
|
for (const auto& table : LOWER_PRIORITY_TABLES) {
|
|
CmapBuilder builder(2);
|
|
builder.appendTable(table.platformId, table.encodingId, table.table);
|
|
builder.appendTable(3, 10, highestFormat12Table);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a')); // comes from highest table
|
|
EXPECT_FALSE(coverage.get('b')); // should not use other table.
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
{
|
|
SCOPED_TRACE("(platform, encoding) = (3, 1) case");
|
|
|
|
struct LowerPriorityTable {
|
|
uint16_t platformId;
|
|
uint16_t encodingId;
|
|
const std::vector<uint8_t>& table;
|
|
} LOWER_PRIORITY_TABLES[] = {
|
|
{0, 0, format4},
|
|
{0, 1, format4},
|
|
{0, 2, format4},
|
|
{0, 3, format4},
|
|
};
|
|
|
|
for (const auto& table : LOWER_PRIORITY_TABLES) {
|
|
CmapBuilder builder(2);
|
|
builder.appendTable(table.platformId, table.encodingId, table.table);
|
|
builder.appendTable(3, 1, highestFormat4Table);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a')); // comes from highest table
|
|
EXPECT_FALSE(coverage.get('b')); // should not use other table.
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(CmapCoverageTest, TableSelection_SkipBrokenFormat4Table) {
|
|
SparseBitSet coverage;
|
|
bool has_cmap_format_14_subtable = false;
|
|
std::vector<uint8_t> validTable =
|
|
buildCmapFormat4Table(std::vector<uint16_t>({'a', 'a'}));
|
|
{
|
|
SCOPED_TRACE("Unsupported format");
|
|
CmapBuilder builder(2);
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat4Table(std::vector<uint16_t>({'b', 'b'}));
|
|
writeU16(0, table.data(), 0 /* format offset */);
|
|
builder.appendTable(3, 1, table);
|
|
builder.appendTable(0, 0, validTable);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a')); // comes from valid table
|
|
EXPECT_FALSE(coverage.get('b')); // should not use invalid table.
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE("Invalid language");
|
|
CmapBuilder builder(2);
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat4Table(std::vector<uint16_t>({'b', 'b'}));
|
|
writeU16(1, table.data(), 4 /* language offset */);
|
|
builder.appendTable(3, 1, table);
|
|
builder.appendTable(0, 0, validTable);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a')); // comes from valid table
|
|
EXPECT_FALSE(coverage.get('b')); // should not use invalid table.
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE("Invalid length");
|
|
CmapBuilder builder(2);
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat4Table(std::vector<uint16_t>({'b', 'b'}));
|
|
writeU16(5000, table.data(), 2 /* length offset */);
|
|
builder.appendTable(3, 1, table);
|
|
builder.appendTable(0, 0, validTable);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a')); // comes from valid table
|
|
EXPECT_FALSE(coverage.get('b')); // should not use invalid table.
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
|
|
TEST(CmapCoverageTest, TableSelection_SkipBrokenFormat12Table) {
|
|
SparseBitSet coverage;
|
|
bool has_cmap_format_14_subtable = false;
|
|
std::vector<uint8_t> validTable =
|
|
buildCmapFormat12Table(std::vector<uint32_t>({'a', 'a'}));
|
|
{
|
|
SCOPED_TRACE("Unsupported format");
|
|
CmapBuilder builder(2);
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat12Table(std::vector<uint32_t>({'b', 'b'}));
|
|
writeU16(0, table.data(), 0 /* format offset */);
|
|
builder.appendTable(3, 1, table);
|
|
builder.appendTable(0, 0, validTable);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a')); // comes from valid table
|
|
EXPECT_FALSE(coverage.get('b')); // should not use invalid table.
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE("Invalid language");
|
|
CmapBuilder builder(2);
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat12Table(std::vector<uint32_t>({'b', 'b'}));
|
|
writeU32(1, table.data(), 8 /* language offset */);
|
|
builder.appendTable(3, 1, table);
|
|
builder.appendTable(0, 0, validTable);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a')); // comes from valid table
|
|
EXPECT_FALSE(coverage.get('b')); // should not use invalid table.
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
{
|
|
SCOPED_TRACE("Invalid length");
|
|
CmapBuilder builder(2);
|
|
std::vector<uint8_t> table =
|
|
buildCmapFormat12Table(std::vector<uint32_t>({'b', 'b'}));
|
|
writeU32(5000, table.data(), 4 /* length offset */);
|
|
builder.appendTable(3, 1, table);
|
|
builder.appendTable(0, 0, validTable);
|
|
std::vector<uint8_t> cmap = builder.build();
|
|
|
|
SparseBitSet coverage = CmapCoverage::getCoverage(
|
|
cmap.data(), cmap.size(), &has_cmap_format_14_subtable);
|
|
EXPECT_TRUE(coverage.get('a')); // comes from valid table
|
|
EXPECT_FALSE(coverage.get('b')); // should not use invalid table.
|
|
EXPECT_FALSE(has_cmap_format_14_subtable);
|
|
}
|
|
}
|
|
|
|
} // namespace minikin
|