| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "ppapi/tests/test_browser_font.h" |
| |
| #include <stdint.h> |
| #include <string.h> |
| |
| #include "ppapi/cpp/image_data.h" |
| #include "ppapi/cpp/trusted/browser_font_trusted.h" |
| #include "ppapi/tests/test_utils.h" |
| #include "ppapi/tests/testing_instance.h" |
| |
| REGISTER_TEST_CASE(BrowserFont); |
| |
| bool TestBrowserFont::Init() { |
| return true; |
| } |
| |
| void TestBrowserFont::RunTests(const std::string& filter) { |
| RUN_TEST(FontFamilies, filter); |
| RUN_TEST(Measure, filter); |
| RUN_TEST(MeasureRTL, filter); |
| RUN_TEST(CharPos, filter); |
| // This test is disabled. It doesn't currently pass. See the |
| // CharacterOffsetForPixel API. |
| //RUN_TEST(CharPosRTL, filter); |
| RUN_TEST(Draw, filter); |
| } |
| |
| // Just tests that GetFontFamilies is hooked up & returns something. |
| std::string TestBrowserFont::TestFontFamilies() { |
| // This function is only supported out-of-process. |
| const PPB_Testing_Private* testing_interface = GetTestingInterface(); |
| if (testing_interface && !testing_interface->IsOutOfProcess()) |
| PASS(); |
| |
| pp::Var families = pp::BrowserFont_Trusted::GetFontFamilies(instance_); |
| |
| ASSERT_TRUE(families.is_string()); |
| ASSERT_TRUE(!families.AsString().empty()); |
| PASS(); |
| } |
| |
| // Tests that measuring text behaves reasonably. We aren't sure if the browser |
| // will be doing kerning or something for the particular default font, so we |
| // just make a string that we're pretty sure should be more than twice as long |
| // as another one, and verify that condition. |
| std::string TestBrowserFont::TestMeasure() { |
| pp::BrowserFontDescription desc; |
| pp::BrowserFont_Trusted font(instance_, desc); |
| |
| int32_t length1 = font.MeasureText(pp::BrowserFontTextRun("WWW")); |
| ASSERT_TRUE(length1 > 0); |
| int32_t length2 = font.MeasureText(pp::BrowserFontTextRun("WWWWWWWW")); |
| ASSERT_TRUE(length2 >= length1 * 2); |
| |
| // Fallback font test. |
| int32_t length3 = font.MeasureText(pp::BrowserFontTextRun("こんにちは")); |
| ASSERT_TRUE(length3 > 0); |
| |
| PASS(); |
| } |
| |
| std::string TestBrowserFont::TestMeasureRTL() { |
| pp::BrowserFontDescription desc; |
| pp::BrowserFont_Trusted font(instance_, desc); |
| |
| // Mixed string, two chars of LTR, two of RTL, then two of LTR. |
| // Note this is in UTF-8 so has more than 6 bytes. |
| std::string mixed("AB\xd7\x94\xd7\x97ZZ"); |
| const int kNumChars = 6; |
| pp::BrowserFontTextRun run(mixed); |
| |
| // Note that since this is UTF-8, the two RTL chars are two bytes each. |
| int32_t len[kNumChars]; |
| len[0] = font.PixelOffsetForCharacter(run, 0); |
| len[1] = font.PixelOffsetForCharacter(run, 1); |
| len[2] = font.PixelOffsetForCharacter(run, 2); |
| len[3] = font.PixelOffsetForCharacter(run, 3); |
| len[4] = font.PixelOffsetForCharacter(run, 4); |
| len[5] = font.PixelOffsetForCharacter(run, 5); |
| |
| // First three chars should be increasing. |
| ASSERT_TRUE(len[0] >= 0); |
| ASSERT_TRUE(len[1] > len[0]); |
| ASSERT_TRUE(len[3] > len[1]); |
| ASSERT_TRUE(len[2] > len[3]); |
| ASSERT_TRUE(len[4] > len[2]); |
| ASSERT_TRUE(len[5] > len[4]); |
| |
| // Test the same sequence with force LTR. The offsets should appear in |
| // sequence. |
| pp::BrowserFontTextRun forced_run(mixed, false, true); |
| len[0] = font.PixelOffsetForCharacter(forced_run, 0); |
| len[1] = font.PixelOffsetForCharacter(forced_run, 1); |
| len[2] = font.PixelOffsetForCharacter(forced_run, 2); |
| len[3] = font.PixelOffsetForCharacter(forced_run, 3); |
| len[4] = font.PixelOffsetForCharacter(forced_run, 4); |
| len[5] = font.PixelOffsetForCharacter(forced_run, 5); |
| for (int i = 1; i < kNumChars; i++) |
| ASSERT_TRUE(len[i] > len[i - 1]); |
| |
| PASS(); |
| } |
| |
| // Tests that the character/pixel offset functions correctly round-trip. |
| std::string TestBrowserFont::TestCharPos() { |
| pp::BrowserFontDescription desc; |
| pp::BrowserFont_Trusted font(instance_, desc); |
| |
| pp::BrowserFontTextRun run("Hello, world"); |
| uint32_t original_char = 3; |
| uint32_t pixel_offset = font.PixelOffsetForCharacter(run, original_char); |
| ASSERT_TRUE(pixel_offset > 0); |
| |
| uint32_t computed_char = font.CharacterOffsetForPixel( |
| run, static_cast<int32_t>(pixel_offset)); |
| ASSERT_TRUE(computed_char == original_char); |
| |
| PASS(); |
| } |
| |
| // Tests that we can get character positions in a mixed LTR/RTL run. |
| std::string TestBrowserFont::TestCharPosRTL() { |
| pp::BrowserFontDescription desc; |
| pp::BrowserFont_Trusted font(instance_, desc); |
| |
| // Mixed string, two chars of LTR, two of RTL, than two of LTR. |
| // Note this is in UTF-8 so has more than 6 bytes. |
| std::string mixed("AB\xd7\x94\xd7\x97ZZ"); |
| |
| pp::BrowserFontTextRun run(mixed); |
| static const int kNumChars = 6; |
| int expected_char_sequence[kNumChars] = { 0, 1, 3, 2, 4, 5 }; |
| |
| // Check that the characters appear in the order we expect. |
| int pixel_width = font.MeasureText(pp::BrowserFontTextRun(mixed)); |
| int last_sequence = 0; // Index into expected_char_sequence. |
| for (int x = 0; x < pixel_width; x++) { |
| int cur_char = font.CharacterOffsetForPixel(run, x); |
| if (cur_char != expected_char_sequence[last_sequence]) { |
| // This pixel has a different character. It should be the next one in |
| // the sequence for it to be correct. |
| last_sequence++; |
| ASSERT_TRUE(last_sequence < kNumChars); |
| ASSERT_TRUE(cur_char == expected_char_sequence[last_sequence]); |
| } |
| } |
| |
| // Try the same string with force LTR. The characters should all appear in |
| // sequence. |
| pp::BrowserFontTextRun forced_run(mixed, false, true); |
| int last_forced_char = 0; // Char index into the forced sequence. |
| for (int x = 0; x < pixel_width; x++) { |
| int cur_char = font.CharacterOffsetForPixel(forced_run, x); |
| if (cur_char != last_forced_char) { |
| last_forced_char++; |
| ASSERT_TRUE(cur_char == last_forced_char); |
| } |
| } |
| |
| PASS(); |
| } |
| |
| // Tests that drawing some text produces "some" output. |
| std::string TestBrowserFont::TestDraw() { |
| pp::BrowserFontDescription desc; |
| desc.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE); |
| desc.set_size(10); |
| pp::BrowserFont_Trusted font(instance_, desc); |
| |
| const pp::Size kSize(30, 10); |
| pp::ImageData image(instance_, |
| PP_IMAGEDATAFORMAT_BGRA_PREMUL, // 0xAARRGGBB |
| kSize, |
| false); // init_to_zero |
| ASSERT_FALSE(image.is_null()); |
| |
| // Draw black text on white canvas. |
| memset(image.data(), 0xFF, 4 * kSize.GetArea()); |
| font.DrawSimpleText(&image, |
| "Hello", |
| pp::Point(0, 10), // Baseline position. |
| 0xFF000000, // Black text. |
| true); // image_data_is_opaque. |
| |
| // Expect that at least a few pixels are non-white (text). |
| // Due to blending, there may be rounding errors and |
| // checking for exact black may not be correct. |
| // Also expect that all pixels are opaque. |
| const uint32_t kRGBMask = 0x00FFFFFF; |
| const uint32_t kAlphaMask = 0xFF000000; |
| int text_pixels = 0, opaque_pixels = 0; |
| const uint32_t* pixels = static_cast<const uint32_t*>(image.data()); |
| for (int i = 0; i < kSize.GetArea(); ++i) { |
| if ((pixels[i] & kRGBMask) != kRGBMask) |
| ++text_pixels; |
| if ((pixels[i] & kAlphaMask) == kAlphaMask) |
| ++opaque_pixels; |
| } |
| ASSERT_GT(text_pixels, 0); |
| ASSERT_EQ(opaque_pixels, kSize.GetArea()); |
| PASS(); |
| } |