blob: 919259e4d30e3f5854713b7c462eb321e084a117 [file] [log] [blame]
/*
* Copyright (C) 2015 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 "utf.h"
#include <map>
#include <vector>
#include <android-base/stringprintf.h>
#include "gtest/gtest.h"
#include "utf-inl.h"
namespace art {
class UtfTest : public testing::Test {};
TEST_F(UtfTest, GetLeadingUtf16Char) {
EXPECT_EQ(0xffff, GetLeadingUtf16Char(0xeeeeffff));
}
TEST_F(UtfTest, GetTrailingUtf16Char) {
EXPECT_EQ(0xffff, GetTrailingUtf16Char(0xffffeeee));
EXPECT_EQ(0, GetTrailingUtf16Char(0x0000aaaa));
}
#define EXPECT_ARRAY_POSITION(expected, end, start) \
EXPECT_EQ(static_cast<uintptr_t>(expected), \
reinterpret_cast<uintptr_t>(end) - reinterpret_cast<uintptr_t>(start));
// A test string containing one, two, three and four byte UTF-8 sequences.
static const uint8_t kAllSequences[] = {
0x24,
0xc2, 0xa2,
0xe2, 0x82, 0xac,
0xf0, 0x9f, 0x8f, 0xa0,
0x00
};
// A test string that contains a UTF-8 encoding of a surrogate pair
// (code point = U+10400).
static const uint8_t kSurrogateEncoding[] = {
0xed, 0xa0, 0x81,
0xed, 0xb0, 0x80,
0x00
};
TEST_F(UtfTest, GetUtf16FromUtf8) {
const char* const start = reinterpret_cast<const char*>(kAllSequences);
const char* ptr = start;
uint32_t pair = 0;
// Single byte sequence.
pair = GetUtf16FromUtf8(&ptr);
EXPECT_EQ(0x24, GetLeadingUtf16Char(pair));
EXPECT_EQ(0, GetTrailingUtf16Char(pair));
EXPECT_ARRAY_POSITION(1, ptr, start);
// Two byte sequence.
pair = GetUtf16FromUtf8(&ptr);
EXPECT_EQ(0xa2, GetLeadingUtf16Char(pair));
EXPECT_EQ(0, GetTrailingUtf16Char(pair));
EXPECT_ARRAY_POSITION(3, ptr, start);
// Three byte sequence.
pair = GetUtf16FromUtf8(&ptr);
EXPECT_EQ(0x20ac, GetLeadingUtf16Char(pair));
EXPECT_EQ(0, GetTrailingUtf16Char(pair));
EXPECT_ARRAY_POSITION(6, ptr, start);
// Four byte sequence
pair = GetUtf16FromUtf8(&ptr);
EXPECT_EQ(0xd83c, GetLeadingUtf16Char(pair));
EXPECT_EQ(0xdfe0, GetTrailingUtf16Char(pair));
EXPECT_ARRAY_POSITION(10, ptr, start);
// Null terminator.
pair = GetUtf16FromUtf8(&ptr);
EXPECT_EQ(0, GetLeadingUtf16Char(pair));
EXPECT_EQ(0, GetTrailingUtf16Char(pair));
EXPECT_ARRAY_POSITION(11, ptr, start);
}
TEST_F(UtfTest, GetUtf16FromUtf8_SurrogatesPassThrough) {
const char* const start = reinterpret_cast<const char *>(kSurrogateEncoding);
const char* ptr = start;
uint32_t pair = 0;
pair = GetUtf16FromUtf8(&ptr);
EXPECT_EQ(0xd801, GetLeadingUtf16Char(pair));
EXPECT_EQ(0, GetTrailingUtf16Char(pair));
EXPECT_ARRAY_POSITION(3, ptr, start);
pair = GetUtf16FromUtf8(&ptr);
EXPECT_EQ(0xdc00, GetLeadingUtf16Char(pair));
EXPECT_EQ(0, GetTrailingUtf16Char(pair));
EXPECT_ARRAY_POSITION(6, ptr, start);
}
TEST_F(UtfTest, CountModifiedUtf8Chars) {
EXPECT_EQ(5u, CountModifiedUtf8Chars(reinterpret_cast<const char *>(kAllSequences)));
EXPECT_EQ(2u, CountModifiedUtf8Chars(reinterpret_cast<const char *>(kSurrogateEncoding)));
}
static void AssertConversion(const std::vector<uint16_t>& input,
const std::vector<uint8_t>& expected) {
ASSERT_EQ(expected.size(), CountUtf8Bytes(&input[0], input.size()));
std::vector<uint8_t> output(expected.size());
ConvertUtf16ToModifiedUtf8(reinterpret_cast<char*>(&output[0]), expected.size(),
&input[0], input.size());
EXPECT_EQ(expected, output);
}
TEST_F(UtfTest, CountAndConvertUtf8Bytes) {
// Surrogate pairs will be converted into 4 byte sequences.
AssertConversion({ 0xd801, 0xdc00 }, { 0xf0, 0x90, 0x90, 0x80 });
// Three byte encodings that are below & above the leading surrogate
// range respectively.
AssertConversion({ 0xdef0 }, { 0xed, 0xbb, 0xb0 });
AssertConversion({ 0xdcff }, { 0xed, 0xb3, 0xbf });
// Two byte encoding.
AssertConversion({ 0x0101 }, { 0xc4, 0x81 });
// Two byte special case : 0 must use an overlong encoding.
AssertConversion({ 0x0101, 0x0000 }, { 0xc4, 0x81, 0xc0, 0x80 });
// One byte encoding.
AssertConversion({ 'h', 'e', 'l', 'l', 'o' }, { 0x68, 0x65, 0x6c, 0x6c, 0x6f });
AssertConversion({
0xd802, 0xdc02, // Surrogate pair.
0xdef0, 0xdcff, // Three byte encodings.
0x0101, 0x0000, // Two byte encodings.
'p' , 'p' // One byte encoding.
}, {
0xf0, 0x90, 0xa0, 0x82,
0xed, 0xbb, 0xb0, 0xed, 0xb3, 0xbf,
0xc4, 0x81, 0xc0, 0x80,
0x70, 0x70
});
}
TEST_F(UtfTest, CountAndConvertUtf8Bytes_UnpairedSurrogate) {
// Unpaired trailing surrogate at the end of input.
AssertConversion({ 'h', 'e', 0xd801 }, { 'h', 'e', 0xed, 0xa0, 0x81 });
// Unpaired (or incorrectly paired) surrogates in the middle of the input.
const std::map<std::vector<uint16_t>, std::vector<uint8_t>> prefixes {
{{ 'h' }, { 'h' }},
{{ 0 }, { 0xc0, 0x80 }},
{{ 0x81 }, { 0xc2, 0x81 }},
{{ 0x801 }, { 0xe0, 0xa0, 0x81 }},
};
const std::map<std::vector<uint16_t>, std::vector<uint8_t>> suffixes {
{{ 'e' }, { 'e' }},
{{ 0 }, { 0xc0, 0x80 }},
{{ 0x7ff }, { 0xdf, 0xbf }},
{{ 0xffff }, { 0xef, 0xbf, 0xbf }},
};
const std::map<std::vector<uint16_t>, std::vector<uint8_t>> tests {
{{ 0xd801 }, { 0xed, 0xa0, 0x81 }},
{{ 0xdc00 }, { 0xed, 0xb0, 0x80 }},
{{ 0xd801, 0xd801 }, { 0xed, 0xa0, 0x81, 0xed, 0xa0, 0x81 }},
{{ 0xdc00, 0xdc00 }, { 0xed, 0xb0, 0x80, 0xed, 0xb0, 0x80 }},
};
for (const auto& prefix : prefixes) {
const std::vector<uint16_t>& prefix_in = prefix.first;
const std::vector<uint8_t>& prefix_out = prefix.second;
for (const auto& test : tests) {
const std::vector<uint16_t>& test_in = test.first;
const std::vector<uint8_t>& test_out = test.second;
for (const auto& suffix : suffixes) {
const std::vector<uint16_t>& suffix_in = suffix.first;
const std::vector<uint8_t>& suffix_out = suffix.second;
std::vector<uint16_t> in = prefix_in;
in.insert(in.end(), test_in.begin(), test_in.end());
in.insert(in.end(), suffix_in.begin(), suffix_in.end());
std::vector<uint8_t> out = prefix_out;
out.insert(out.end(), test_out.begin(), test_out.end());
out.insert(out.end(), suffix_out.begin(), suffix_out.end());
AssertConversion(in, out);
}
}
}
}
// Old versions of functions, here to compare answers with optimized versions.
size_t CountModifiedUtf8Chars_reference(const char* utf8) {
size_t len = 0;
int ic;
while ((ic = *utf8++) != '\0') {
len++;
if ((ic & 0x80) == 0) {
// one-byte encoding
continue;
}
// two- or three-byte encoding
utf8++;
if ((ic & 0x20) == 0) {
// two-byte encoding
continue;
}
utf8++;
if ((ic & 0x10) == 0) {
// three-byte encoding
continue;
}
// four-byte encoding: needs to be converted into a surrogate
// pair.
utf8++;
len++;
}
return len;
}
static size_t CountUtf8Bytes_reference(const uint16_t* chars, size_t char_count) {
size_t result = 0;
while (char_count--) {
const uint16_t ch = *chars++;
if (ch > 0 && ch <= 0x7f) {
++result;
} else if (ch >= 0xd800 && ch <= 0xdbff) {
if (char_count > 0) {
const uint16_t ch2 = *chars;
// If we find a properly paired surrogate, we emit it as a 4 byte
// UTF sequence. If we find an unpaired leading or trailing surrogate,
// we emit it as a 3 byte sequence like would have done earlier.
if (ch2 >= 0xdc00 && ch2 <= 0xdfff) {
chars++;
char_count--;
result += 4;
} else {
result += 3;
}
} else {
// This implies we found an unpaired trailing surrogate at the end
// of a string.
result += 3;
}
} else if (ch > 0x7ff) {
result += 3;
} else {
result += 2;
}
}
return result;
}
static void ConvertUtf16ToModifiedUtf8_reference(char* utf8_out, const uint16_t* utf16_in,
size_t char_count) {
while (char_count--) {
const uint16_t ch = *utf16_in++;
if (ch > 0 && ch <= 0x7f) {
*utf8_out++ = ch;
} else {
// Char_count == 0 here implies we've encountered an unpaired
// surrogate and we have no choice but to encode it as 3-byte UTF
// sequence. Note that unpaired surrogates can occur as a part of
// "normal" operation.
if ((ch >= 0xd800 && ch <= 0xdbff) && (char_count > 0)) {
const uint16_t ch2 = *utf16_in;
// Check if the other half of the pair is within the expected
// range. If it isn't, we will have to emit both "halves" as
// separate 3 byte sequences.
if (ch2 >= 0xdc00 && ch2 <= 0xdfff) {
utf16_in++;
char_count--;
const uint32_t code_point = (ch << 10) + ch2 - 0x035fdc00;
*utf8_out++ = (code_point >> 18) | 0xf0;
*utf8_out++ = ((code_point >> 12) & 0x3f) | 0x80;
*utf8_out++ = ((code_point >> 6) & 0x3f) | 0x80;
*utf8_out++ = (code_point & 0x3f) | 0x80;
continue;
}
}
if (ch > 0x07ff) {
// Three byte encoding.
*utf8_out++ = (ch >> 12) | 0xe0;
*utf8_out++ = ((ch >> 6) & 0x3f) | 0x80;
*utf8_out++ = (ch & 0x3f) | 0x80;
} else /*(ch > 0x7f || ch == 0)*/ {
// Two byte encoding.
*utf8_out++ = (ch >> 6) | 0xc0;
*utf8_out++ = (ch & 0x3f) | 0x80;
}
}
}
}
// Exhaustive test of converting a single code point to UTF-16, then UTF-8, and back again.
static void codePointToSurrogatePair(uint32_t code_point, uint16_t &first, uint16_t &second) {
first = (code_point >> 10) + 0xd7c0;
second = (code_point & 0x03ff) + 0xdc00;
}
static void testConversions(uint16_t *buf, int char_count) {
char bytes_test[8] = { 0 }, bytes_reference[8] = { 0 };
uint16_t out_buf_test[4] = { 0 }, out_buf_reference[4] = { 0 };
int byte_count_test, byte_count_reference;
int char_count_test, char_count_reference;
// Calculate the number of utf-8 bytes for the utf-16 chars.
byte_count_reference = CountUtf8Bytes_reference(buf, char_count);
byte_count_test = CountUtf8Bytes(buf, char_count);
EXPECT_EQ(byte_count_reference, byte_count_test);
// Convert the utf-16 string to utf-8 bytes.
ConvertUtf16ToModifiedUtf8_reference(bytes_reference, buf, char_count);
ConvertUtf16ToModifiedUtf8(bytes_test, byte_count_test, buf, char_count);
for (int i = 0; i < byte_count_test; ++i) {
EXPECT_EQ(bytes_reference[i], bytes_test[i]);
}
// Calculate the number of utf-16 chars from the utf-8 bytes.
bytes_reference[byte_count_reference] = 0; // Reference function needs null termination.
char_count_reference = CountModifiedUtf8Chars_reference(bytes_reference);
char_count_test = CountModifiedUtf8Chars(bytes_test, byte_count_test);
EXPECT_EQ(char_count, char_count_reference);
EXPECT_EQ(char_count, char_count_test);
// Convert the utf-8 bytes back to utf-16 chars.
// Does not need copied _reference version of the function because the original
// function with the old API is retained for debug/testing code.
ConvertModifiedUtf8ToUtf16(out_buf_reference, bytes_reference);
ConvertModifiedUtf8ToUtf16(out_buf_test, char_count_test, bytes_test, byte_count_test);
for (int i = 0; i < char_count_test; ++i) {
EXPECT_EQ(buf[i], out_buf_reference[i]);
EXPECT_EQ(buf[i], out_buf_test[i]);
}
}
TEST_F(UtfTest, ExhaustiveBidirectionalCodePointCheck) {
for (int codePoint = 0; codePoint <= 0x10ffff; ++codePoint) {
uint16_t buf[4] = { 0 };
if (codePoint <= 0xffff) {
if (codePoint >= 0xd800 && codePoint <= 0xdfff) {
// According to the Unicode standard, no character will ever
// be assigned to these code points, and they cannot be encoded
// into either utf-16 or utf-8.
continue;
}
buf[0] = 'h';
buf[1] = codePoint;
buf[2] = 'e';
testConversions(buf, 2);
testConversions(buf, 3);
testConversions(buf + 1, 1);
testConversions(buf + 1, 2);
} else {
buf[0] = 'h';
codePointToSurrogatePair(codePoint, buf[1], buf[2]);
buf[3] = 'e';
testConversions(buf, 2);
testConversions(buf, 3);
testConversions(buf, 4);
testConversions(buf + 1, 1);
testConversions(buf + 1, 2);
testConversions(buf + 1, 3);
}
}
}
TEST_F(UtfTest, NonAscii) {
const char kNonAsciiCharacter = '\x80';
const char input[] = { kNonAsciiCharacter, '\0' };
uint32_t hash = ComputeModifiedUtf8Hash(input);
EXPECT_EQ(static_cast<uint8_t>(kNonAsciiCharacter), hash);
}
TEST_F(UtfTest, PrintableStringUtf8) {
// Note: This is UTF-8, not Modified-UTF-8.
const uint8_t kTestSequence[] = { 0xf0, 0x90, 0x80, 0x80, 0 };
const char* start = reinterpret_cast<const char*>(kTestSequence);
const char* ptr = start;
uint32_t pair = GetUtf16FromUtf8(&ptr);
ASSERT_EQ(*ptr, '\0');
uint16_t leading = GetLeadingUtf16Char(pair);
uint16_t trailing = GetTrailingUtf16Char(pair);
ASSERT_NE(0u, trailing);
std::string expected = android::base::StringPrintf("\"\\u%04x\\u%04x\"",
static_cast<unsigned>(leading),
static_cast<unsigned>(trailing));
std::string printable = PrintableString(start);
EXPECT_EQ(expected, printable);
}
} // namespace art