diff options
Diffstat (limited to 'WebKit/chromium/tests')
| -rw-r--r-- | WebKit/chromium/tests/KURLTest.cpp | 611 | ||||
| -rw-r--r-- | WebKit/chromium/tests/KeyboardTest.cpp | 213 | ||||
| -rw-r--r-- | WebKit/chromium/tests/RunAllTests.cpp | 50 | ||||
| -rw-r--r-- | WebKit/chromium/tests/TransparencyWinTest.cpp | 693 | ||||
| -rw-r--r-- | WebKit/chromium/tests/UniscribeHelperTest.cpp | 165 |
5 files changed, 1732 insertions, 0 deletions
diff --git a/WebKit/chromium/tests/KURLTest.cpp b/WebKit/chromium/tests/KURLTest.cpp new file mode 100644 index 0000000..b316683 --- /dev/null +++ b/WebKit/chromium/tests/KURLTest.cpp @@ -0,0 +1,611 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// Basic tests that verify our KURL's interface behaves the same as the +// original KURL's. + +#include "config.h" + +#include <gtest/gtest.h> + +#include "KURL.h" + +namespace { + +// Output stream operator so gTest's macros work with WebCore strings. +std::ostream& operator<<(std::ostream& out, const WebCore::String& str) +{ + return str.isEmpty() ? out : out << str.utf8().data(); +} + +struct ComponentCase { + const char* url; + const char* protocol; + const char* host; + const int port; + const char* user; + const char* pass; + const char* path; + const char* lastPath; + const char* query; + const char* ref; +}; + +// Test the cases where we should be the same as WebKit's old KURL. +TEST(KURLTest, SameGetters) +{ + struct GetterCase { + const char* url; + const char* protocol; + const char* host; + int port; + const char* user; + const char* pass; + const char* lastPathComponent; + const char* query; + const char* ref; + bool hasRef; + } cases[] = { + {"http://www.google.com/foo/blah?bar=baz#ref", "http", "www.google.com", 0, "", 0, "blah", "bar=baz", "ref", true}, + {"http://foo.com:1234/foo/bar/", "http", "foo.com", 1234, "", 0, "bar", 0, 0, false}, + {"http://www.google.com?#", "http", "www.google.com", 0, "", 0, 0, "", "", true}, + {"https://me:pass@google.com:23#foo", "https", "google.com", 23, "me", "pass", 0, 0, "foo", true}, + {"javascript:hello!//world", "javascript", "", 0, "", 0, "world", 0, 0, false}, + }; + + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) { + // UTF-8 + WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url); + + EXPECT_EQ(cases[i].protocol, kurl.protocol()); + EXPECT_EQ(cases[i].host, kurl.host()); + EXPECT_EQ(cases[i].port, kurl.port()); + EXPECT_EQ(cases[i].user, kurl.user()); + EXPECT_EQ(cases[i].pass, kurl.pass()); + EXPECT_EQ(cases[i].lastPathComponent, kurl.lastPathComponent()); + EXPECT_EQ(cases[i].query, kurl.query()); + EXPECT_EQ(cases[i].ref, kurl.fragmentIdentifier()); + EXPECT_EQ(cases[i].hasRef, kurl.hasFragmentIdentifier()); + + // UTF-16 + WebCore::String utf16(cases[i].url); + kurl = WebCore::KURL(WebCore::ParsedURLString, utf16); + + EXPECT_EQ(cases[i].protocol, kurl.protocol()); + EXPECT_EQ(cases[i].host, kurl.host()); + EXPECT_EQ(cases[i].port, kurl.port()); + EXPECT_EQ(cases[i].user, kurl.user()); + EXPECT_EQ(cases[i].pass, kurl.pass()); + EXPECT_EQ(cases[i].lastPathComponent, kurl.lastPathComponent()); + EXPECT_EQ(cases[i].query, kurl.query()); + EXPECT_EQ(cases[i].ref, kurl.fragmentIdentifier()); + EXPECT_EQ(cases[i].hasRef, kurl.hasFragmentIdentifier()); + } +} + +// Test a few cases where we're different just to make sure we give reasonable +// output. +TEST(KURLTest, DifferentGetters) +{ + ComponentCase cases[] = { + // url protocol host port user pass path lastPath query ref + + // Old WebKit allows references and queries in what we call "path" URLs + // like javascript, so the path here will only consist of "hello!". + {"javascript:hello!?#/\\world", "javascript", "", 0, "", 0, "hello!?#/\\world", "world", 0, 0}, + + // Old WebKit doesn't handle "parameters" in paths, so will + // disagree with us about where the path is for this URL. + {"http://a.com/hello;world", "http", "a.com", 0, "", 0, "/hello;world", "hello", 0, 0}, + + // WebKit doesn't like UTF-8 or UTF-16 input. + {"http://\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xbd\xa0\xe5\xa5\xbd/", "http", "xn--6qqa088eba", 0, "", 0, "/", 0, 0, 0}, + + // WebKit %-escapes non-ASCII characters in reference, but we don't. + {"http://www.google.com/foo/blah?bar=baz#\xce\xb1\xce\xb2", "http", "www.google.com", 0, "", 0, "/foo/blah/", "blah", "bar=baz", "\xce\xb1\xce\xb2"}, + }; + + for (size_t i = 0; i < arraysize(cases); i++) { + WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url); + + EXPECT_EQ(cases[i].protocol, kurl.protocol()); + EXPECT_EQ(cases[i].host, kurl.host()); + EXPECT_EQ(cases[i].port, kurl.port()); + EXPECT_EQ(cases[i].user, kurl.user()); + EXPECT_EQ(cases[i].pass, kurl.pass()); + EXPECT_EQ(cases[i].lastPath, kurl.lastPathComponent()); + EXPECT_EQ(cases[i].query, kurl.query()); + // Want to compare UCS-16 refs (or to null). + if (cases[i].ref) + EXPECT_EQ(WebCore::String::fromUTF8(cases[i].ref), kurl.fragmentIdentifier()); + else + EXPECT_TRUE(kurl.fragmentIdentifier().isNull()); + } +} + +// Ensures that both ASCII and UTF-8 canonical URLs are handled properly and we +// get the correct string object out. +TEST(KURLTest, UTF8) +{ + const char asciiURL[] = "http://foo/bar#baz"; + WebCore::KURL asciiKURL(WebCore::ParsedURLString, asciiURL); + EXPECT_TRUE(asciiKURL.string() == WebCore::String(asciiURL)); + + // When the result is ASCII, we should get an ASCII String. Some + // code depends on being able to compare the result of the .string() + // getter with another String, and the isASCIIness of the two + // strings must match for these functions (like equalIgnoringCase). + EXPECT_TRUE(WebCore::equalIgnoringCase(asciiKURL, WebCore::String(asciiURL))); + + // Reproduce code path in FrameLoader.cpp -- equalIgnoringCase implicitly + // expects gkurl.protocol() to have been created as ascii. + WebCore::KURL mailto(WebCore::ParsedURLString, "mailto:foo@foo.com"); + EXPECT_TRUE(WebCore::equalIgnoringCase(mailto.protocol(), "mailto")); + + const char utf8URL[] = "http://foo/bar#\xe4\xbd\xa0\xe5\xa5\xbd"; + WebCore::KURL utf8KURL(WebCore::ParsedURLString, utf8URL); + + EXPECT_TRUE(utf8KURL.string() == WebCore::String::fromUTF8(utf8URL)); +} + +TEST(KURLTest, Setters) +{ + // Replace the starting URL with the given components one at a time and + // verify that we're always the same as the old KURL. + // + // Note that old KURL won't canonicalize the default port away, so we + // can't set setting the http port to "80" (or even "0"). + // + // We also can't test clearing the query. + // + // The format is every other row is a test, and the row that follows it is the + // expected result. + struct ExpectedComponentCase { + const char* url; + const char* protocol; + const char* host; + const int port; + const char* user; + const char* pass; + const char* path; + const char* query; + const char* ref; + + // The full expected URL with the given "set" applied. + const char* expectedProtocol; + const char* expectedHost; + const char* expectedPort; + const char* expectedUser; + const char* expectedPass; + const char* expectedPath; + const char* expectedQuery; + const char* expectedRef; + } cases[] = { + // url protocol host port user pass path query ref + {"http://www.google.com/", "https", "news.google.com", 8888, "me", "pass", "/foo", "?q=asdf", "heehee", + "https://www.google.com/", + "https://news.google.com/", + "https://news.google.com:8888/", + "https://me@news.google.com:8888/", + "https://me:pass@news.google.com:8888/", + "https://me:pass@news.google.com:8888/foo", + "https://me:pass@news.google.com:8888/foo?q=asdf", + "https://me:pass@news.google.com:8888/foo?q=asdf#heehee"}, + + {"https://me:pass@google.com:88/a?f#b", "http", "goo.com", 92, "", "", "/", 0, "", + "http://me:pass@google.com:88/a?f#b", + "http://me:pass@goo.com:88/a?f#b", + "http://me:pass@goo.com:92/a?f#b", + "http://:pass@goo.com:92/a?f#b", + "http://goo.com:92/a?f#b", + "http://goo.com:92/?f#b", + "http://goo.com:92/#b", + "https://goo.com:92/"}, + }; + + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) { + WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url); + + kurl.setProtocol(cases[i].protocol); + EXPECT_STREQ(cases[i].expectedProtocol, kurl.string().utf8().data()); + + kurl.setHost(cases[i].host); + EXPECT_STREQ(cases[i].expectedHost, kurl.string().utf8().data()); + + kurl.setPort(cases[i].port); + EXPECT_STREQ(cases[i].expectedPort, kurl.string().utf8().data()); + + kurl.setUser(cases[i].user); + EXPECT_STREQ(cases[i].expectedUser, kurl.string().utf8().data()); + + kurl.setPass(cases[i].pass); + EXPECT_STREQ(cases[i].expectedPass, kurl.string().utf8().data()); + + kurl.setPath(cases[i].path); + EXPECT_STREQ(cases[i].expectedPath, kurl.string().utf8().data()); + + kurl.setQuery(cases[i].query); + EXPECT_STREQ(cases[i].expectedQuery, kurl.string().utf8().data()); + + // Refs are tested below. On the Safari 3.1 branch, we don't match their + // KURL since we integrated a fix from their trunk. + } +} + +// Tests that KURL::decodeURLEscapeSequences works as expected +#if USE(GOOGLEURL) +TEST(KURLTest, Decode) +{ + struct DecodeCase { + const char* input; + const char* output; + } decodeCases[] = { + {"hello, world", "hello, world"}, + {"%01%02%03%04%05%06%07%08%09%0a%0B%0C%0D%0e%0f/", "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0B\x0C\x0D\x0e\x0f/"}, + {"%10%11%12%13%14%15%16%17%18%19%1a%1B%1C%1D%1e%1f/", "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1B\x1C\x1D\x1e\x1f/"}, + {"%20%21%22%23%24%25%26%27%28%29%2a%2B%2C%2D%2e%2f/", " !\"#$%&'()*+,-.//"}, + {"%30%31%32%33%34%35%36%37%38%39%3a%3B%3C%3D%3e%3f/", "0123456789:;<=>?/"}, + {"%40%41%42%43%44%45%46%47%48%49%4a%4B%4C%4D%4e%4f/", "@ABCDEFGHIJKLMNO/"}, + {"%50%51%52%53%54%55%56%57%58%59%5a%5B%5C%5D%5e%5f/", "PQRSTUVWXYZ[\\]^_/"}, + {"%60%61%62%63%64%65%66%67%68%69%6a%6B%6C%6D%6e%6f/", "`abcdefghijklmno/"}, + {"%70%71%72%73%74%75%76%77%78%79%7a%7B%7C%7D%7e%7f/", "pqrstuvwxyz{|}~\x7f/"}, + // Test un-UTF-8-ization. + {"%e4%bd%a0%e5%a5%bd", "\xe4\xbd\xa0\xe5\xa5\xbd"}, + }; + + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(decodeCases); i++) { + WebCore::String input(decodeCases[i].input); + WebCore::String str = WebCore::decodeURLEscapeSequences(input); + EXPECT_STREQ(decodeCases[i].output, str.utf8().data()); + } + + // Our decode should decode %00 + WebCore::String zero = WebCore::decodeURLEscapeSequences("%00"); + EXPECT_STRNE("%00", zero.utf8().data()); + + // Test the error behavior for invalid UTF-8 (we differ from WebKit here). + WebCore::String invalid = WebCore::decodeURLEscapeSequences( + "%e4%a0%e5%a5%bd"); + char16 invalidExpectedHelper[4] = { 0x00e4, 0x00a0, 0x597d, 0 }; + WebCore::String invalidExpected( + reinterpret_cast<const ::UChar*>(invalidExpectedHelper), + 3); + EXPECT_EQ(invalidExpected, invalid); +} +#endif + +TEST(KURLTest, Encode) +{ + // Also test that it gets converted to UTF-8 properly. + char16 wideInputHelper[3] = { 0x4f60, 0x597d, 0 }; + WebCore::String wideInput( + reinterpret_cast<const ::UChar*>(wideInputHelper), 2); + WebCore::String wideReference("\xe4\xbd\xa0\xe5\xa5\xbd", 6); + WebCore::String wideOutput = + WebCore::encodeWithURLEscapeSequences(wideInput); + EXPECT_EQ(wideReference, wideOutput); + + // Our encode only escapes NULLs for safety (see the implementation for + // more), so we only bother to test a few cases. + WebCore::String input( + "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 16); + WebCore::String reference( + "%00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 18); + WebCore::String output = WebCore::encodeWithURLEscapeSequences(input); + EXPECT_EQ(reference, output); +} + +TEST(KURLTest, ResolveEmpty) +{ + WebCore::KURL emptyBase; + + // WebKit likes to be able to resolve absolute input agains empty base URLs, + // which would normally be invalid since the base URL is invalid. + const char abs[] = "http://www.google.com/"; + WebCore::KURL resolveAbs(emptyBase, abs); + EXPECT_TRUE(resolveAbs.isValid()); + EXPECT_STREQ(abs, resolveAbs.string().utf8().data()); + + // Resolving a non-relative URL agains the empty one should still error. + const char rel[] = "foo.html"; + WebCore::KURL resolveErr(emptyBase, rel); + EXPECT_FALSE(resolveErr.isValid()); +} + +// WebKit will make empty URLs and set components on them. kurl doesn't allow +// replacements on invalid URLs, but here we do. +TEST(KURLTest, ReplaceInvalid) +{ + WebCore::KURL kurl; + + EXPECT_FALSE(kurl.isValid()); + EXPECT_TRUE(kurl.isEmpty()); + EXPECT_STREQ("", kurl.string().utf8().data()); + + kurl.setProtocol("http"); + // GKURL will say that a URL with just a scheme is invalid, KURL will not. +#if USE(GOOGLEURL) + EXPECT_FALSE(kurl.isValid()); +#else + EXPECT_TRUE(kurl.isValid()); +#endif + EXPECT_FALSE(kurl.isEmpty()); + // At this point, we do things slightly differently if there is only a scheme. + // We check the results here to make it more obvious what is going on, but it + // shouldn't be a big deal if these change. +#if USE(GOOGLEURL) + EXPECT_STREQ("http:", kurl.string().utf8().data()); +#else + EXPECT_STREQ("http:/", kurl.string().utf8().data()); +#endif + + kurl.setHost("www.google.com"); + EXPECT_TRUE(kurl.isValid()); + EXPECT_FALSE(kurl.isEmpty()); + EXPECT_STREQ("http://www.google.com/", kurl.string().utf8().data()); + + kurl.setPort(8000); + EXPECT_TRUE(kurl.isValid()); + EXPECT_FALSE(kurl.isEmpty()); + EXPECT_STREQ("http://www.google.com:8000/", kurl.string().utf8().data()); + + kurl.setPath("/favicon.ico"); + EXPECT_TRUE(kurl.isValid()); + EXPECT_FALSE(kurl.isEmpty()); + EXPECT_STREQ("http://www.google.com:8000/favicon.ico", kurl.string().utf8().data()); + + // Now let's test that giving an invalid replacement still fails. +#if USE(GOOGLEURL) + kurl.setProtocol("f/sj#@"); + EXPECT_FALSE(kurl.isValid()); +#endif +} + +TEST(KURLTest, Path) +{ + const char initial[] = "http://www.google.com/path/foo"; + WebCore::KURL kurl(WebCore::ParsedURLString, initial); + + // Clear by setting a null string. + WebCore::String nullString; + EXPECT_TRUE(nullString.isNull()); + kurl.setPath(nullString); + EXPECT_STREQ("http://www.google.com/", kurl.string().utf8().data()); +} + +// Test that setting the query to different things works. Thq query is handled +// a littler differently than some of the other components. +TEST(KURLTest, Query) +{ + const char initial[] = "http://www.google.com/search?q=awesome"; + WebCore::KURL kurl(WebCore::ParsedURLString, initial); + + // Clear by setting a null string. + WebCore::String nullString; + EXPECT_TRUE(nullString.isNull()); + kurl.setQuery(nullString); + EXPECT_STREQ("http://www.google.com/search", kurl.string().utf8().data()); + + // Clear by setting an empty string. + kurl = WebCore::KURL(WebCore::ParsedURLString, initial); + WebCore::String emptyString(""); + EXPECT_FALSE(emptyString.isNull()); + kurl.setQuery(emptyString); + EXPECT_STREQ("http://www.google.com/search?", kurl.string().utf8().data()); + + // Set with something that begins in a question mark. + const char question[] = "?foo=bar"; + kurl.setQuery(question); + EXPECT_STREQ("http://www.google.com/search?foo=bar", + kurl.string().utf8().data()); + + // Set with something that doesn't begin in a question mark. + const char query[] = "foo=bar"; + kurl.setQuery(query); + EXPECT_STREQ("http://www.google.com/search?foo=bar", + kurl.string().utf8().data()); +} + +TEST(KURLTest, Ref) +{ + WebCore::KURL kurl(WebCore::ParsedURLString, "http://foo/bar#baz"); + + // Basic ref setting. + WebCore::KURL cur(WebCore::ParsedURLString, "http://foo/bar"); + cur.setFragmentIdentifier("asdf"); + EXPECT_STREQ("http://foo/bar#asdf", cur.string().utf8().data()); + cur = kurl; + cur.setFragmentIdentifier("asdf"); + EXPECT_STREQ("http://foo/bar#asdf", cur.string().utf8().data()); + + // Setting a ref to the empty string will set it to "#". + cur = WebCore::KURL(WebCore::ParsedURLString, "http://foo/bar"); + cur.setFragmentIdentifier(""); + EXPECT_STREQ("http://foo/bar#", cur.string().utf8().data()); + cur = kurl; + cur.setFragmentIdentifier(""); + EXPECT_STREQ("http://foo/bar#", cur.string().utf8().data()); + + // Setting the ref to the null string will clear it altogether. + cur = WebCore::KURL(WebCore::ParsedURLString, "http://foo/bar"); + cur.setFragmentIdentifier(WebCore::String()); + EXPECT_STREQ("http://foo/bar", cur.string().utf8().data()); + cur = kurl; + cur.setFragmentIdentifier(WebCore::String()); + EXPECT_STREQ("http://foo/bar", cur.string().utf8().data()); +} + +TEST(KURLTest, Empty) +{ + WebCore::KURL kurl; + + // First test that regular empty URLs are the same. + EXPECT_TRUE(kurl.isEmpty()); + EXPECT_FALSE(kurl.isValid()); + EXPECT_TRUE(kurl.isNull()); + EXPECT_TRUE(kurl.string().isNull()); + EXPECT_TRUE(kurl.string().isEmpty()); + + // Test resolving a null URL on an empty string. + WebCore::KURL kurl2(kurl, ""); + EXPECT_FALSE(kurl2.isNull()); + EXPECT_TRUE(kurl2.isEmpty()); + EXPECT_FALSE(kurl2.isValid()); + EXPECT_FALSE(kurl2.string().isNull()); + EXPECT_TRUE(kurl2.string().isEmpty()); + EXPECT_FALSE(kurl2.string().isNull()); + EXPECT_TRUE(kurl2.string().isEmpty()); + + // Resolve the null URL on a null string. + WebCore::KURL kurl22(kurl, WebCore::String()); + EXPECT_FALSE(kurl22.isNull()); + EXPECT_TRUE(kurl22.isEmpty()); + EXPECT_FALSE(kurl22.isValid()); + EXPECT_FALSE(kurl22.string().isNull()); + EXPECT_TRUE(kurl22.string().isEmpty()); + EXPECT_FALSE(kurl22.string().isNull()); + EXPECT_TRUE(kurl22.string().isEmpty()); + + // Test non-hierarchical schemes resolving. The actual URLs will be different. + // WebKit's one will set the string to "something.gif" and we'll set it to an + // empty string. I think either is OK, so we just check our behavior. +#if USE(GOOGLEURL) + WebCore::KURL kurl3(WebCore::KURL(WebCore::ParsedURLString, "data:foo"), + "something.gif"); + EXPECT_TRUE(kurl3.isEmpty()); + EXPECT_FALSE(kurl3.isValid()); +#endif + + // Test for weird isNull string input, + // see: http://bugs.webkit.org/show_bug.cgi?id=16487 + WebCore::KURL kurl4(WebCore::ParsedURLString, kurl.string()); + EXPECT_TRUE(kurl4.isEmpty()); + EXPECT_FALSE(kurl4.isValid()); + EXPECT_TRUE(kurl4.string().isNull()); + EXPECT_TRUE(kurl4.string().isEmpty()); + + // Resolving an empty URL on an invalid string. + WebCore::KURL kurl5(WebCore::KURL(), "foo.js"); + // We'll be empty in this case, but KURL won't be. Should be OK. + // EXPECT_EQ(kurl5.isEmpty(), kurl5.isEmpty()); + // EXPECT_EQ(kurl5.string().isEmpty(), kurl5.string().isEmpty()); + EXPECT_FALSE(kurl5.isValid()); + EXPECT_FALSE(kurl5.string().isNull()); + + // Empty string as input + WebCore::KURL kurl6(WebCore::ParsedURLString, ""); + EXPECT_TRUE(kurl6.isEmpty()); + EXPECT_FALSE(kurl6.isValid()); + EXPECT_FALSE(kurl6.string().isNull()); + EXPECT_TRUE(kurl6.string().isEmpty()); + + // Non-empty but invalid C string as input. + WebCore::KURL kurl7(WebCore::ParsedURLString, "foo.js"); + // WebKit will actually say this URL has the string "foo.js" but is invalid. + // We don't do that. + // EXPECT_EQ(kurl7.isEmpty(), kurl7.isEmpty()); + EXPECT_FALSE(kurl7.isValid()); + EXPECT_FALSE(kurl7.string().isNull()); +} + +TEST(KURLTest, UserPass) +{ + const char* src = "http://user:pass@google.com/"; + WebCore::KURL kurl(WebCore::ParsedURLString, src); + + // Clear just the username. + kurl.setUser(""); + EXPECT_EQ("http://:pass@google.com/", kurl.string()); + + // Clear just the password. + kurl = WebCore::KURL(WebCore::ParsedURLString, src); + kurl.setPass(""); + EXPECT_EQ("http://user@google.com/", kurl.string()); + + // Now clear both. + kurl.setUser(""); + EXPECT_EQ("http://google.com/", kurl.string()); +} + +TEST(KURLTest, Offsets) +{ + const char* src1 = "http://user:pass@google.com/foo/bar.html?baz=query#ref"; + WebCore::KURL kurl1(WebCore::ParsedURLString, src1); + + EXPECT_EQ(17u, kurl1.hostStart()); + EXPECT_EQ(27u, kurl1.hostEnd()); + EXPECT_EQ(27u, kurl1.pathStart()); + EXPECT_EQ(40u, kurl1.pathEnd()); + EXPECT_EQ(32u, kurl1.pathAfterLastSlash()); + + const char* src2 = "http://google.com/foo/"; + WebCore::KURL kurl2(WebCore::ParsedURLString, src2); + + EXPECT_EQ(7u, kurl2.hostStart()); + EXPECT_EQ(17u, kurl2.hostEnd()); + EXPECT_EQ(17u, kurl2.pathStart()); + EXPECT_EQ(22u, kurl2.pathEnd()); + EXPECT_EQ(22u, kurl2.pathAfterLastSlash()); + + const char* src3 = "javascript:foobar"; + WebCore::KURL kurl3(WebCore::ParsedURLString, src3); + + EXPECT_EQ(11u, kurl3.hostStart()); + EXPECT_EQ(11u, kurl3.hostEnd()); + EXPECT_EQ(11u, kurl3.pathStart()); + EXPECT_EQ(17u, kurl3.pathEnd()); + EXPECT_EQ(11u, kurl3.pathAfterLastSlash()); +} + +TEST(KURLTest, DeepCopy) +{ + const char url[] = "http://www.google.com/"; + WebCore::KURL src(WebCore::ParsedURLString, url); + EXPECT_TRUE(src.string() == url); // This really just initializes the cache. + WebCore::KURL dest = src.copy(); + EXPECT_TRUE(dest.string() == url); // This really just initializes the cache. + + // The pointers should be different for both UTF-8 and UTF-16. + EXPECT_NE(dest.string().characters(), src.string().characters()); + EXPECT_NE(dest.utf8String().data(), src.utf8String().data()); +} + +TEST(KURLTest, ProtocolIs) +{ + WebCore::KURL url1(WebCore::ParsedURLString, "foo://bar"); + EXPECT_TRUE(url1.protocolIs("foo")); + EXPECT_FALSE(url1.protocolIs("foo-bar")); + + WebCore::KURL url2(WebCore::ParsedURLString, "foo-bar:"); + EXPECT_TRUE(url2.protocolIs("foo-bar")); + EXPECT_FALSE(url2.protocolIs("foo")); +} + +} // namespace diff --git a/WebKit/chromium/tests/KeyboardTest.cpp b/WebKit/chromium/tests/KeyboardTest.cpp new file mode 100644 index 0000000..07bed3c --- /dev/null +++ b/WebKit/chromium/tests/KeyboardTest.cpp @@ -0,0 +1,213 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <gtest/gtest.h> + +#include "EditorClientImpl.h" +#include "EventTarget.h" +#include "KeyboardCodes.h" +#include "KeyboardEvent.h" +#include "WebInputEvent.h" +#include "WebInputEventConversion.h" + +using namespace WebCore; +using namespace WebKit; + +namespace { + +class KeyboardTest : public testing::Test { +public: + + // Pass a WebKeyboardEvent into the EditorClient and get back the string + // name of which editing event that key causes. + // E.g., sending in the enter key gives back "InsertNewline". + const char* interpretKeyEvent( + const WebKeyboardEvent& webKeyboardEvent, + PlatformKeyboardEvent::Type keyType) + { + EditorClientImpl editorImpl(0); + PlatformKeyboardEventBuilder evt(webKeyboardEvent); + evt.setKeyType(keyType); + RefPtr<KeyboardEvent> keyboardEvent = KeyboardEvent::create(evt, 0); + return editorImpl.interpretKeyEvent(keyboardEvent.get()); + } + + // Set up a WebKeyboardEvent KEY_DOWN event with key code and modifiers. + void setupKeyDownEvent(WebKeyboardEvent* keyboardEvent, + char keyCode, + int modifiers) + { + keyboardEvent->windowsKeyCode = keyCode; + keyboardEvent->modifiers = modifiers; + keyboardEvent->type = WebInputEvent::KeyDown; + keyboardEvent->text[0] = keyCode; + keyboardEvent->setKeyIdentifierFromWindowsKeyCode(); + } + + // Like interpretKeyEvent, but with pressing down OSModifier+|keyCode|. + // OSModifier is the platform's standard modifier key: control on most + // platforms, but meta (command) on Mac. + const char* interpretOSModifierKeyPress(char keyCode) + { + WebKeyboardEvent keyboardEvent; +#if OS(DARWIN) + WebInputEvent::Modifiers osModifier = WebInputEvent::MetaKey; +#else + WebInputEvent::Modifiers osModifier = WebInputEvent::ControlKey; +#endif + setupKeyDownEvent(&keyboardEvent, keyCode, osModifier); + return interpretKeyEvent(keyboardEvent, PlatformKeyboardEvent::RawKeyDown); + } + + // Like interpretKeyEvent, but with pressing down ctrl+|keyCode|. + const char* interpretCtrlKeyPress(char keyCode) + { + WebKeyboardEvent keyboardEvent; + setupKeyDownEvent(&keyboardEvent, keyCode, WebInputEvent::ControlKey); + return interpretKeyEvent(keyboardEvent, PlatformKeyboardEvent::RawKeyDown); + } + + // Like interpretKeyEvent, but with typing a tab. + const char* interpretTab(int modifiers) + { + WebKeyboardEvent keyboardEvent; + setupKeyDownEvent(&keyboardEvent, '\t', modifiers); + return interpretKeyEvent(keyboardEvent, PlatformKeyboardEvent::Char); + } + + // Like interpretKeyEvent, but with typing a newline. + const char* interpretNewLine(int modifiers) + { + WebKeyboardEvent keyboardEvent; + setupKeyDownEvent(&keyboardEvent, '\r', modifiers); + return interpretKeyEvent(keyboardEvent, PlatformKeyboardEvent::Char); + } + + // A name for "no modifiers set". + static const int noModifiers = 0; +}; + +TEST_F(KeyboardTest, TestCtrlReturn) +{ + EXPECT_STREQ("InsertNewline", interpretCtrlKeyPress(0xD)); +} + +TEST_F(KeyboardTest, TestOSModifierZ) +{ +#if !OS(DARWIN) + EXPECT_STREQ("Undo", interpretOSModifierKeyPress('Z')); +#endif +} + +TEST_F(KeyboardTest, TestOSModifierY) +{ +#if !OS(DARWIN) + EXPECT_STREQ("Redo", interpretOSModifierKeyPress('Y')); +#endif +} + +TEST_F(KeyboardTest, TestOSModifierA) +{ +#if !OS(DARWIN) + EXPECT_STREQ("SelectAll", interpretOSModifierKeyPress('A')); +#endif +} + +TEST_F(KeyboardTest, TestOSModifierX) +{ +#if !OS(DARWIN) + EXPECT_STREQ("Cut", interpretOSModifierKeyPress('X')); +#endif +} + +TEST_F(KeyboardTest, TestOSModifierC) +{ +#if !OS(DARWIN) + EXPECT_STREQ("Copy", interpretOSModifierKeyPress('C')); +#endif +} + +TEST_F(KeyboardTest, TestOSModifierV) +{ +#if !OS(DARWIN) + EXPECT_STREQ("Paste", interpretOSModifierKeyPress('V')); +#endif +} + +TEST_F(KeyboardTest, TestEscape) +{ + WebKeyboardEvent keyboardEvent; + setupKeyDownEvent(&keyboardEvent, WebCore::VKEY_ESCAPE, noModifiers); + + const char* result = interpretKeyEvent(keyboardEvent, + PlatformKeyboardEvent::RawKeyDown); + EXPECT_STREQ("Cancel", result); +} + +TEST_F(KeyboardTest, TestInsertTab) +{ + EXPECT_STREQ("InsertTab", interpretTab(noModifiers)); +} + +TEST_F(KeyboardTest, TestInsertBackTab) +{ + EXPECT_STREQ("InsertBacktab", interpretTab(WebInputEvent::ShiftKey)); +} + +TEST_F(KeyboardTest, TestInsertNewline) +{ + EXPECT_STREQ("InsertNewline", interpretNewLine(noModifiers)); +} + +TEST_F(KeyboardTest, TestInsertNewline2) +{ + EXPECT_STREQ("InsertNewline", interpretNewLine(WebInputEvent::ControlKey)); +} + +TEST_F(KeyboardTest, TestInsertLineBreak) +{ + EXPECT_STREQ("InsertLineBreak", interpretNewLine(WebInputEvent::ShiftKey)); +} + +TEST_F(KeyboardTest, TestInsertNewline3) +{ + EXPECT_STREQ("InsertNewline", interpretNewLine(WebInputEvent::AltKey)); +} + +TEST_F(KeyboardTest, TestInsertNewline4) +{ + int modifiers = WebInputEvent::AltKey | WebInputEvent::ShiftKey; + const char* result = interpretNewLine(modifiers); + EXPECT_STREQ("InsertNewline", result); +} + +} // empty namespace diff --git a/WebKit/chromium/tests/RunAllTests.cpp b/WebKit/chromium/tests/RunAllTests.cpp new file mode 100644 index 0000000..0f3f82f --- /dev/null +++ b/WebKit/chromium/tests/RunAllTests.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// FIXME: Avoid this source dependency on Chromium's base module. +#include <base/test/test_suite.h> + +#include "WebKit.h" +#include "WebKitClient.h" + +// WebKitClient has a protected destructor, so we need to subclass. +class DummyWebKitClient : public WebKit::WebKitClient { +}; + +int main(int argc, char** argv) +{ + DummyWebKitClient dummyClient; + WebKit::initialize(&dummyClient); + + int result = TestSuite(argc, argv).Run(); + + WebKit::shutdown(); + return result; +} diff --git a/WebKit/chromium/tests/TransparencyWinTest.cpp b/WebKit/chromium/tests/TransparencyWinTest.cpp new file mode 100644 index 0000000..b83c2a9 --- /dev/null +++ b/WebKit/chromium/tests/TransparencyWinTest.cpp @@ -0,0 +1,693 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "TransparencyWin.h" + +#include "AffineTransform.h" +#include "ImageBuffer.h" + +#include <gtest/gtest.h> +#include <windows.h> + +namespace WebCore { + +static FloatRect RECTToFloatRect(const RECT* rect) +{ + return FloatRect(static_cast<float>(rect->left), + static_cast<float>(rect->top), + static_cast<float>(rect->right - rect->left), + static_cast<float>(rect->bottom - rect->top)); +} + +static void drawNativeRect(GraphicsContext* context, + int x, int y, int w, int h) +{ + skia::PlatformCanvas* canvas = context->platformContext()->canvas(); + HDC dc = canvas->beginPlatformPaint(); + + RECT innerRc; + innerRc.left = x; + innerRc.top = y; + innerRc.right = x + w; + innerRc.bottom = y + h; + FillRect(dc, &innerRc, + reinterpret_cast<HBRUSH>(GetStockObject(BLACK_BRUSH))); + + canvas->endPlatformPaint(); +} + +static Color getPixelAt(GraphicsContext* context, int x, int y) +{ + const SkBitmap& bitmap = context->platformContext()->canvas()-> + getTopPlatformDevice().accessBitmap(false); + return Color(*reinterpret_cast<const RGBA32*>(bitmap.getAddr32(x, y))); +} + +// Resets the top layer's alpha channel to 0 for each pixel. This simulates +// Windows messing it up. +static void clearTopLayerAlphaChannel(GraphicsContext* context) +{ + SkBitmap& bitmap = const_cast<SkBitmap&>(context->platformContext()-> + canvas()->getTopPlatformDevice().accessBitmap(false)); + for (int y = 0; y < bitmap.height(); y++) { + uint32_t* row = bitmap.getAddr32(0, y); + for (int x = 0; x < bitmap.width(); x++) + row[x] &= 0x00FFFFFF; + } +} + +// Clears the alpha channel on the specified pixel. +static void clearTopLayerAlphaPixel(GraphicsContext* context, int x, int y) +{ + SkBitmap& bitmap = const_cast<SkBitmap&>(context->platformContext()-> + canvas()->getTopPlatformDevice().accessBitmap(false)); + *bitmap.getAddr32(x, y) &= 0x00FFFFFF; +} + +static std::ostream& operator<<(std::ostream& out, const Color& c) +{ + std::ios_base::fmtflags oldFlags = out.flags(std::ios_base::hex | + std::ios_base::showbase); + out << c.rgb(); + out.flags(oldFlags); + return out; +} + +TEST(TransparencyWin, NoLayer) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(17, 16), DeviceRGB)); + + // KeepTransform + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::NoLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 12)); + + EXPECT_TRUE(src->context() == helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); + } + + // Untransform is not allowed for NoLayer. + + // ScaleTransform + src->context()->save(); + src->context()->scale(FloatSize(2.0, 0.5)); + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::NoLayer, + TransparencyWin::ScaleTransform, + IntRect(2, 2, 6, 6)); + helper.composite(); + + // The coordinate system should be based in the upper left of our box. + // It should be post-transformed. + EXPECT_TRUE(src->context() == helper.context()); + EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize); + EXPECT_TRUE(IntRect(4, 1, 12, 3) == helper.drawRect()); + } + src->context()->restore(); +} + +TEST(TransparencyWin, WhiteLayer) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // KeepTransform + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::WhiteLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 12)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); + } + + // Untransform + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::WhiteLayer, + TransparencyWin::Untransform, + IntRect(1, 1, 14, 12)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(0, 0, 14, 12) == helper.drawRect()); + } + + // ScaleTransform + src->context()->save(); + src->context()->scale(FloatSize(2.0, 0.5)); + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::WhiteLayer, + TransparencyWin::ScaleTransform, + IntRect(2, 2, 6, 6)); + helper.composite(); + + // The coordinate system should be based in the upper left of our box. + // It should be post-transformed. + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize); + EXPECT_TRUE(IntRect(0, 0, 12, 3) == helper.drawRect()); + } + src->context()->restore(); +} + +TEST(TransparencyWin, TextComposite) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // KeepTransform is the only valid transform mode for TextComposite. + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::TextComposite, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 12)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); + } +} + +TEST(TransparencyWin, OpaqueCompositeLayer) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // KeepTransform + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 12)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); + } + + // KeepTransform with scroll applied. + src->context()->save(); + src->context()->translate(0, -1); + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 14)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 14) == helper.m_layerSize); + EXPECT_TRUE(IntRect(1, 1, 14, 14) == helper.drawRect()); + } + src->context()->restore(); + + // Untransform + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::Untransform, + IntRect(1, 1, 14, 12)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(0, 0, 14, 12) == helper.drawRect()); + } + + // ScaleTransform + src->context()->save(); + src->context()->scale(FloatSize(2.0, 0.5)); + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::ScaleTransform, + IntRect(2, 2, 6, 6)); + helper.composite(); + + // The coordinate system should be based in the upper left of our box. + // It should be post-transformed. + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize); + EXPECT_TRUE(IntRect(0, 0, 12, 3) == helper.drawRect()); + } + src->context()->restore(); +} + +TEST(TransparencyWin, WhiteLayerPixelTest) +{ + // Make a total transparent buffer, and draw the white layer inset by 1 px. + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::WhiteLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 14)); + + // Coordinates should be in the original space, not the layer. + drawNativeRect(helper.context(), 3, 3, 1, 1); + clearTopLayerAlphaChannel(helper.context()); + helper.composite(); + } + + // The final image should be transparent around the edges for 1 px, white + // in the middle, with (3,3) (what we drew above) being opaque black. + EXPECT_EQ(Color(Color::transparent), getPixelAt(src->context(), 0, 0)); + EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 2, 2)); + EXPECT_EQ(Color(Color::black), getPixelAt(src->context(), 3, 3)); + EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 4, 4)); +} + +TEST(TransparencyWin, OpaqueCompositeLayerPixel) +{ + Color red(0xFFFF0000), darkRed(0xFFBF0000); + Color green(0xFF00FF00); + + // Make a red bottom layer, followed by a half green next layer @ 50%. + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + FloatRect fullRect(0, 0, 16, 16); + src->context()->fillRect(fullRect, red, DeviceColorSpace); + src->context()->beginTransparencyLayer(0.5); + FloatRect rightHalf(8, 0, 8, 16); + src->context()->fillRect(rightHalf, green, DeviceColorSpace); + + // Make a transparency layer inset by one pixel, and fill it inset by + // another pixel with 50% black. + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 14)); + + FloatRect inner(2, 2, 12, 12); + helper.context()->fillRect(inner, Color(0x7f000000), DeviceColorSpace); + // These coordinates are relative to the layer, whish is inset by 1x1 + // pixels from the top left. So we're actually clearing (2, 2) and + // (13,13), which are the extreme corners of the black area (and which + // we check below). + clearTopLayerAlphaPixel(helper.context(), 1, 1); + clearTopLayerAlphaPixel(helper.context(), 12, 12); + helper.composite(); + } + + // Finish the compositing. + src->context()->endTransparencyLayer(); + + // Check that we got the right values, it should be like the rectangle was + // drawn with half opacity even though the alpha channel got messed up. + EXPECT_EQ(red, getPixelAt(src->context(), 0, 0)); + EXPECT_EQ(red, getPixelAt(src->context(), 1, 1)); + EXPECT_EQ(darkRed, getPixelAt(src->context(), 2, 2)); + + // The dark result is: + // (black @ 50% atop green) @ 50% atop red = 0xFF804000 + // which is 0xFFA02000 (Skia computes 0xFFA11F00 due to rounding). + Color darkGreenRed(0xFF803f00); + EXPECT_EQ(darkGreenRed, getPixelAt(src->context(), 13, 13)); + + // 50% green on top of red = FF808000 (rounded to what Skia will produce). + Color greenRed(0xFF807F00); + EXPECT_EQ(greenRed, getPixelAt(src->context(), 14, 14)); + EXPECT_EQ(greenRed, getPixelAt(src->context(), 15, 15)); +} + +// Tests that translations are properly handled when using KeepTransform. +TEST(TransparencyWin, TranslateOpaqueCompositeLayer) +{ + // Fill with white. + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + Color white(0xFFFFFFFF); + FloatRect fullRect(0, 0, 16, 16); + src->context()->fillRect(fullRect, white, DeviceColorSpace); + + // Scroll down by 8 (coordinate system goes up). + src->context()->save(); + src->context()->translate(0, -8); + + Color red(0xFFFF0000); + Color green(0xFF00FF00); + { + // Make the transparency layer after translation will be @ (0, -8) with + // size 16x16. + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::KeepTransform, + IntRect(0, 0, 16, 16)); + + // Draw a red pixel at (15, 15). This should be the at (15, 7) after + // the transform. + FloatRect bottomRight(15, 15, 1, 1); + helper.context()->fillRect(bottomRight, green, DeviceColorSpace); + helper.composite(); + } + + src->context()->restore(); + + // Check the pixel we wrote. + EXPECT_EQ(green, getPixelAt(src->context(), 15, 7)); +} + +// Same as OpaqueCompositeLayer, but the canvas has a rotation applied. This +// tests that the propert transform is applied to the copied layer. +TEST(TransparencyWin, RotateOpaqueCompositeLayer) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // The background is white. + Color white(0xFFFFFFFF); + FloatRect fullRect(0, 0, 16, 16); + src->context()->fillRect(fullRect, white, DeviceColorSpace); + + // Rotate the image by 90 degrees. This matrix is the same as + // cw90.rotate(90); but avoids rounding errors. Rounding errors can cause + // Skia to think that !rectStaysRect() and it will fall through to path + // drawing mode, which in turn gives us antialiasing. We want no + // antialiasing or other rounding problems since we're testing exact pixel + // values. + src->context()->save(); + AffineTransform cw90(0, 1, -1, 0, 0, 0); + src->context()->concatCTM(cw90); + + // Make a transparency layer consisting of a horizontal line of 50% black. + // Since the rotation is applied, this will actually be a vertical line + // down the middle of the image. + src->context()->beginTransparencyLayer(0.5); + FloatRect blackRect(0, -9, 16, 2); + Color black(0xFF000000); + src->context()->fillRect(blackRect, black, DeviceColorSpace); + + // Now draw 50% red square. + { + // Create a transparency helper inset one pixel in the buffer. The + // coordinates are before transforming into this space, and maps to + // IntRect(1, 1, 14, 14). + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::Untransform, + IntRect(1, -15, 14, 14)); + + // Fill with red. + helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000), DeviceColorSpace); + clearTopLayerAlphaChannel(helper.context()); + helper.composite(); + } + + // Finish the compositing. + src->context()->endTransparencyLayer(); + + // Top corner should be the original background. + EXPECT_EQ(white, getPixelAt(src->context(), 0, 0)); + + // Check the stripe down the middle, first at the top... + Color gray(0xFF808080); + EXPECT_EQ(white, getPixelAt(src->context(), 6, 0)); + EXPECT_EQ(gray, getPixelAt(src->context(), 7, 0)); + EXPECT_EQ(gray, getPixelAt(src->context(), 8, 0)); + EXPECT_EQ(white, getPixelAt(src->context(), 9, 0)); + + // ...now at the bottom. + EXPECT_EQ(white, getPixelAt(src->context(), 6, 15)); + EXPECT_EQ(gray, getPixelAt(src->context(), 7, 15)); + EXPECT_EQ(gray, getPixelAt(src->context(), 8, 15)); + EXPECT_EQ(white, getPixelAt(src->context(), 9, 15)); + + // Our red square should be 25% red over the top of those two. + Color redwhite(0xFFdfbfbf); + Color redgray(0xFF9f8080); + EXPECT_EQ(white, getPixelAt(src->context(), 0, 1)); + EXPECT_EQ(redwhite, getPixelAt(src->context(), 1, 1)); + EXPECT_EQ(redwhite, getPixelAt(src->context(), 6, 1)); + EXPECT_EQ(redgray, getPixelAt(src->context(), 7, 1)); + EXPECT_EQ(redgray, getPixelAt(src->context(), 8, 1)); + EXPECT_EQ(redwhite, getPixelAt(src->context(), 9, 1)); + EXPECT_EQ(redwhite, getPixelAt(src->context(), 14, 1)); + EXPECT_EQ(white, getPixelAt(src->context(), 15, 1)); + + // Complete the 50% transparent layer. + src->context()->restore(); +} + +TEST(TransparencyWin, TranslateScaleOpaqueCompositeLayer) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // The background is white on top with red on bottom. + Color white(0xFFFFFFFF); + FloatRect topRect(0, 0, 16, 8); + src->context()->fillRect(topRect, white, DeviceColorSpace); + Color red(0xFFFF0000); + FloatRect bottomRect(0, 8, 16, 8); + src->context()->fillRect(bottomRect, red, DeviceColorSpace); + + src->context()->save(); + + // Translate left by one pixel. + AffineTransform left; + left.translate(-1, 0); + + // Scale by 2x. + AffineTransform scale; + scale.scale(2.0); + src->context()->concatCTM(scale); + + // Then translate up by one pixel (which will actually be 2 due to scaling). + AffineTransform up; + up.translate(0, -1); + src->context()->concatCTM(up); + + // Now draw 50% red square. + { + // Create a transparency helper inset one pixel in the buffer. The + // coordinates are before transforming into this space, and maps to + // IntRect(1, 1, 14, 14). + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::KeepTransform, + IntRect(1, -15, 14, 14)); + + // Fill with red. + helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000), DeviceColorSpace); + clearTopLayerAlphaChannel(helper.context()); + helper.composite(); + } +} + +// Tests scale mode with no additional copy. +TEST(TransparencyWin, Scale) +{ + // Create an opaque white buffer. + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + FloatRect fullBuffer(0, 0, 16, 16); + src->context()->fillRect(fullBuffer, Color::white, DeviceColorSpace); + + // Scale by 2x. + src->context()->save(); + AffineTransform scale; + scale.scale(2.0); + src->context()->concatCTM(scale); + + // Start drawing a rectangle from 1->4. This should get scaled to 2->8. + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::NoLayer, + TransparencyWin::ScaleTransform, + IntRect(1, 1, 3, 3)); + + // The context should now have the identity transform and the returned + // rect should be scaled. + EXPECT_TRUE(helper.context()->getCTM().isIdentity()); + EXPECT_EQ(2, helper.drawRect().x()); + EXPECT_EQ(2, helper.drawRect().y()); + EXPECT_EQ(8, helper.drawRect().right()); + EXPECT_EQ(8, helper.drawRect().bottom()); + + // Set the pixel at (2, 2) to be transparent. This should be fixed when + // the helper goes out of scope. We don't want to call + // clearTopLayerAlphaChannel because that will actually clear the whole + // canvas (since we have no extra layer!). + SkBitmap& bitmap = const_cast<SkBitmap&>(helper.context()-> + platformContext()->canvas()->getTopPlatformDevice(). + accessBitmap(false)); + *bitmap.getAddr32(2, 2) &= 0x00FFFFFF; + helper.composite(); + } + + src->context()->restore(); + + // Check the pixel we previously made transparent, it should have gotten + // fixed back up to white. + + // The current version doesn't fixup transparency when there is no layer. + // This seems not to be necessary, so we don't bother, but if it becomes + // necessary, this line should be uncommented. + // EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 2, 2)); +} + +// Tests scale mode with an additional copy for transparency. This will happen +// if we have a scaled textbox, for example. WebKit will create a new +// transparency layer, draw the text field, then draw the text into it, then +// composite this down with an opacity. +TEST(TransparencyWin, ScaleTransparency) +{ + // Create an opaque white buffer. + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + FloatRect fullBuffer(0, 0, 16, 16); + src->context()->fillRect(fullBuffer, Color::white, DeviceColorSpace); + + // Make another layer (which duplicates how WebKit will make this). We fill + // the top half with red, and have the layer be 50% opaque. + src->context()->beginTransparencyLayer(0.5); + FloatRect topHalf(0, 0, 16, 8); + src->context()->fillRect(topHalf, Color(0xFFFF0000), DeviceColorSpace); + + // Scale by 2x. + src->context()->save(); + AffineTransform scale; + scale.scale(2.0); + src->context()->concatCTM(scale); + + // Make a layer inset two pixels (because of scaling, this is 2->14). And + // will it with 50% black. + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::ScaleTransform, + IntRect(1, 1, 6, 6)); + + helper.context()->fillRect(helper.drawRect(), Color(0x7f000000), DeviceColorSpace); + clearTopLayerAlphaChannel(helper.context()); + helper.composite(); + } + + // Finish the layer. + src->context()->restore(); + src->context()->endTransparencyLayer(); + + Color redBackground(0xFFFF8080); // 50% red composited on white. + EXPECT_EQ(redBackground, getPixelAt(src->context(), 0, 0)); + EXPECT_EQ(redBackground, getPixelAt(src->context(), 1, 1)); + + // Top half (minus two pixel border) should be 50% gray atop opaque + // red = 0xFF804141. Then that's composited with 50% transparency on solid + // white = 0xFFC0A1A1. + Color darkRed(0xFFBF8080); + EXPECT_EQ(darkRed, getPixelAt(src->context(), 2, 2)); + EXPECT_EQ(darkRed, getPixelAt(src->context(), 7, 7)); + + // Bottom half (minus a two pixel border) should be a layer with 5% gray + // with another 50% opacity composited atop white. + Color darkWhite(0xFFBFBFBF); + EXPECT_EQ(darkWhite, getPixelAt(src->context(), 8, 8)); + EXPECT_EQ(darkWhite, getPixelAt(src->context(), 13, 13)); + + Color white(0xFFFFFFFF); // Background in the lower-right. + EXPECT_EQ(white, getPixelAt(src->context(), 14, 14)); + EXPECT_EQ(white, getPixelAt(src->context(), 15, 15)); +} + +TEST(TransparencyWin, Text) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // Our text should end up 50% transparent blue-green. + Color fullResult(0x80008080); + + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::TextComposite, + TransparencyWin::KeepTransform, + IntRect(0, 0, 16, 16)); + helper.setTextCompositeColor(fullResult); + + // Write several different squares to simulate ClearType. These should + // all reduce to 2/3 coverage. + FloatRect pixel(0, 0, 1, 1); + helper.context()->fillRect(pixel, 0xFFFF0000, DeviceColorSpace); + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF00FF00, DeviceColorSpace); + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF0000FF, DeviceColorSpace); + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF008080, DeviceColorSpace); + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF800080, DeviceColorSpace); + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF808000, DeviceColorSpace); + + // Try one with 100% coverage (opaque black). + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF000000, DeviceColorSpace); + + // Now mess with the alpha channel. + clearTopLayerAlphaChannel(helper.context()); + helper.composite(); + } + + Color oneThirdResult(0x55005555); // = fullResult * 2 / 3 + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 0, 0)); + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 1, 0)); + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 2, 0)); + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 3, 0)); + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 4, 0)); + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 5, 0)); + EXPECT_EQ(fullResult, getPixelAt(src->context(), 6, 0)); + EXPECT_EQ(Color::transparent, getPixelAt(src->context(), 7, 0)); +} + +} // namespace WebCore diff --git a/WebKit/chromium/tests/UniscribeHelperTest.cpp b/WebKit/chromium/tests/UniscribeHelperTest.cpp new file mode 100644 index 0000000..8aaed11 --- /dev/null +++ b/WebKit/chromium/tests/UniscribeHelperTest.cpp @@ -0,0 +1,165 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <gtest/gtest.h> + +#include "PlatformString.h" +#include "UniscribeHelper.h" + +using namespace WebCore; + +namespace { + +class UniscribeTest : public testing::Test { +public: + UniscribeTest() + { + } + + // Returns an HFONT with the given name. The caller does not have to free + // this, it will be automatically freed at the end of the test. Returns 0 + // on failure. On success, the + HFONT MakeFont(const wchar_t* fontName, SCRIPT_CACHE** cache) + { + LOGFONT lf; + memset(&lf, 0, sizeof(LOGFONT)); + lf.lfHeight = 20; + wcscpy_s(lf.lfFaceName, fontName); + + HFONT hfont = CreateFontIndirect(&lf); + if (!hfont) + return 0; + + *cache = new SCRIPT_CACHE; + **cache = 0; + createdFonts.append(std::make_pair(hfont, *cache)); + return hfont; + } + +protected: + // Default font properties structure for tests to use. + SCRIPT_FONTPROPERTIES properties; + +private: + virtual void SetUp() + { + memset(&properties, 0, sizeof(SCRIPT_FONTPROPERTIES)); + properties.cBytes = sizeof(SCRIPT_FONTPROPERTIES); + properties.wgBlank = ' '; + properties.wgDefault = '?'; // Used when the char is not in the font. + properties.wgInvalid = '#'; // Used for invalid characters. + } + + virtual void TearDown() + { + // Free any allocated fonts. + for (size_t i = 0; i < createdFonts.size(); i++) { + DeleteObject(createdFonts[i].first); + ScriptFreeCache(createdFonts[i].second); + delete createdFonts[i].second; + } + createdFonts.clear(); + } + + // Tracks allocated fonts so we can delete them at the end of the test. + // The script cache pointer is heap allocated and must be freed. + Vector< std::pair<HFONT, SCRIPT_CACHE*> > createdFonts; +}; + +} // namespace + +// This test tests giving Uniscribe a very large buffer, which will cause a +// failure. +TEST_F(UniscribeTest, TooBig) +{ + // Make a large string with an e with a zillion combining accents. + String input(L"e"); + for (int i = 0; i < 100000; i++) + input.append(static_cast<UChar>(0x301)); // Combining acute accent. + + SCRIPT_CACHE* scriptCache; + HFONT hfont = MakeFont(L"Times New Roman", &scriptCache); + ASSERT_TRUE(hfont); + + // Test a long string without the normal length protection we have. This + // will cause shaping to fail. + { + UniscribeHelper uniscribe( + input.characters(), static_cast<int>(input.length()), + false, hfont, scriptCache, &properties); + uniscribe.initWithOptionalLengthProtection(false); + + // There should be one shaping entry, with nothing in it. + ASSERT_EQ(1, uniscribe.m_shapes.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_glyphs.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_logs.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_visualAttributes.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_advance.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_offsets.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_justify.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_abc.abcA); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_abc.abcB); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_abc.abcC); + + // The sizes of the other stuff should match the shaping entry. + EXPECT_EQ(1, uniscribe.m_runs.size()); + EXPECT_EQ(1, uniscribe.m_screenOrder.size()); + + // Check that the various querying functions handle the empty case + // properly. + EXPECT_EQ(0, uniscribe.width()); + EXPECT_EQ(0, uniscribe.firstGlyphForCharacter(0)); + EXPECT_EQ(0, uniscribe.firstGlyphForCharacter(1000)); + EXPECT_EQ(0, uniscribe.xToCharacter(0)); + EXPECT_EQ(0, uniscribe.xToCharacter(1000)); + } + + // Now test the very large string and make sure it is handled properly by + // the length protection. + { + UniscribeHelper uniscribe( + input.characters(), static_cast<int>(input.length()), + false, hfont, scriptCache, &properties); + uniscribe.initWithOptionalLengthProtection(true); + + // There should be 0 runs and shapes. + EXPECT_EQ(0, uniscribe.m_runs.size()); + EXPECT_EQ(0, uniscribe.m_shapes.size()); + EXPECT_EQ(0, uniscribe.m_screenOrder.size()); + + EXPECT_EQ(0, uniscribe.width()); + EXPECT_EQ(0, uniscribe.firstGlyphForCharacter(0)); + EXPECT_EQ(0, uniscribe.firstGlyphForCharacter(1000)); + EXPECT_EQ(0, uniscribe.xToCharacter(0)); + EXPECT_EQ(0, uniscribe.xToCharacter(1000)); + } +} |