diff options
Diffstat (limited to 'WebKit/chromium/tests')
22 files changed, 2518 insertions, 70 deletions
diff --git a/WebKit/chromium/tests/ArenaTestHelpers.h b/WebKit/chromium/tests/ArenaTestHelpers.h new file mode 100644 index 0000000..70936e5 --- /dev/null +++ b/WebKit/chromium/tests/ArenaTestHelpers.h @@ -0,0 +1,79 @@ +/* + * 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: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS 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 APPLE OR ITS 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. + */ + +#ifndef ArenaTestHelpers_h +#define ArenaTestHelpers_h + +#include "PODArena.h" +#include <gtest/gtest.h> +#include <wtf/NotFound.h> +#include <wtf/Vector.h> + +namespace WebCore { +namespace ArenaTestHelpers { + +// An allocator for the PODArena which tracks the regions which have +// been allocated. +class TrackedAllocator : public PODArena::FastMallocAllocator { +public: + static PassRefPtr<TrackedAllocator> create() + { + return adoptRef(new TrackedAllocator); + } + + virtual void* allocate(size_t size) + { + void* result = PODArena::FastMallocAllocator::allocate(size); + m_allocatedRegions.append(result); + return result; + } + + virtual void free(void* ptr) + { + size_t slot = m_allocatedRegions.find(ptr); + ASSERT_NE(slot, notFound); + m_allocatedRegions.remove(slot); + PODArena::FastMallocAllocator::free(ptr); + } + + bool isEmpty() const + { + return !numRegions(); + } + + int numRegions() const + { + return m_allocatedRegions.size(); + } + +private: + TrackedAllocator() { } + Vector<void*> m_allocatedRegions; +}; + +} // namespace ArenaTestHelpers +} // namespace WebCore + +#endif // ArenaTestHelpers_h diff --git a/WebKit/chromium/tests/DragImageTest.cpp b/WebKit/chromium/tests/DragImageTest.cpp new file mode 100644 index 0000000..8ce6fe2 --- /dev/null +++ b/WebKit/chromium/tests/DragImageTest.cpp @@ -0,0 +1,151 @@ +/* + * 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 "DragImage.h" +#include "Image.h" +#include "NativeImageSkia.h" + +using namespace WebCore; + +namespace { + +class TestImage : public Image { +public: + + static PassRefPtr<TestImage> create(const IntSize& size) + { + return adoptRef(new TestImage(size)); + } + + explicit TestImage(const IntSize& size) + : Image(0) + , m_size(size) + { + m_nativeImage = new NativeImageSkia(); + m_nativeImage->setConfig(SkBitmap::kARGB_8888_Config, + size.width(), size.height(), 0); + m_nativeImage->allocPixels(); + } + + virtual ~TestImage() + { + delete m_nativeImage; + } + + virtual IntSize size() const + { + return m_size; + } + + virtual NativeImagePtr nativeImageForCurrentFrame() + { + if (m_size.isZero()) + return 0; + + return m_nativeImage; + } + + // Stub implementations of pure virtual Image functions. + virtual void destroyDecodedData(bool) + { + } + + virtual unsigned int decodedSize() const + { + return 0u; + } + + virtual void draw(WebCore::GraphicsContext*, const WebCore::FloatRect&, + const WebCore::FloatRect&, WebCore::ColorSpace, + WebCore::CompositeOperator) + { + } + +private: + + IntSize m_size; + + NativeImagePtr m_nativeImage; +}; + +TEST(DragImageTest, NullHandling) +{ + EXPECT_FALSE(createDragImageFromImage(0)); + + deleteDragImage(0); + EXPECT_TRUE(dragImageSize(0).isZero()); + EXPECT_FALSE(scaleDragImage(0, FloatSize(0.5, 0.5))); + EXPECT_FALSE(dissolveDragImageToFraction(0, 0.5)); + EXPECT_FALSE(createDragImageFromImage(0)); + EXPECT_FALSE(createDragImageIconForCachedImage(0)); +} + +TEST(DragImageTest, NonNullHandling) +{ + RefPtr<TestImage> testImage(TestImage::create(IntSize(2, 2))); + DragImageRef dragImage = createDragImageFromImage(testImage.get()); + ASSERT_TRUE(dragImage); + + dragImage = scaleDragImage(dragImage, FloatSize(0.5, 0.5)); + ASSERT_TRUE(dragImage); + IntSize size = dragImageSize(dragImage); + EXPECT_EQ(1, size.width()); + EXPECT_EQ(1, size.height()); + + dragImage = dissolveDragImageToFraction(dragImage, 0.5); + ASSERT_TRUE(dragImage); + + deleteDragImage(dragImage); +} + +TEST(DragImageTest, CreateDragImage) +{ + { + // Tests that the DrageImage implementation doesn't choke on null values + // of nativeImageForCurrentFrame(). + RefPtr<TestImage> testImage(TestImage::create(IntSize())); + EXPECT_FALSE(createDragImageFromImage(testImage.get())); + } + + { + // Tests that the drag image is a deep copy. + RefPtr<TestImage> testImage(TestImage::create(IntSize(1, 1))); + DragImageRef dragImage = createDragImageFromImage(testImage.get()); + ASSERT_TRUE(dragImage); + SkAutoLockPixels lock1(*dragImage), lock2(*(testImage->nativeImageForCurrentFrame())); + EXPECT_NE(dragImage->getPixels(), testImage->nativeImageForCurrentFrame()->getPixels()); + } +} + +} // anonymous namespace diff --git a/WebKit/chromium/tests/IDBBindingUtilitiesTest.cpp b/WebKit/chromium/tests/IDBBindingUtilitiesTest.cpp new file mode 100644 index 0000000..1b7f156 --- /dev/null +++ b/WebKit/chromium/tests/IDBBindingUtilitiesTest.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: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS 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 APPLE OR ITS 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 "IDBBindingUtilities.h" +#include "IDBKey.h" +#include "IDBKeyPath.h" +#include "SerializedScriptValue.h" + +#include <gtest/gtest.h> +#include <wtf/Vector.h> + +#if ENABLE(INDEXED_DATABASE) + +using namespace WebCore; + +namespace { + +class LocalContext { +public: + LocalContext() + : m_context(v8::Context::New()) + { + m_context->Enter(); + } + + virtual ~LocalContext() + { + m_context->Exit(); + m_context.Dispose(); + } + +private: + v8::Locker m_locker; + v8::HandleScope m_scope; + v8::Persistent<v8::Context> m_context; +}; + +PassRefPtr<IDBKey> checkKeyFromValueAndKeyPathInternal(SerializedScriptValue* value, const String& keyPath) +{ + Vector<IDBKeyPathElement> idbKeyPath; + IDBKeyPathParseError parseError; + IDBParseKeyPath(keyPath, idbKeyPath, parseError); + EXPECT_EQ(IDBKeyPathParseErrorNone, parseError); + return createIDBKeyFromSerializedValueAndKeyPath(value, idbKeyPath); +} + +void checkKeyPathNullValue(SerializedScriptValue* value, const String& keyPath) +{ + RefPtr<IDBKey> idbKey = checkKeyFromValueAndKeyPathInternal(value, keyPath); + ASSERT_FALSE(idbKey.get()); +} + +void checkKeyPathStringValue(SerializedScriptValue* value, const String& keyPath, const String& expected) +{ + RefPtr<IDBKey> idbKey = checkKeyFromValueAndKeyPathInternal(value, keyPath); + ASSERT_TRUE(idbKey.get()); + ASSERT_EQ(IDBKey::StringType, idbKey->type()); + ASSERT_TRUE(expected == idbKey->string()); +} + +void checkKeyPathNumberValue(SerializedScriptValue* value, const String& keyPath, int expected) +{ + RefPtr<IDBKey> idbKey = checkKeyFromValueAndKeyPathInternal(value, keyPath); + ASSERT_TRUE(idbKey.get()); + ASSERT_EQ(IDBKey::NumberType, idbKey->type()); + ASSERT_TRUE(expected == idbKey->number()); +} + +TEST(IDBKeyFromValueAndKeyPathTest, TopLevelPropertyStringValue) +{ + LocalContext v8context; + v8::Local<v8::Object> object = v8::Object::New(); + object->Set(v8::String::New("foo"), v8::String::New("zoo")); + + RefPtr<SerializedScriptValue> serializedScriptValue = SerializedScriptValue::create(object); + + checkKeyPathStringValue(serializedScriptValue.get(), "foo", "zoo"); + checkKeyPathNullValue(serializedScriptValue.get(), "bar"); + checkKeyPathNullValue(serializedScriptValue.get(), "[3]"); +} + +TEST(IDBKeyFromValueAndKeyPathTest, TopLevelPropertyNumberValue) +{ + LocalContext v8context; + v8::Local<v8::Object> object = v8::Object::New(); + object->Set(v8::String::New("foo"), v8::Number::New(456)); + + RefPtr<SerializedScriptValue> serializedScriptValue = SerializedScriptValue::create(object); + + checkKeyPathNumberValue(serializedScriptValue.get(), "foo", 456); + checkKeyPathNullValue(serializedScriptValue.get(), "bar"); + checkKeyPathNullValue(serializedScriptValue.get(), "[3]"); +} + +TEST(IDBKeyFromValueAndKeyPathTest, TopLevelArrayElement) +{ + LocalContext v8context; + v8::Local<v8::Array> array = v8::Array::New(); + array->Set(3, v8::String::New("zoo")); + + RefPtr<SerializedScriptValue> serializedScriptValue = SerializedScriptValue::create(array); + + checkKeyPathStringValue(serializedScriptValue.get(), "[3]", "zoo"); + checkKeyPathNullValue(serializedScriptValue.get(), "foo"); + checkKeyPathNullValue(serializedScriptValue.get(), "bar"); +} + +TEST(IDBKeyFromValueAndKeyPathTest, SubProperty) +{ + LocalContext v8context; + v8::Local<v8::Object> object = v8::Object::New(); + v8::Local<v8::Object> subProperty = v8::Object::New(); + subProperty->Set(v8::String::New("bar"), v8::String::New("zee")); + object->Set(v8::String::New("foo"), subProperty); + + RefPtr<SerializedScriptValue> serializedScriptValue = SerializedScriptValue::create(object); + + checkKeyPathStringValue(serializedScriptValue.get(), "foo.bar", "zee"); + checkKeyPathNullValue(serializedScriptValue.get(), "bar"); + checkKeyPathNullValue(serializedScriptValue.get(), "[3]"); +} + +TEST(IDBKeyFromValueAndKeyPathTest, Array2D) +{ + LocalContext v8context; + v8::Local<v8::Object> object = v8::Object::New(); + v8::Local<v8::Array> array = v8::Array::New(); + v8::Local<v8::Array> subArray = v8::Array::New(); + subArray->Set(7, v8::String::New("zee")); + array->Set(3, subArray); + object->Set(v8::String::New("foo"), array); + + RefPtr<SerializedScriptValue> serializedScriptValue = SerializedScriptValue::create(object); + + checkKeyPathStringValue(serializedScriptValue.get(), "foo[3][7]", "zee"); + checkKeyPathNullValue(serializedScriptValue.get(), "bar"); + checkKeyPathNullValue(serializedScriptValue.get(), "[4]"); +} + +} // namespace + +#endif // ENABLE(INDEXED_DATABASE) diff --git a/WebKit/chromium/tests/IDBKeyPathTest.cpp b/WebKit/chromium/tests/IDBKeyPathTest.cpp new file mode 100644 index 0000000..6c378d6 --- /dev/null +++ b/WebKit/chromium/tests/IDBKeyPathTest.cpp @@ -0,0 +1,205 @@ +/* + * 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: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS 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 APPLE OR ITS 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 "IDBKeyPath.h" + +#include <gtest/gtest.h> +#include <wtf/Vector.h> + +#if ENABLE(INDEXED_DATABASE) + +using namespace WebCore; + +namespace { + +IDBKeyPathElement ExpectedToken(const String& identifier, bool isIndexed, int index) +{ + IDBKeyPathElement expected; + if (isIndexed) { + expected.type = IDBKeyPathElement::IsIndexed; + expected.index = index; + } else { + expected.type = IDBKeyPathElement::IsNamed; + expected.identifier = identifier; + } + return expected; +} + +void checkKeyPath(const String& keyPath, const Vector<IDBKeyPathElement>& expected, int parserError) +{ + + IDBKeyPathParseError error; + Vector<IDBKeyPathElement> idbKeyPathElements; + IDBParseKeyPath(keyPath, idbKeyPathElements, error); + ASSERT_EQ(parserError, error); + if (error != IDBKeyPathParseErrorNone) + return; + ASSERT_EQ(expected.size(), idbKeyPathElements.size()); + for (size_t i = 0; i < expected.size(); ++i) { + ASSERT_TRUE(expected[i].type == idbKeyPathElements[i].type) << i; + if (expected[i].type == IDBKeyPathElement::IsIndexed) + ASSERT_EQ(expected[i].index, idbKeyPathElements[i].index) << i; + else if (expected[i].type == IDBKeyPathElement::IsNamed) + ASSERT_TRUE(expected[i].identifier == idbKeyPathElements[i].identifier) << i; + else + ASSERT_TRUE(false) << "Invalid IDBKeyPathElement type"; + } +} + +TEST(IDBKeyPathTest, ValidKeyPath0) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("foo.bar.zoo"); + expected.append(ExpectedToken("foo", false, 0)); + expected.append(ExpectedToken("bar", false, 0)); + expected.append(ExpectedToken("zoo", false, 0)); + checkKeyPath(keyPath, expected, 0); +} + +TEST(IDBKeyPathTest, ValidKeyPath1) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("a[34][20].foo[2].bar"); + expected.append(ExpectedToken("a", false, 0)); + expected.append(ExpectedToken(String(), true, 34)); + expected.append(ExpectedToken(String(), true, 20)); + expected.append(ExpectedToken("foo", false, 0)); + expected.append(ExpectedToken(String(), true, 2)); + expected.append(ExpectedToken("bar", false, 0)); + checkKeyPath(keyPath, expected, 0); +} + +TEST(IDBKeyPathTest, ValidKeyPath2) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("foo[ 34 ].Zoo_[00023]\t._c"); + expected.append(ExpectedToken("foo", false, 0)); + expected.append(ExpectedToken(String(), true, 34)); + expected.append(ExpectedToken("Zoo_", false, 0)); + expected.append(ExpectedToken(String(), true, 23)); + expected.append(ExpectedToken("_c", false, 0)); + checkKeyPath(keyPath, expected, 0); +} + +TEST(IDBKeyPathTest, ValidKeyPath3) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("foo[ 34 ]"); + expected.append(ExpectedToken("foo", false, 0)); + expected.append(ExpectedToken(String(), true, 34)); + checkKeyPath(keyPath, expected, 0); +} + +TEST(IDBKeyPathTest, ValidKeyPath4) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("[ 34 ]"); + expected.append(ExpectedToken(String(), true, 34)); + checkKeyPath(keyPath, expected, 0); +} + +TEST(IDBKeyPathTest, InvalidKeyPath2) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("a[[34]].b[2].c"); + expected.append(ExpectedToken("a", false, 0)); + checkKeyPath(keyPath, expected, 3); +} + +TEST(IDBKeyPathTest, InvalidKeyPath3) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("a[[34].b[2].c"); + expected.append(ExpectedToken("a", false, 0)); + checkKeyPath(keyPath, expected, 3); +} + +TEST(IDBKeyPathTest, InvalidKeyPath5) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("a[[34.b[2].c"); + expected.append(ExpectedToken("a", false, 0)); + checkKeyPath(keyPath, expected, 3); +} + +TEST(IDBKeyPathTest, InvalidKeyPath6) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("+a[34].b[2].c"); + checkKeyPath(keyPath, expected, 1); +} + +TEST(IDBKeyPathTest, InvalidKeyPath7) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("%a[34].b[2].c"); + checkKeyPath(keyPath, expected, 1); +} + +TEST(IDBKeyPathTest, InvalidKeyPath8) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("a{[34]}.b[2].c"); + expected.append(ExpectedToken("a", false, 0)); + checkKeyPath(keyPath, expected, 2); +} + +TEST(IDBKeyPathTest, InvalidKeyPath9) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("a..b[2].c"); + expected.append(ExpectedToken("a", false, 0)); + checkKeyPath(keyPath, expected, 5); +} + +TEST(IDBKeyPathTest, InvalidKeyPath10) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("a[34]b.foo[2].bar"); + expected.append(ExpectedToken("a", false, 0)); + expected.append(ExpectedToken(String(), true, 34)); + checkKeyPath(keyPath, expected, 4); +} + +TEST(IDBKeyPathTest, InvalidKeyPath11) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("a[-1]"); + expected.append(ExpectedToken("a", false, 0)); + checkKeyPath(keyPath, expected, 3); +} + +TEST(IDBKeyPathTest, InvalidKeyPath12) +{ + Vector<IDBKeyPathElement> expected; + String keyPath("a[9999999999999999999999999999999999]"); + expected.append(ExpectedToken("a", false, 0)); + checkKeyPath(keyPath, expected, 3); +} + +} // namespace + +#endif // ENABLE(INDEXED_DATABASE) diff --git a/WebKit/chromium/tests/KURLTest.cpp b/WebKit/chromium/tests/KURLTest.cpp index b316683..152dd31 100644 --- a/WebKit/chromium/tests/KURLTest.cpp +++ b/WebKit/chromium/tests/KURLTest.cpp @@ -37,13 +37,16 @@ #include "KURL.h" -namespace { - +namespace WTF { // Output stream operator so gTest's macros work with WebCore strings. -std::ostream& operator<<(std::ostream& out, const WebCore::String& str) +std::ostream& operator<<(std::ostream& out, const String& str) { return str.isEmpty() ? out : out << str.utf8().data(); } +} // namespace WTF + +namespace { + struct ComponentCase { const char* url; @@ -95,7 +98,7 @@ TEST(KURLTest, SameGetters) EXPECT_EQ(cases[i].hasRef, kurl.hasFragmentIdentifier()); // UTF-16 - WebCore::String utf16(cases[i].url); + WTF::String utf16(cases[i].url); kurl = WebCore::KURL(WebCore::ParsedURLString, utf16); EXPECT_EQ(cases[i].protocol, kurl.protocol()); @@ -144,7 +147,7 @@ TEST(KURLTest, DifferentGetters) 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()); + EXPECT_EQ(WTF::String::fromUTF8(cases[i].ref), kurl.fragmentIdentifier()); else EXPECT_TRUE(kurl.fragmentIdentifier().isNull()); } @@ -156,23 +159,23 @@ TEST(KURLTest, UTF8) { const char asciiURL[] = "http://foo/bar#baz"; WebCore::KURL asciiKURL(WebCore::ParsedURLString, asciiURL); - EXPECT_TRUE(asciiKURL.string() == WebCore::String(asciiURL)); + EXPECT_TRUE(asciiKURL.string() == WTF::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))); + EXPECT_TRUE(WTF::equalIgnoringCase(asciiKURL, WTF::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")); + EXPECT_TRUE(WTF::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)); + EXPECT_TRUE(utf8KURL.string() == WTF::String::fromUTF8(utf8URL)); } TEST(KURLTest, Setters) @@ -281,20 +284,20 @@ TEST(KURLTest, Decode) }; for (size_t i = 0; i < ARRAYSIZE_UNSAFE(decodeCases); i++) { - WebCore::String input(decodeCases[i].input); - WebCore::String str = WebCore::decodeURLEscapeSequences(input); + WTF::String input(decodeCases[i].input); + WTF::String str = WebCore::decodeURLEscapeSequences(input); EXPECT_STREQ(decodeCases[i].output, str.utf8().data()); } // Our decode should decode %00 - WebCore::String zero = WebCore::decodeURLEscapeSequences("%00"); + WTF::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( + WTF::String invalid = WebCore::decodeURLEscapeSequences( "%e4%a0%e5%a5%bd"); char16 invalidExpectedHelper[4] = { 0x00e4, 0x00a0, 0x597d, 0 }; - WebCore::String invalidExpected( + WTF::String invalidExpected( reinterpret_cast<const ::UChar*>(invalidExpectedHelper), 3); EXPECT_EQ(invalidExpected, invalid); @@ -305,20 +308,20 @@ TEST(KURLTest, Encode) { // Also test that it gets converted to UTF-8 properly. char16 wideInputHelper[3] = { 0x4f60, 0x597d, 0 }; - WebCore::String wideInput( + WTF::String wideInput( reinterpret_cast<const ::UChar*>(wideInputHelper), 2); - WebCore::String wideReference("\xe4\xbd\xa0\xe5\xa5\xbd", 6); - WebCore::String wideOutput = + WTF::String wideReference("\xe4\xbd\xa0\xe5\xa5\xbd", 6); + WTF::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( + WTF::String input( "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 16); - WebCore::String reference( + WTF::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); + WTF::String output = WebCore::encodeWithURLEscapeSequences(input); EXPECT_EQ(reference, output); } @@ -381,10 +384,11 @@ TEST(KURLTest, ReplaceInvalid) 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. + // Now let's test that giving an invalid replacement fails. Invalid + // protocols fail without modifying the URL, which should remain valid. #if USE(GOOGLEURL) - kurl.setProtocol("f/sj#@"); - EXPECT_FALSE(kurl.isValid()); + EXPECT_FALSE(kurl.setProtocol("f/sj#@")); + EXPECT_TRUE(kurl.isValid()); #endif } @@ -394,7 +398,7 @@ TEST(KURLTest, Path) WebCore::KURL kurl(WebCore::ParsedURLString, initial); // Clear by setting a null string. - WebCore::String nullString; + WTF::String nullString; EXPECT_TRUE(nullString.isNull()); kurl.setPath(nullString); EXPECT_STREQ("http://www.google.com/", kurl.string().utf8().data()); @@ -408,14 +412,14 @@ TEST(KURLTest, Query) WebCore::KURL kurl(WebCore::ParsedURLString, initial); // Clear by setting a null string. - WebCore::String nullString; + WTF::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(""); + WTF::String emptyString(""); EXPECT_FALSE(emptyString.isNull()); kurl.setQuery(emptyString); EXPECT_STREQ("http://www.google.com/search?", kurl.string().utf8().data()); @@ -455,10 +459,10 @@ TEST(KURLTest, Ref) // Setting the ref to the null string will clear it altogether. cur = WebCore::KURL(WebCore::ParsedURLString, "http://foo/bar"); - cur.setFragmentIdentifier(WebCore::String()); + cur.setFragmentIdentifier(WTF::String()); EXPECT_STREQ("http://foo/bar", cur.string().utf8().data()); cur = kurl; - cur.setFragmentIdentifier(WebCore::String()); + cur.setFragmentIdentifier(WTF::String()); EXPECT_STREQ("http://foo/bar", cur.string().utf8().data()); } @@ -484,7 +488,7 @@ TEST(KURLTest, Empty) EXPECT_TRUE(kurl2.string().isEmpty()); // Resolve the null URL on a null string. - WebCore::KURL kurl22(kurl, WebCore::String()); + WebCore::KURL kurl22(kurl, WTF::String()); EXPECT_FALSE(kurl22.isNull()); EXPECT_TRUE(kurl22.isEmpty()); EXPECT_FALSE(kurl22.isValid()); diff --git a/WebKit/chromium/tests/PODArenaTest.cpp b/WebKit/chromium/tests/PODArenaTest.cpp new file mode 100644 index 0000000..c5b1ede --- /dev/null +++ b/WebKit/chromium/tests/PODArenaTest.cpp @@ -0,0 +1,106 @@ +/* + * 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: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS 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 APPLE OR ITS 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 "PODArena.h" + +#include "ArenaTestHelpers.h" +#include <algorithm> +#include <gtest/gtest.h> +#include <wtf/FastMalloc.h> +#include <wtf/RefPtr.h> +#include <wtf/Vector.h> + +namespace WebCore { + +using ArenaTestHelpers::TrackedAllocator; + +namespace { + +// A couple of simple structs to allocate. +struct TestClass1 { + TestClass1() + : x(0), y(0), z(0), w(1) { } + + float x, y, z, w; +}; + +struct TestClass2 { + TestClass2() + : a(1), b(2), c(3), d(4) { } + + float a, b, c, d; +}; + +} // anonymous namespace + +class PODArenaTest : public testing::Test { +}; + +// Make sure the arena can successfully allocate from more than one +// region. +TEST_F(PODArenaTest, CanAllocateFromMoreThanOneRegion) +{ + RefPtr<TrackedAllocator> allocator = TrackedAllocator::create(); + RefPtr<PODArena> arena = PODArena::create(allocator); + int numIterations = 10 * PODArena::DefaultChunkSize / sizeof(TestClass1); + for (int i = 0; i < numIterations; ++i) + arena->allocateObject<TestClass1>(); + EXPECT_GT(allocator->numRegions(), 1); +} + +// Make sure the arena frees all allocated regions during destruction. +TEST_F(PODArenaTest, FreesAllAllocatedRegions) +{ + RefPtr<TrackedAllocator> allocator = TrackedAllocator::create(); + { + RefPtr<PODArena> arena = PODArena::create(allocator); + for (int i = 0; i < 3; i++) + arena->allocateObject<TestClass1>(); + EXPECT_GT(allocator->numRegions(), 0); + } + EXPECT_TRUE(allocator->isEmpty()); +} + +// Make sure the arena runs constructors of the objects allocated within. +TEST_F(PODArenaTest, RunsConstructors) +{ + RefPtr<PODArena> arena = PODArena::create(); + for (int i = 0; i < 10000; i++) { + TestClass1* tc1 = arena->allocateObject<TestClass1>(); + EXPECT_EQ(0, tc1->x); + EXPECT_EQ(0, tc1->y); + EXPECT_EQ(0, tc1->z); + EXPECT_EQ(1, tc1->w); + TestClass2* tc2 = arena->allocateObject<TestClass2>(); + EXPECT_EQ(1, tc2->a); + EXPECT_EQ(2, tc2->b); + EXPECT_EQ(3, tc2->c); + EXPECT_EQ(4, tc2->d); + } +} + +} // namespace WebCore diff --git a/WebKit/chromium/tests/PODIntervalTreeTest.cpp b/WebKit/chromium/tests/PODIntervalTreeTest.cpp new file mode 100644 index 0000000..8241a89 --- /dev/null +++ b/WebKit/chromium/tests/PODIntervalTreeTest.cpp @@ -0,0 +1,356 @@ +/* + * 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: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS 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 APPLE OR ITS 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. + */ + +// Tests for the interval tree class. + +#include "config.h" + +#include "PODIntervalTree.h" + +#include "Logging.h" +#include "TreeTestHelpers.h" +#include <gtest/gtest.h> +#include <wtf/Vector.h> +#include <wtf/text/WTFString.h> + +namespace WebCore { + +using TreeTestHelpers::generateSeed; +using TreeTestHelpers::initRandom; +using TreeTestHelpers::nextRandom; + +#ifndef NDEBUG +template<> +struct ValueToString<float> { + static String string(const float& value) { return String::number(value); } +}; + +template<> +struct ValueToString<void*> { + static String string(void* const& value) + { + return String::format("0x%p", value); + } +}; +#endif + +TEST(PODIntervalTreeTest, TestInsertion) +{ + PODIntervalTree<float> tree; + tree.add(PODInterval<float>(2, 4)); + ASSERT_TRUE(tree.checkInvariants()); +} + +TEST(PODIntervalTreeTest, TestInsertionAndQuery) +{ + PODIntervalTree<float> tree; + tree.add(PODInterval<float>(2, 4)); + ASSERT_TRUE(tree.checkInvariants()); + Vector<PODInterval<float> > result = tree.allOverlaps(PODInterval<float>(1, 3)); + EXPECT_EQ(1U, result.size()); + EXPECT_EQ(2, result[0].low()); + EXPECT_EQ(4, result[0].high()); +} + +TEST(PODIntervalTreeTest, TestQueryAgainstZeroSizeInterval) +{ + PODIntervalTree<float> tree; + tree.add(PODInterval<float>(1, 2.5)); + tree.add(PODInterval<float>(3.5, 5)); + tree.add(PODInterval<float>(2, 4)); + ASSERT_TRUE(tree.checkInvariants()); + Vector<PODInterval<float> > result = tree.allOverlaps(PODInterval<float>(3, 3)); + EXPECT_EQ(1U, result.size()); + EXPECT_EQ(2, result[0].low()); + EXPECT_EQ(4, result[0].high()); +} + +#ifndef NDEBUG +template<> +struct ValueToString<int*> { + static String string(int* const& value) + { + return String::format("0x%p", value); + } +}; +#endif + +TEST(PODIntervalTreeTest, TestDuplicateElementInsertion) +{ + PODIntervalTree<float, int*> tree; + int tmp1 = 1; + int tmp2 = 2; + typedef PODIntervalTree<float, int*>::IntervalType IntervalType; + IntervalType interval1(1, 3, &tmp1); + IntervalType interval2(1, 3, &tmp2); + tree.add(interval1); + tree.add(interval2); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(interval1)); + EXPECT_TRUE(tree.contains(interval2)); + EXPECT_TRUE(tree.remove(interval1)); + EXPECT_TRUE(tree.contains(interval2)); + EXPECT_FALSE(tree.contains(interval1)); + EXPECT_TRUE(tree.remove(interval2)); + EXPECT_EQ(0, tree.size()); +} + +namespace { + +struct UserData1 { +public: + UserData1() + : a(0), b(1) { } + + float a; + int b; +}; + +} // anonymous namespace + +#ifndef NDEBUG +template<> +struct ValueToString<UserData1> { + static String string(const UserData1& value) + { + return String("[UserData1 a=") + String::number(value.a) + " b=" + String::number(value.b) + "]"; + } +}; +#endif + +TEST(PODIntervalTreeTest, TestInsertionOfComplexUserData) +{ + PODIntervalTree<float, UserData1> tree; + UserData1 data1; + data1.a = 5; + data1.b = 6; + tree.add(tree.createInterval(2, 4, data1)); + ASSERT_TRUE(tree.checkInvariants()); +} + +TEST(PODIntervalTreeTest, TestQueryingOfComplexUserData) +{ + PODIntervalTree<float, UserData1> tree; + UserData1 data1; + data1.a = 5; + data1.b = 6; + tree.add(tree.createInterval(2, 4, data1)); + ASSERT_TRUE(tree.checkInvariants()); + Vector<PODInterval<float, UserData1> > overlaps = tree.allOverlaps(tree.createInterval(3, 5, data1)); + EXPECT_EQ(1U, overlaps.size()); + EXPECT_EQ(5, overlaps[0].data().a); + EXPECT_EQ(6, overlaps[0].data().b); +} + +namespace { + +class EndpointType1 { +public: + explicit EndpointType1(int value) + : m_value(value) { } + + int value() const { return m_value; } + + bool operator<(const EndpointType1& other) const { return m_value < other.m_value; } + bool operator==(const EndpointType1& other) const { return m_value == other.m_value; } + +private: + int m_value; + // These operators should not be called by the interval tree. + bool operator>(const EndpointType1& other); + bool operator<=(const EndpointType1& other); + bool operator>=(const EndpointType1& other); + bool operator!=(const EndpointType1& other); +}; + +} // anonymous namespace + +#ifndef NDEBUG +template<> +struct ValueToString<EndpointType1> { + static String string(const EndpointType1& value) + { + return String("[EndpointType1 value=") + String::number(value.value()) + "]"; + } +}; +#endif + +TEST(PODIntervalTreeTest, TestTreeDoesNotRequireMostOperators) +{ + PODIntervalTree<EndpointType1> tree; + tree.add(tree.createInterval(EndpointType1(1), EndpointType1(2))); + ASSERT_TRUE(tree.checkInvariants()); +} + +// Uncomment to debug a failure of the insertion and deletion test. Won't work +// in release builds. +// #define DEBUG_INSERTION_AND_DELETION_TEST + +#ifndef NDEBUG +template<> +struct ValueToString<int> { + static String string(const int& value) { return String::number(value); } +}; +#endif + +namespace { + +void InsertionAndDeletionTest(int32_t seed, int treeSize) +{ + initRandom(seed); + int maximumValue = treeSize; + // Build the tree + PODIntervalTree<int> tree; + Vector<PODInterval<int> > addedElements; + Vector<PODInterval<int> > removedElements; + for (int i = 0; i < treeSize; i++) { + int left = nextRandom(maximumValue); + int length = nextRandom(maximumValue); + PODInterval<int> interval(left, left + length); + tree.add(interval); +#ifdef DEBUG_INSERTION_AND_DELETION_TEST + LOG_ERROR("*** Adding element %s", ValueToString<PODInterval<int> >::string(interval).ascii().data()); +#endif + addedElements.append(interval); + } + // Churn the tree's contents. + // First remove half of the elements in random order. + for (int i = 0; i < treeSize / 2; i++) { + int index = nextRandom(addedElements.size()); +#ifdef DEBUG_INSERTION_AND_DELETION_TEST + LOG_ERROR("*** Removing element %s", ValueToString<PODInterval<int> >::string(addedElements[index]).ascii().data()); +#endif + ASSERT_TRUE(tree.contains(addedElements[index])) << "Test failed for seed " << seed; + tree.remove(addedElements[index]); + removedElements.append(addedElements[index]); + addedElements.remove(index); + ASSERT_TRUE(tree.checkInvariants()) << "Test failed for seed " << seed; + } + // Now randomly add or remove elements. + for (int i = 0; i < 2 * treeSize; i++) { + bool add = false; + if (!addedElements.size()) + add = true; + else if (!removedElements.size()) + add = false; + else + add = (nextRandom(2) == 1); + if (add) { + int index = nextRandom(removedElements.size()); +#ifdef DEBUG_INSERTION_AND_DELETION_TEST + LOG_ERROR("*** Adding element %s", ValueToString<PODInterval<int> >::string(removedElements[index]).ascii().data()); +#endif + tree.add(removedElements[index]); + addedElements.append(removedElements[index]); + removedElements.remove(index); + } else { + int index = nextRandom(addedElements.size()); +#ifdef DEBUG_INSERTION_AND_DELETION_TEST + LOG_ERROR("*** Removing element %s", ValueToString<PODInterval<int> >::string(addedElements[index]).ascii().data()); +#endif + ASSERT_TRUE(tree.contains(addedElements[index])) << "Test failed for seed " << seed; + ASSERT_TRUE(tree.remove(addedElements[index])) << "Test failed for seed " << seed; + removedElements.append(addedElements[index]); + addedElements.remove(index); + } + ASSERT_TRUE(tree.checkInvariants()) << "Test failed for seed " << seed; + } +} + +} // anonymous namespace + +TEST(PODIntervalTreeTest, RandomDeletionAndInsertionRegressionTest1) +{ + InsertionAndDeletionTest(13972, 100); +} + +TEST(PODIntervalTreeTest, RandomDeletionAndInsertionRegressionTest2) +{ + InsertionAndDeletionTest(1283382113, 10); +} + +TEST(PODIntervalTreeTest, RandomDeletionAndInsertionRegressionTest3) +{ + // This is the sequence of insertions and deletions that triggered + // the failure in RandomDeletionAndInsertionRegressionTest2. + PODIntervalTree<int> tree; + tree.add(tree.createInterval(0, 5)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(4, 5)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(8, 9)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(1, 4)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(3, 5)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(4, 12)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(0, 2)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(0, 2)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(9, 13)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(0, 1)); + ASSERT_TRUE(tree.checkInvariants()); + tree.remove(tree.createInterval(0, 2)); + ASSERT_TRUE(tree.checkInvariants()); + tree.remove(tree.createInterval(9, 13)); + ASSERT_TRUE(tree.checkInvariants()); + tree.remove(tree.createInterval(0, 2)); + ASSERT_TRUE(tree.checkInvariants()); + tree.remove(tree.createInterval(0, 1)); + ASSERT_TRUE(tree.checkInvariants()); + tree.remove(tree.createInterval(4, 5)); + ASSERT_TRUE(tree.checkInvariants()); + tree.remove(tree.createInterval(4, 12)); + ASSERT_TRUE(tree.checkInvariants()); +} + +TEST(PODIntervalTreeTest, RandomDeletionAndInsertionRegressionTest4) +{ + // Even further reduced test case for RandomDeletionAndInsertionRegressionTest3. + PODIntervalTree<int> tree; + tree.add(tree.createInterval(0, 5)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(8, 9)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(1, 4)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(3, 5)); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(tree.createInterval(4, 12)); + ASSERT_TRUE(tree.checkInvariants()); + tree.remove(tree.createInterval(4, 12)); + ASSERT_TRUE(tree.checkInvariants()); +} + +TEST(PODIntervalTreeTest, TestRandomDeletionAndInsertion) +{ + InsertionAndDeletionTest(generateSeed(), 1000); +} + +} // namespace WebCore diff --git a/WebKit/chromium/tests/PODRedBlackTreeTest.cpp b/WebKit/chromium/tests/PODRedBlackTreeTest.cpp new file mode 100644 index 0000000..0cc10e7 --- /dev/null +++ b/WebKit/chromium/tests/PODRedBlackTreeTest.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: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS 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 APPLE OR ITS 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. + */ + +// Tests for the red-black tree class. + +#include "config.h" + +#include "PODRedBlackTree.h" + +#include "ArenaTestHelpers.h" +#include "TreeTestHelpers.h" +#include <gtest/gtest.h> +#include <wtf/Vector.h> + +namespace WebCore { + +using ArenaTestHelpers::TrackedAllocator; +using TreeTestHelpers::generateSeed; +using TreeTestHelpers::initRandom; +using TreeTestHelpers::nextRandom; + +TEST(PODRedBlackTreeTest, TestTreeAllocatesFromArena) +{ + RefPtr<TrackedAllocator> allocator = TrackedAllocator::create(); + { + RefPtr<PODArena> arena = PODArena::create(allocator); + PODRedBlackTree<int> tree(arena); + int numAdditions = 2 * PODArena::DefaultChunkSize / sizeof(int); + for (int i = 0; i < numAdditions; ++i) + tree.add(i); + EXPECT_GT(allocator->numRegions(), 1); + } + EXPECT_EQ(allocator->numRegions(), 0); +} + +TEST(PODRedBlackTreeTest, TestSingleElementInsertion) +{ + PODRedBlackTree<int> tree; + tree.add(5); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(5)); +} + +TEST(PODRedBlackTreeTest, TestMultipleElementInsertion) +{ + PODRedBlackTree<int> tree; + tree.add(4); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(4)); + tree.add(3); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(3)); + tree.add(5); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(5)); + EXPECT_TRUE(tree.contains(4)); + EXPECT_TRUE(tree.contains(3)); +} + +TEST(PODRedBlackTreeTest, TestDuplicateElementInsertion) +{ + PODRedBlackTree<int> tree; + tree.add(3); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(3); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(3); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_EQ(3, tree.size()); + EXPECT_TRUE(tree.contains(3)); +} + +TEST(PODRedBlackTreeTest, TestSingleElementInsertionAndDeletion) +{ + PODRedBlackTree<int> tree; + tree.add(5); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(5)); + tree.remove(5); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_FALSE(tree.contains(5)); +} + +TEST(PODRedBlackTreeTest, TestMultipleElementInsertionAndDeletion) +{ + PODRedBlackTree<int> tree; + tree.add(4); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(4)); + tree.add(3); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(3)); + tree.add(5); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(5)); + EXPECT_TRUE(tree.contains(4)); + EXPECT_TRUE(tree.contains(3)); + tree.remove(4); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(3)); + EXPECT_FALSE(tree.contains(4)); + EXPECT_TRUE(tree.contains(5)); + tree.remove(5); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_TRUE(tree.contains(3)); + EXPECT_FALSE(tree.contains(4)); + EXPECT_FALSE(tree.contains(5)); + EXPECT_EQ(1, tree.size()); +} + +TEST(PODRedBlackTreeTest, TestDuplicateElementInsertionAndDeletion) +{ + PODRedBlackTree<int> tree; + tree.add(3); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(3); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(3); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_EQ(3, tree.size()); + EXPECT_TRUE(tree.contains(3)); + tree.remove(3); + ASSERT_TRUE(tree.checkInvariants()); + tree.remove(3); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_EQ(1, tree.size()); + EXPECT_TRUE(tree.contains(3)); + tree.remove(3); + ASSERT_TRUE(tree.checkInvariants()); + EXPECT_EQ(0, tree.size()); + EXPECT_FALSE(tree.contains(3)); +} + +TEST(PODRedBlackTreeTest, FailingInsertionRegressionTest1) +{ + // These numbers came from a previously-failing randomized test run. + PODRedBlackTree<int> tree; + tree.add(5113); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(4517); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(3373); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(9307); + ASSERT_TRUE(tree.checkInvariants()); + tree.add(7077); + ASSERT_TRUE(tree.checkInvariants()); +} + +namespace { +void InsertionAndDeletionTest(const int32_t seed, const int treeSize) +{ + initRandom(seed); + const int maximumValue = treeSize; + // Build the tree. + PODRedBlackTree<int> tree; + Vector<int> values; + for (int i = 0; i < treeSize; i++) { + int value = nextRandom(maximumValue); + tree.add(value); + ASSERT_TRUE(tree.checkInvariants()) << "Test failed for seed " << seed; + values.append(value); + } + // Churn the tree's contents. + for (int i = 0; i < treeSize; i++) { + // Pick a random value to remove. + int index = nextRandom(treeSize); + int value = values[index]; + // Remove this value. + tree.remove(value); + ASSERT_TRUE(tree.checkInvariants()) << "Test failed for seed " << seed; + // Replace it with a new one. + value = nextRandom(maximumValue); + values[index] = value; + tree.add(value); + ASSERT_TRUE(tree.checkInvariants()) << "Test failed for seed " << seed; + } +} +} // anonymous namespace + +TEST(PODRedBlackTreeTest, RandomDeletionAndInsertionRegressionTest1) +{ + InsertionAndDeletionTest(12311, 100); +} + +TEST(PODRedBlackTreeTest, TestRandomDeletionAndInsertion) +{ + InsertionAndDeletionTest(generateSeed(), 100); +} + +} // namespace WebCore diff --git a/WebKit/chromium/tests/PopupMenuTest.cpp b/WebKit/chromium/tests/PopupMenuTest.cpp new file mode 100644 index 0000000..b68980f --- /dev/null +++ b/WebKit/chromium/tests/PopupMenuTest.cpp @@ -0,0 +1,377 @@ +/* + * 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 "Color.h" +#include "KeyboardCodes.h" +#include "PopupMenu.h" +#include "PopupMenuClient.h" +#include "PopupMenuChromium.h" +#include "WebFrameClient.h" +#include "WebFrameImpl.h" +#include "WebInputEvent.h" +#include "WebPopupMenuImpl.h" +#include "WebScreenInfo.h" +#include "WebViewClient.h" +#include "WebViewImpl.h" + +using namespace WebCore; +using namespace WebKit; + +namespace { + +class TestPopupMenuClient : public PopupMenuClient { +public: + // Item at index 0 is selected by default. + TestPopupMenuClient() : m_selectIndex(0) { } + virtual ~TestPopupMenuClient() {} + virtual void valueChanged(unsigned listIndex, bool fireEvents = true) + { + m_selectIndex = listIndex; + } + virtual void selectionChanged(unsigned, bool) {} + virtual void selectionCleared() {} + + virtual String itemText(unsigned listIndex) const + { + String str("Item "); + str.append(String::number(listIndex)); + return str; + } + virtual String itemLabel(unsigned) const { return String(); } + virtual String itemIcon(unsigned) const { return String(); } + virtual String itemToolTip(unsigned listIndex) const { return itemText(listIndex); } + virtual String itemAccessibilityText(unsigned listIndex) const { return itemText(listIndex); } + virtual bool itemIsEnabled(unsigned listIndex) const { return true; } + virtual PopupMenuStyle itemStyle(unsigned listIndex) const + { + Font font(FontPlatformData(12.0, false, false), false); + return PopupMenuStyle(Color::black, Color::white, font, true, false, Length(), TextDirection()); + } + virtual PopupMenuStyle menuStyle() const { return itemStyle(0); } + virtual int clientInsetLeft() const { return 0; } + virtual int clientInsetRight() const { return 0; } + virtual int clientPaddingLeft() const { return 0; } + virtual int clientPaddingRight() const { return 0; } + virtual int listSize() const { return 10; } + virtual int selectedIndex() const { return m_selectIndex; } + virtual void popupDidHide() { } + virtual bool itemIsSeparator(unsigned listIndex) const { return false; } + virtual bool itemIsLabel(unsigned listIndex) const { return false; } + virtual bool itemIsSelected(unsigned listIndex) const { return listIndex == m_selectIndex; } + virtual bool shouldPopOver() const { return false; } + virtual bool valueShouldChangeOnHotTrack() const { return false; } + virtual void setTextFromItem(unsigned listIndex) { } + + virtual FontSelector* fontSelector() const { return 0; } + virtual HostWindow* hostWindow() const { return 0; } + + virtual PassRefPtr<Scrollbar> createScrollbar(ScrollbarClient*, ScrollbarOrientation, ScrollbarControlSize) { return 0; } + +private: + unsigned m_selectIndex; +}; + +class TestWebWidgetClient : public WebWidgetClient { +public: + ~TestWebWidgetClient() { } +}; + +class TestWebPopupMenuImpl : public WebPopupMenuImpl { +public: + static PassRefPtr<TestWebPopupMenuImpl> create(WebWidgetClient* client) + { + return adoptRef(new TestWebPopupMenuImpl(client)); + } + + ~TestWebPopupMenuImpl() { } + +private: + TestWebPopupMenuImpl(WebWidgetClient* client) : WebPopupMenuImpl(client) { } +}; + +class TestWebWidget : public WebWidget { +public: + virtual ~TestWebWidget() { } + virtual void close() { } + virtual WebSize size() { return WebSize(100, 100); } + virtual void resize(const WebSize&) { } + virtual void layout() { } + virtual void paint(WebCanvas*, const WebRect&) { } + virtual void themeChanged() { } + virtual void composite(bool finish) { } + virtual bool handleInputEvent(const WebInputEvent&) { return true; } + virtual void mouseCaptureLost() { } + virtual void setFocus(bool) { } + virtual bool setComposition( + const WebString& text, + const WebVector<WebCompositionUnderline>& underlines, + int selectionStart, + int selectionEnd) { return true; } + virtual bool confirmComposition() { return true; } + virtual WebTextInputType textInputType() { return WebKit::WebTextInputTypeNone; } + virtual WebRect caretOrSelectionBounds() { return WebRect(); } + virtual void setTextDirection(WebTextDirection) { } +}; + +class TestWebViewClient : public WebViewClient { +public: + TestWebViewClient() : m_webPopupMenu(TestWebPopupMenuImpl::create(&m_webWidgetClient)) { } + ~TestWebViewClient() { } + + virtual WebWidget* createPopupMenu(WebPopupType) { return m_webPopupMenu.get(); } + + // We need to override this so that the popup menu size is not 0 + // (the layout code checks to see if the popup fits on the screen). + virtual WebScreenInfo screenInfo() + { + WebScreenInfo screenInfo; + screenInfo.availableRect.height = 2000; + screenInfo.availableRect.width = 2000; + return screenInfo; + } + +private: + TestWebWidgetClient m_webWidgetClient; + RefPtr<TestWebPopupMenuImpl> m_webPopupMenu; +}; + +class TestWebFrameClient : public WebFrameClient { +public: + ~TestWebFrameClient() { } +}; + +class SelectPopupMenuTest : public testing::Test { +public: + SelectPopupMenuTest() + { + } + +protected: + virtual void SetUp() + { + m_webView = static_cast<WebViewImpl*>(WebView::create(&m_webviewClient, 0)); + m_webView->initializeMainFrame(&m_webFrameClient); + m_popupMenu = adoptRef(new PopupMenuChromium(&m_popupMenuClient)); + } + + virtual void TearDown() + { + m_popupMenu = 0; + m_webView->close(); + } + + // Returns true if there currently is a select popup in the WebView. + bool popupOpen() const { return m_webView->selectPopup(); } + + int selectedIndex() const { return m_popupMenuClient.selectedIndex(); } + + void showPopup() + { + m_popupMenu->show(IntRect(0, 0, 100, 100), + static_cast<WebFrameImpl*>(m_webView->mainFrame())->frameView(), 0); + ASSERT_TRUE(popupOpen()); + EXPECT_TRUE(m_webView->selectPopup()->popupType() == PopupContainer::Select); + } + + void hidePopup() + { + m_popupMenu->hide(); + EXPECT_FALSE(popupOpen()); + } + + void simulateKeyDownEvent(int keyCode) + { + simulateKeyEvent(WebInputEvent::RawKeyDown, keyCode); + } + + void simulateKeyUpEvent(int keyCode) + { + simulateKeyEvent(WebInputEvent::KeyUp, keyCode); + } + + // Simulates a key event on the WebView. + // The WebView forwards the event to the select popup if one is open. + void simulateKeyEvent(WebInputEvent::Type eventType, int keyCode) + { + WebKeyboardEvent keyEvent; + keyEvent.windowsKeyCode = keyCode; + keyEvent.type = eventType; + m_webView->handleInputEvent(keyEvent); + } + + // Simulates a mouse event on the select popup. + void simulateLeftMouseDownEvent(const IntPoint& point) + { + PlatformMouseEvent mouseEvent(point, point, LeftButton, MouseEventPressed, + 1, false, false, false, false, 0); + m_webView->selectPopup()->handleMouseDownEvent(mouseEvent); + } + void simulateLeftMouseUpEvent(const IntPoint& point) + { + PlatformMouseEvent mouseEvent(point, point, LeftButton, MouseEventReleased, + 1, false, false, false, false, 0); + m_webView->selectPopup()->handleMouseReleaseEvent(mouseEvent); + } + +protected: + TestWebViewClient m_webviewClient; + WebViewImpl* m_webView; + TestWebFrameClient m_webFrameClient; + TestPopupMenuClient m_popupMenuClient; + RefPtr<PopupMenu> m_popupMenu; +}; + +// Tests that show/hide and repeats. Select popups are reused in web pages when +// they are reopened, that what this is testing. +TEST_F(SelectPopupMenuTest, ShowThenHide) +{ + for (int i = 0; i < 3; i++) { + showPopup(); + hidePopup(); + } +} + +// Tests that showing a select popup and deleting it does not cause problem. +// This happens in real-life if a page navigates while a select popup is showing. +TEST_F(SelectPopupMenuTest, ShowThenDelete) +{ + showPopup(); + // Nothing else to do, TearDown() deletes the popup. +} + +// Tests that losing focus closes the select popup. +TEST_F(SelectPopupMenuTest, ShowThenLoseFocus) +{ + showPopup(); + // Simulate losing focus. + m_webView->setFocus(false); + + // Popup should have closed. + EXPECT_FALSE(popupOpen()); +} + +// Tests that pressing ESC closes the popup. +TEST_F(SelectPopupMenuTest, ShowThenPressESC) +{ + showPopup(); + simulateKeyDownEvent(VKEY_ESCAPE); + // Popup should have closed. + EXPECT_FALSE(popupOpen()); +} + +// Tests selecting an item with the arrows and enter/esc/tab. +TEST_F(SelectPopupMenuTest, SelectWithKeys) +{ + showPopup(); + // Simulate selecting the 2nd item by pressing Down, Down, enter. + simulateKeyDownEvent(VKEY_DOWN); + simulateKeyDownEvent(VKEY_DOWN); + simulateKeyDownEvent(VKEY_RETURN); + + // Popup should have closed. + EXPECT_TRUE(!popupOpen()); + EXPECT_EQ(2, selectedIndex()); + + // It should work as well with ESC. + showPopup(); + simulateKeyDownEvent(VKEY_DOWN); + simulateKeyDownEvent(VKEY_ESCAPE); + EXPECT_FALSE(popupOpen()); + EXPECT_EQ(3, selectedIndex()); + + // It should work as well with TAB. + showPopup(); + simulateKeyDownEvent(VKEY_DOWN); + simulateKeyDownEvent(VKEY_TAB); + EXPECT_FALSE(popupOpen()); + EXPECT_EQ(4, selectedIndex()); +} + +// Tests that selecting an item with the mouse does select the item and close +// the popup. +TEST_F(SelectPopupMenuTest, ClickItem) +{ + showPopup(); + + // Y of 18 to be on the item at index 1 (12 font plus border and more to be safe). + IntPoint row1Point(2, 18); + // Simulate a click down/up on the first item. + simulateLeftMouseDownEvent(row1Point); + simulateLeftMouseUpEvent(row1Point); + + // Popup should have closed and the item at index 1 selected. + EXPECT_FALSE(popupOpen()); + EXPECT_EQ(1, selectedIndex()); +} + +// Tests that moving the mouse over an item and then clicking outside the select popup +// leaves the seleted item unchanged. +TEST_F(SelectPopupMenuTest, MouseOverItemClickOutside) +{ + showPopup(); + + // Y of 18 to be on the item at index 1 (12 font plus border and more to be safe). + IntPoint row1Point(2, 18); + // Simulate the mouse moving over the first item. + PlatformMouseEvent mouseEvent(row1Point, row1Point, NoButton, MouseEventMoved, + 1, false, false, false, false, 0); + m_webView->selectPopup()->handleMouseMoveEvent(mouseEvent); + + // Click outside the popup. + simulateLeftMouseDownEvent(IntPoint(1000, 1000)); + + // Popup should have closed and item 0 should still be selected. + EXPECT_FALSE(popupOpen()); + EXPECT_EQ(0, selectedIndex()); +} + +// Tests that selecting an item with the keyboard and then clicking outside the select +// popup does select that item. +TEST_F(SelectPopupMenuTest, SelectItemWithKeyboardItemClickOutside) +{ + showPopup(); + + // Simulate selecting the 2nd item by pressing Down, Down. + simulateKeyDownEvent(VKEY_DOWN); + simulateKeyDownEvent(VKEY_DOWN); + + // Click outside the popup. + simulateLeftMouseDownEvent(IntPoint(1000, 1000)); + + // Popup should have closed and the item should have been selected. + EXPECT_FALSE(popupOpen()); + EXPECT_EQ(2, selectedIndex()); +} + +} // namespace diff --git a/WebKit/chromium/tests/RunAllTests.cpp b/WebKit/chromium/tests/RunAllTests.cpp index 0f3f82f..b213de7 100644 --- a/WebKit/chromium/tests/RunAllTests.cpp +++ b/WebKit/chromium/tests/RunAllTests.cpp @@ -33,18 +33,27 @@ #include "WebKit.h" #include "WebKitClient.h" +#include <webkit/support/webkit_support.h> -// WebKitClient has a protected destructor, so we need to subclass. -class DummyWebKitClient : public WebKit::WebKitClient { -}; +#if defined(WIN32) && defined(WEBKIT_DLL_UNITTEST) +#include "WebUnitTests.h" +#endif int main(int argc, char** argv) { - DummyWebKitClient dummyClient; - WebKit::initialize(&dummyClient); + TestSuite testSuite(argc, argv); + // TestSuite must be created before SetUpTestEnvironment so it performs + // initializations needed by WebKit support. + webkit_support::SetUpTestEnvironmentForUnitTests(); - int result = TestSuite(argc, argv).Run(); +#if defined(WIN32) && defined(WEBKIT_DLL_UNITTEST) + // For chromium multi-dll build, need to call webkit api to create a + // TestSuite instance in webkit.dll and run all tests from there. + int result = WebKit::RunAllUnitTests(argc, argv); +#else + int result = testSuite.Run(); +#endif - WebKit::shutdown(); + webkit_support::TearDownTestEnvironment(); return result; } diff --git a/WebKit/chromium/tests/TilingDataTest.cpp b/WebKit/chromium/tests/TilingDataTest.cpp new file mode 100755 index 0000000..ec18f01 --- /dev/null +++ b/WebKit/chromium/tests/TilingDataTest.cpp @@ -0,0 +1,334 @@ +/* + * 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 "TilingData.h" + +#include <gtest/gtest.h> + +using namespace WebCore; + +namespace { + +TEST(TilingDataTest, numTiles_NoTiling) +{ + EXPECT_EQ(1, TilingData(16, 16, 16, false).numTiles()); + EXPECT_EQ(1, TilingData(16, 15, 15, true).numTiles()); + EXPECT_EQ(1, TilingData(16, 16, 16, true).numTiles()); + EXPECT_EQ(1, TilingData(16, 1, 16, false).numTiles()); + EXPECT_EQ(1, TilingData(15, 15, 15, true).numTiles()); +} + +TEST(TilingDataTest, numTiles_TilingNoBorders) +{ + EXPECT_EQ(1, TilingData(4, 1, 4, false).numTiles()); + EXPECT_EQ(1, TilingData(4, 2, 4, false).numTiles()); + EXPECT_EQ(1, TilingData(4, 3, 4, false).numTiles()); + EXPECT_EQ(1, TilingData(4, 4, 4, false).numTiles()); + EXPECT_EQ(2, TilingData(4, 5, 4, false).numTiles()); + EXPECT_EQ(2, TilingData(4, 6, 4, false).numTiles()); + EXPECT_EQ(2, TilingData(4, 7, 4, false).numTiles()); + EXPECT_EQ(2, TilingData(4, 8, 4, false).numTiles()); + EXPECT_EQ(3, TilingData(4, 9, 4, false).numTiles()); + EXPECT_EQ(3, TilingData(4, 10, 4, false).numTiles()); + EXPECT_EQ(3, TilingData(4, 11, 4, false).numTiles()); + + EXPECT_EQ(1, TilingData(5, 1, 5, false).numTiles()); + EXPECT_EQ(1, TilingData(5, 2, 5, false).numTiles()); + EXPECT_EQ(1, TilingData(5, 3, 5, false).numTiles()); + EXPECT_EQ(1, TilingData(5, 4, 5, false).numTiles()); + EXPECT_EQ(1, TilingData(5, 5, 5, false).numTiles()); + EXPECT_EQ(2, TilingData(5, 6, 5, false).numTiles()); + EXPECT_EQ(2, TilingData(5, 7, 5, false).numTiles()); + EXPECT_EQ(2, TilingData(5, 8, 5, false).numTiles()); + EXPECT_EQ(2, TilingData(5, 9, 5, false).numTiles()); + EXPECT_EQ(2, TilingData(5, 10, 5, false).numTiles()); + EXPECT_EQ(3, TilingData(5, 11, 5, false).numTiles()); + + EXPECT_EQ(1, TilingData(16, 16, 16, false).numTiles()); + EXPECT_EQ(1, TilingData(17, 16, 16, false).numTiles()); + EXPECT_EQ(4, TilingData(15, 16, 16, false).numTiles()); + EXPECT_EQ(4, TilingData(8, 16, 16, false).numTiles()); + EXPECT_EQ(6, TilingData(8, 17, 16, false).numTiles()); +} + +TEST(TilingDataTest, numTiles_TilingWithBorders) +{ + EXPECT_EQ(1, TilingData(3, 1, 3, true).numTiles()); + EXPECT_EQ(1, TilingData(3, 2, 3, true).numTiles()); + EXPECT_EQ(1, TilingData(3, 3, 3, true).numTiles()); + EXPECT_EQ(2, TilingData(3, 4, 3, true).numTiles()); + EXPECT_EQ(3, TilingData(3, 5, 3, true).numTiles()); + EXPECT_EQ(4, TilingData(3, 6, 3, true).numTiles()); + EXPECT_EQ(5, TilingData(3, 7, 3, true).numTiles()); + + EXPECT_EQ(1, TilingData(4, 1, 4, true).numTiles()); + EXPECT_EQ(1, TilingData(4, 2, 4, true).numTiles()); + EXPECT_EQ(1, TilingData(4, 3, 4, true).numTiles()); + EXPECT_EQ(1, TilingData(4, 4, 4, true).numTiles()); + EXPECT_EQ(2, TilingData(4, 5, 4, true).numTiles()); + EXPECT_EQ(2, TilingData(4, 6, 4, true).numTiles()); + EXPECT_EQ(3, TilingData(4, 7, 4, true).numTiles()); + EXPECT_EQ(3, TilingData(4, 8, 4, true).numTiles()); + EXPECT_EQ(4, TilingData(4, 9, 4, true).numTiles()); + EXPECT_EQ(4, TilingData(4, 10, 4, true).numTiles()); + EXPECT_EQ(5, TilingData(4, 11, 4, true).numTiles()); + + EXPECT_EQ(1, TilingData(5, 1, 5, true).numTiles()); + EXPECT_EQ(1, TilingData(5, 2, 5, true).numTiles()); + EXPECT_EQ(1, TilingData(5, 3, 5, true).numTiles()); + EXPECT_EQ(1, TilingData(5, 4, 5, true).numTiles()); + EXPECT_EQ(1, TilingData(5, 5, 5, true).numTiles()); + EXPECT_EQ(2, TilingData(5, 6, 5, true).numTiles()); + EXPECT_EQ(2, TilingData(5, 7, 5, true).numTiles()); + EXPECT_EQ(2, TilingData(5, 8, 5, true).numTiles()); + EXPECT_EQ(3, TilingData(5, 9, 5, true).numTiles()); + EXPECT_EQ(3, TilingData(5, 10, 5, true).numTiles()); + EXPECT_EQ(3, TilingData(5, 11, 5, true).numTiles()); +} + +TEST(TilingDataTest, tileXIndexFromSrcCoord) +{ + EXPECT_EQ(0, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(0)); + EXPECT_EQ(0, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(1)); + EXPECT_EQ(0, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(2)); + EXPECT_EQ(1, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(3)); + EXPECT_EQ(1, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(4)); + EXPECT_EQ(1, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(5)); + EXPECT_EQ(2, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(6)); + EXPECT_EQ(2, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(7)); + EXPECT_EQ(2, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(8)); + EXPECT_EQ(3, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(9)); + EXPECT_EQ(3, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(10)); + EXPECT_EQ(3, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(11)); + + EXPECT_EQ(0, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(0)); + EXPECT_EQ(0, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(1)); + EXPECT_EQ(1, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(2)); + EXPECT_EQ(2, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(3)); + EXPECT_EQ(3, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(4)); + EXPECT_EQ(4, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(5)); + EXPECT_EQ(5, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(6)); + EXPECT_EQ(6, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(7)); + EXPECT_EQ(7, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(8)); + EXPECT_EQ(7, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(9)); + EXPECT_EQ(7, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(10)); + EXPECT_EQ(7, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(11)); +} +TEST(TilingDataTest, tileYIndexFromSrcCoord) +{ + EXPECT_EQ(0, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(0)); + EXPECT_EQ(0, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(1)); + EXPECT_EQ(0, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(2)); + EXPECT_EQ(1, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(3)); + EXPECT_EQ(1, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(4)); + EXPECT_EQ(1, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(5)); + EXPECT_EQ(2, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(6)); + EXPECT_EQ(2, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(7)); + EXPECT_EQ(2, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(8)); + EXPECT_EQ(3, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(9)); + EXPECT_EQ(3, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(10)); + EXPECT_EQ(3, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(11)); + + EXPECT_EQ(0, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(0)); + EXPECT_EQ(0, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(1)); + EXPECT_EQ(1, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(2)); + EXPECT_EQ(2, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(3)); + EXPECT_EQ(3, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(4)); + EXPECT_EQ(4, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(5)); + EXPECT_EQ(5, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(6)); + EXPECT_EQ(6, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(7)); + EXPECT_EQ(7, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(8)); + EXPECT_EQ(7, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(9)); + EXPECT_EQ(7, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(10)); + EXPECT_EQ(7, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(11)); +} + +TEST(TilingDataTest, tileSizeX) +{ + EXPECT_EQ(5, TilingData(5, 5, 5, false).tileSizeX(0)); + EXPECT_EQ(5, TilingData(5, 5, 5, true).tileSizeX(0)); + + EXPECT_EQ(5, TilingData(5, 6, 6, false).tileSizeX(0)); + EXPECT_EQ(1, TilingData(5, 6, 6, false).tileSizeX(1)); + EXPECT_EQ(4, TilingData(5, 6, 6, true).tileSizeX(0)); + EXPECT_EQ(2, TilingData(5, 6, 6, true).tileSizeX(1)); + + EXPECT_EQ(5, TilingData(5, 8, 8, false).tileSizeX(0)); + EXPECT_EQ(3, TilingData(5, 8, 8, false).tileSizeX(1)); + EXPECT_EQ(4, TilingData(5, 8, 8, true).tileSizeX(0)); + EXPECT_EQ(4, TilingData(5, 8, 8, true).tileSizeX(1)); + + EXPECT_EQ(5, TilingData(5, 10, 10, false).tileSizeX(0)); + EXPECT_EQ(5, TilingData(5, 10, 10, false).tileSizeX(1)); + EXPECT_EQ(4, TilingData(5, 10, 10, true).tileSizeX(0)); + EXPECT_EQ(3, TilingData(5, 10, 10, true).tileSizeX(1)); + EXPECT_EQ(3, TilingData(5, 10, 10, true).tileSizeX(2)); + + EXPECT_EQ(4, TilingData(5, 11, 11, true).tileSizeX(2)); + EXPECT_EQ(3, TilingData(5, 12, 12, true).tileSizeX(2)); +} +TEST(TilingDataTest, tileSizeY) +{ + EXPECT_EQ(5, TilingData(5, 5, 5, false).tileSizeY(0)); + EXPECT_EQ(5, TilingData(5, 5, 5, true).tileSizeY(0)); + + EXPECT_EQ(5, TilingData(5, 6, 6, false).tileSizeY(0)); + EXPECT_EQ(1, TilingData(5, 6, 6, false).tileSizeY(1)); + EXPECT_EQ(4, TilingData(5, 6, 6, true).tileSizeY(0)); + EXPECT_EQ(2, TilingData(5, 6, 6, true).tileSizeY(1)); + + EXPECT_EQ(5, TilingData(5, 8, 8, false).tileSizeY(0)); + EXPECT_EQ(3, TilingData(5, 8, 8, false).tileSizeY(1)); + EXPECT_EQ(4, TilingData(5, 8, 8, true).tileSizeY(0)); + EXPECT_EQ(4, TilingData(5, 8, 8, true).tileSizeY(1)); + + EXPECT_EQ(5, TilingData(5, 10, 10, false).tileSizeY(0)); + EXPECT_EQ(5, TilingData(5, 10, 10, false).tileSizeY(1)); + EXPECT_EQ(4, TilingData(5, 10, 10, true).tileSizeY(0)); + EXPECT_EQ(3, TilingData(5, 10, 10, true).tileSizeY(1)); + EXPECT_EQ(3, TilingData(5, 10, 10, true).tileSizeY(2)); + + EXPECT_EQ(4, TilingData(5, 11, 11, true).tileSizeY(2)); + EXPECT_EQ(3, TilingData(5, 12, 12, true).tileSizeY(2)); +} + +TEST(TilingDataTest, tileSizeX_and_tilePositionX) +{ + // Single tile cases: + EXPECT_EQ(1, TilingData(3, 1, 1, false).tileSizeX(0)); + EXPECT_EQ(0, TilingData(3, 1, 1, false).tilePositionX(0)); + EXPECT_EQ(1, TilingData(3, 1, 100, false).tileSizeX(0)); + EXPECT_EQ(0, TilingData(3, 1, 100, false).tilePositionX(0)); + EXPECT_EQ(3, TilingData(3, 3, 1, false).tileSizeX(0)); + EXPECT_EQ(0, TilingData(3, 3, 1, false).tilePositionX(0)); + EXPECT_EQ(3, TilingData(3, 3, 100, false).tileSizeX(0)); + EXPECT_EQ(0, TilingData(3, 3, 100, false).tilePositionX(0)); + EXPECT_EQ(1, TilingData(3, 1, 1, true).tileSizeX(0)); + EXPECT_EQ(0, TilingData(3, 1, 1, true).tilePositionX(0)); + EXPECT_EQ(1, TilingData(3, 1, 100, true).tileSizeX(0)); + EXPECT_EQ(0, TilingData(3, 1, 100, true).tilePositionX(0)); + EXPECT_EQ(3, TilingData(3, 3, 1, true).tileSizeX(0)); + EXPECT_EQ(0, TilingData(3, 3, 1, true).tilePositionX(0)); + EXPECT_EQ(3, TilingData(3, 3, 100, true).tileSizeX(0)); + EXPECT_EQ(0, TilingData(3, 3, 100, true).tilePositionX(0)); + + // Multiple tiles: + // no border + // positions 0, 3 + EXPECT_EQ(2, TilingData(3, 6, 1, false).numTiles()); + EXPECT_EQ(3, TilingData(3, 6, 1, false).tileSizeX(0)); + EXPECT_EQ(3, TilingData(3, 6, 1, false).tileSizeX(1)); + EXPECT_EQ(0, TilingData(3, 6, 1, false).tilePositionX(0)); + EXPECT_EQ(3, TilingData(3, 6, 1, false).tilePositionX(1)); + EXPECT_EQ(3, TilingData(3, 6, 100, false).tileSizeX(0)); + EXPECT_EQ(3, TilingData(3, 6, 100, false).tileSizeX(1)); + EXPECT_EQ(0, TilingData(3, 6, 100, false).tilePositionX(0)); + EXPECT_EQ(3, TilingData(3, 6, 100, false).tilePositionX(1)); + + // Multiple tiles: + // with border + // positions 0, 2, 3, 4 + EXPECT_EQ(4, TilingData(3, 6, 1, true).numTiles()); + EXPECT_EQ(2, TilingData(3, 6, 1, true).tileSizeX(0)); + EXPECT_EQ(1, TilingData(3, 6, 1, true).tileSizeX(1)); + EXPECT_EQ(1, TilingData(3, 6, 1, true).tileSizeX(2)); + EXPECT_EQ(2, TilingData(3, 6, 1, true).tileSizeX(3)); + EXPECT_EQ(0, TilingData(3, 6, 1, true).tilePositionX(0)); + EXPECT_EQ(2, TilingData(3, 6, 1, true).tilePositionX(1)); + EXPECT_EQ(3, TilingData(3, 6, 1, true).tilePositionX(2)); + EXPECT_EQ(4, TilingData(3, 6, 1, true).tilePositionX(3)); + EXPECT_EQ(2, TilingData(3, 6, 100, true).tileSizeX(0)); + EXPECT_EQ(1, TilingData(3, 6, 100, true).tileSizeX(1)); + EXPECT_EQ(1, TilingData(3, 6, 100, true).tileSizeX(2)); + EXPECT_EQ(2, TilingData(3, 6, 100, true).tileSizeX(3)); + EXPECT_EQ(0, TilingData(3, 6, 100, true).tilePositionX(0)); + EXPECT_EQ(2, TilingData(3, 6, 100, true).tilePositionX(1)); + EXPECT_EQ(3, TilingData(3, 6, 100, true).tilePositionX(2)); + EXPECT_EQ(4, TilingData(3, 6, 100, true).tilePositionX(3)); +} + +TEST(TilingDataTest, tileSizeY_and_tilePositionY) +{ + // Single tile cases: + EXPECT_EQ(1, TilingData(3, 1, 1, false).tileSizeY(0)); + EXPECT_EQ(0, TilingData(3, 1, 1, false).tilePositionY(0)); + EXPECT_EQ(1, TilingData(3, 100, 1, false).tileSizeY(0)); + EXPECT_EQ(0, TilingData(3, 100, 1, false).tilePositionY(0)); + EXPECT_EQ(3, TilingData(3, 1, 3, false).tileSizeY(0)); + EXPECT_EQ(0, TilingData(3, 1, 3, false).tilePositionY(0)); + EXPECT_EQ(3, TilingData(3, 100, 3, false).tileSizeY(0)); + EXPECT_EQ(0, TilingData(3, 100, 3, false).tilePositionY(0)); + EXPECT_EQ(1, TilingData(3, 1, 1, true).tileSizeY(0)); + EXPECT_EQ(0, TilingData(3, 1, 1, true).tilePositionY(0)); + EXPECT_EQ(1, TilingData(3, 100, 1, true).tileSizeY(0)); + EXPECT_EQ(0, TilingData(3, 100, 1, true).tilePositionY(0)); + EXPECT_EQ(3, TilingData(3, 1, 3, true).tileSizeY(0)); + EXPECT_EQ(0, TilingData(3, 1, 3, true).tilePositionY(0)); + EXPECT_EQ(3, TilingData(3, 100, 3, true).tileSizeY(0)); + EXPECT_EQ(0, TilingData(3, 100, 3, true).tilePositionY(0)); + + // Multiple tiles: + // no border + // positions 0, 3 + EXPECT_EQ(2, TilingData(3, 1, 6, false).numTiles()); + EXPECT_EQ(3, TilingData(3, 1, 6, false).tileSizeY(0)); + EXPECT_EQ(3, TilingData(3, 1, 6, false).tileSizeY(1)); + EXPECT_EQ(0, TilingData(3, 1, 6, false).tilePositionY(0)); + EXPECT_EQ(3, TilingData(3, 1, 6, false).tilePositionY(1)); + EXPECT_EQ(3, TilingData(3, 100, 6, false).tileSizeY(0)); + EXPECT_EQ(3, TilingData(3, 100, 6, false).tileSizeY(1)); + EXPECT_EQ(0, TilingData(3, 100, 6, false).tilePositionY(0)); + EXPECT_EQ(3, TilingData(3, 100, 6, false).tilePositionY(1)); + + // Multiple tiles: + // with border + // positions 0, 2, 3, 4 + EXPECT_EQ(4, TilingData(3, 1, 6, true).numTiles()); + EXPECT_EQ(2, TilingData(3, 1, 6, true).tileSizeY(0)); + EXPECT_EQ(1, TilingData(3, 1, 6, true).tileSizeY(1)); + EXPECT_EQ(1, TilingData(3, 1, 6, true).tileSizeY(2)); + EXPECT_EQ(2, TilingData(3, 1, 6, true).tileSizeY(3)); + EXPECT_EQ(0, TilingData(3, 1, 6, true).tilePositionY(0)); + EXPECT_EQ(2, TilingData(3, 1, 6, true).tilePositionY(1)); + EXPECT_EQ(3, TilingData(3, 1, 6, true).tilePositionY(2)); + EXPECT_EQ(4, TilingData(3, 1, 6, true).tilePositionY(3)); + EXPECT_EQ(2, TilingData(3, 100, 6, true).tileSizeY(0)); + EXPECT_EQ(1, TilingData(3, 100, 6, true).tileSizeY(1)); + EXPECT_EQ(1, TilingData(3, 100, 6, true).tileSizeY(2)); + EXPECT_EQ(2, TilingData(3, 100, 6, true).tileSizeY(3)); + EXPECT_EQ(0, TilingData(3, 100, 6, true).tilePositionY(0)); + EXPECT_EQ(2, TilingData(3, 100, 6, true).tilePositionY(1)); + EXPECT_EQ(3, TilingData(3, 100, 6, true).tilePositionY(2)); + EXPECT_EQ(4, TilingData(3, 100, 6, true).tilePositionY(3)); +} + +} // namespace diff --git a/WebKit/chromium/tests/TransparencyWinTest.cpp b/WebKit/chromium/tests/TransparencyWinTest.cpp index b83c2a9..ed7f12f 100644 --- a/WebKit/chromium/tests/TransparencyWinTest.cpp +++ b/WebKit/chromium/tests/TransparencyWinTest.cpp @@ -103,7 +103,7 @@ static std::ostream& operator<<(std::ostream& out, const Color& c) TEST(TransparencyWin, NoLayer) { - OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(17, 16), DeviceRGB)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(17, 16), ColorSpaceDeviceRGB)); // KeepTransform { @@ -142,7 +142,7 @@ TEST(TransparencyWin, NoLayer) TEST(TransparencyWin, WhiteLayer) { - OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); // KeepTransform { @@ -194,7 +194,7 @@ TEST(TransparencyWin, WhiteLayer) TEST(TransparencyWin, TextComposite) { - OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); // KeepTransform is the only valid transform mode for TextComposite. { @@ -213,7 +213,7 @@ TEST(TransparencyWin, TextComposite) TEST(TransparencyWin, OpaqueCompositeLayer) { - OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); // KeepTransform { @@ -283,7 +283,7 @@ TEST(TransparencyWin, OpaqueCompositeLayer) 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)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); { TransparencyWin helper; @@ -312,13 +312,13 @@ TEST(TransparencyWin, OpaqueCompositeLayerPixel) 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)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); FloatRect fullRect(0, 0, 16, 16); - src->context()->fillRect(fullRect, red, DeviceColorSpace); + src->context()->fillRect(fullRect, red, ColorSpaceDeviceRGB); src->context()->beginTransparencyLayer(0.5); FloatRect rightHalf(8, 0, 8, 16); - src->context()->fillRect(rightHalf, green, DeviceColorSpace); + src->context()->fillRect(rightHalf, green, ColorSpaceDeviceRGB); // Make a transparency layer inset by one pixel, and fill it inset by // another pixel with 50% black. @@ -330,7 +330,7 @@ TEST(TransparencyWin, OpaqueCompositeLayerPixel) IntRect(1, 1, 14, 14)); FloatRect inner(2, 2, 12, 12); - helper.context()->fillRect(inner, Color(0x7f000000), DeviceColorSpace); + helper.context()->fillRect(inner, Color(0x7f000000), ColorSpaceDeviceRGB); // 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 @@ -365,10 +365,10 @@ TEST(TransparencyWin, OpaqueCompositeLayerPixel) TEST(TransparencyWin, TranslateOpaqueCompositeLayer) { // Fill with white. - OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); Color white(0xFFFFFFFF); FloatRect fullRect(0, 0, 16, 16); - src->context()->fillRect(fullRect, white, DeviceColorSpace); + src->context()->fillRect(fullRect, white, ColorSpaceDeviceRGB); // Scroll down by 8 (coordinate system goes up). src->context()->save(); @@ -388,7 +388,7 @@ TEST(TransparencyWin, TranslateOpaqueCompositeLayer) // 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.context()->fillRect(bottomRight, green, ColorSpaceDeviceRGB); helper.composite(); } @@ -402,12 +402,12 @@ TEST(TransparencyWin, TranslateOpaqueCompositeLayer) // tests that the propert transform is applied to the copied layer. TEST(TransparencyWin, RotateOpaqueCompositeLayer) { - OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); // The background is white. Color white(0xFFFFFFFF); FloatRect fullRect(0, 0, 16, 16); - src->context()->fillRect(fullRect, white, DeviceColorSpace); + src->context()->fillRect(fullRect, white, ColorSpaceDeviceRGB); // Rotate the image by 90 degrees. This matrix is the same as // cw90.rotate(90); but avoids rounding errors. Rounding errors can cause @@ -425,7 +425,7 @@ TEST(TransparencyWin, RotateOpaqueCompositeLayer) src->context()->beginTransparencyLayer(0.5); FloatRect blackRect(0, -9, 16, 2); Color black(0xFF000000); - src->context()->fillRect(blackRect, black, DeviceColorSpace); + src->context()->fillRect(blackRect, black, ColorSpaceDeviceRGB); // Now draw 50% red square. { @@ -439,7 +439,7 @@ TEST(TransparencyWin, RotateOpaqueCompositeLayer) IntRect(1, -15, 14, 14)); // Fill with red. - helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000), DeviceColorSpace); + helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000), ColorSpaceDeviceRGB); clearTopLayerAlphaChannel(helper.context()); helper.composite(); } @@ -481,15 +481,15 @@ TEST(TransparencyWin, RotateOpaqueCompositeLayer) TEST(TransparencyWin, TranslateScaleOpaqueCompositeLayer) { - OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); // 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); + src->context()->fillRect(topRect, white, ColorSpaceDeviceRGB); Color red(0xFFFF0000); FloatRect bottomRect(0, 8, 16, 8); - src->context()->fillRect(bottomRect, red, DeviceColorSpace); + src->context()->fillRect(bottomRect, red, ColorSpaceDeviceRGB); src->context()->save(); @@ -519,7 +519,7 @@ TEST(TransparencyWin, TranslateScaleOpaqueCompositeLayer) IntRect(1, -15, 14, 14)); // Fill with red. - helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000), DeviceColorSpace); + helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000), ColorSpaceDeviceRGB); clearTopLayerAlphaChannel(helper.context()); helper.composite(); } @@ -529,9 +529,9 @@ TEST(TransparencyWin, TranslateScaleOpaqueCompositeLayer) TEST(TransparencyWin, Scale) { // Create an opaque white buffer. - OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); FloatRect fullBuffer(0, 0, 16, 16); - src->context()->fillRect(fullBuffer, Color::white, DeviceColorSpace); + src->context()->fillRect(fullBuffer, Color::white, ColorSpaceDeviceRGB); // Scale by 2x. src->context()->save(); @@ -584,15 +584,15 @@ TEST(TransparencyWin, Scale) TEST(TransparencyWin, ScaleTransparency) { // Create an opaque white buffer. - OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); FloatRect fullBuffer(0, 0, 16, 16); - src->context()->fillRect(fullBuffer, Color::white, DeviceColorSpace); + src->context()->fillRect(fullBuffer, Color::white, ColorSpaceDeviceRGB); // 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); + src->context()->fillRect(topHalf, Color(0xFFFF0000), ColorSpaceDeviceRGB); // Scale by 2x. src->context()->save(); @@ -609,7 +609,7 @@ TEST(TransparencyWin, ScaleTransparency) TransparencyWin::ScaleTransform, IntRect(1, 1, 6, 6)); - helper.context()->fillRect(helper.drawRect(), Color(0x7f000000), DeviceColorSpace); + helper.context()->fillRect(helper.drawRect(), Color(0x7f000000), ColorSpaceDeviceRGB); clearTopLayerAlphaChannel(helper.context()); helper.composite(); } @@ -642,7 +642,7 @@ TEST(TransparencyWin, ScaleTransparency) TEST(TransparencyWin, Text) { - OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), ColorSpaceDeviceRGB)); // Our text should end up 50% transparent blue-green. Color fullResult(0x80008080); @@ -658,21 +658,21 @@ TEST(TransparencyWin, Text) // 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); + helper.context()->fillRect(pixel, 0xFFFF0000, ColorSpaceDeviceRGB); pixel.move(1.0f, 0.0f); - helper.context()->fillRect(pixel, 0xFF00FF00, DeviceColorSpace); + helper.context()->fillRect(pixel, 0xFF00FF00, ColorSpaceDeviceRGB); pixel.move(1.0f, 0.0f); - helper.context()->fillRect(pixel, 0xFF0000FF, DeviceColorSpace); + helper.context()->fillRect(pixel, 0xFF0000FF, ColorSpaceDeviceRGB); pixel.move(1.0f, 0.0f); - helper.context()->fillRect(pixel, 0xFF008080, DeviceColorSpace); + helper.context()->fillRect(pixel, 0xFF008080, ColorSpaceDeviceRGB); pixel.move(1.0f, 0.0f); - helper.context()->fillRect(pixel, 0xFF800080, DeviceColorSpace); + helper.context()->fillRect(pixel, 0xFF800080, ColorSpaceDeviceRGB); pixel.move(1.0f, 0.0f); - helper.context()->fillRect(pixel, 0xFF808000, DeviceColorSpace); + helper.context()->fillRect(pixel, 0xFF808000, ColorSpaceDeviceRGB); // Try one with 100% coverage (opaque black). pixel.move(1.0f, 0.0f); - helper.context()->fillRect(pixel, 0xFF000000, DeviceColorSpace); + helper.context()->fillRect(pixel, 0xFF000000, ColorSpaceDeviceRGB); // Now mess with the alpha channel. clearTopLayerAlphaChannel(helper.context()); diff --git a/WebKit/chromium/tests/TreeTestHelpers.cpp b/WebKit/chromium/tests/TreeTestHelpers.cpp new file mode 100644 index 0000000..103b871 --- /dev/null +++ b/WebKit/chromium/tests/TreeTestHelpers.cpp @@ -0,0 +1,60 @@ +/* + * 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: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS 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 APPLE OR ITS 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 "TreeTestHelpers.h" + +#include <cstdlib> +#include <wtf/CurrentTime.h> + +namespace WebCore { +namespace TreeTestHelpers { + +int32_t generateSeed() +{ + // A seed of 1 has the special behavior of resetting the random + // number generator. Assume that if we call this routine that we + // don't want this behavior. + int32_t seed; + do { + seed = static_cast<int32_t>(currentTime()); + } while (seed <= 1); + return seed; +} + +void initRandom(const int32_t seed) +{ + srand(seed); +} + +int32_t nextRandom(const int32_t maximumValue) +{ + // rand_r is not available on Windows + return rand() % maximumValue; +} + +} // namespace TreeTestHelpers +} // namespace WebCore diff --git a/WebKit/chromium/tests/TreeTestHelpers.h b/WebKit/chromium/tests/TreeTestHelpers.h new file mode 100644 index 0000000..af07b2a --- /dev/null +++ b/WebKit/chromium/tests/TreeTestHelpers.h @@ -0,0 +1,53 @@ +/* + * 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: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS 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 APPLE OR ITS 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. + */ + +// Simple pseudorandom number generator helper functions, used by the +// red-black and interval tree tests. +// +// These are **not** thread safe! + +#ifndef TreeTestHelpers_h +#define TreeTestHelpers_h + +#include <stdint.h> + +namespace WebCore { +namespace TreeTestHelpers { + +// Generates a seed value to be passed to initRandom(). +int32_t generateSeed(); + +// Initializes the pseudo-random number generator with a specific seed. +void initRandom(const int32_t seed); + +// Produces the next pseudo-random number in the sequence, in the +// range from [0..maximumValue). Negative numbers are not allowed and will +// produce undefined results. +int32_t nextRandom(const int32_t maximumValue); + +} // namespace TreeTestHelpers +} // namespace WebCore + +#endif // TreeTestHelpers_h diff --git a/WebKit/chromium/tests/WebFrameTest.cpp b/WebKit/chromium/tests/WebFrameTest.cpp new file mode 100644 index 0000000..cf91cb4 --- /dev/null +++ b/WebKit/chromium/tests/WebFrameTest.cpp @@ -0,0 +1,112 @@ +/* + * 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 <googleurl/src/gurl.h> +#include <gtest/gtest.h> +#include <webkit/support/webkit_support.h> +#include "WebFrame.h" +#include "WebFrameClient.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebURLRequest.h" +#include "WebURLResponse.h" +#include "WebView.h" + +using namespace WebKit; + +namespace { + +class WebFrameTest : public testing::Test { +public: + WebFrameTest() {} + + virtual void TearDown() + { + webkit_support::UnregisterAllMockedURLs(); + } + + void registerMockedURLLoad(const WebURL& url, const WebURLResponse& response, const WebString& fileName) + { + std::string filePath = webkit_support::GetWebKitRootDir().utf8(); + filePath.append("/WebKit/chromium/tests/data/"); + filePath.append(fileName.utf8()); + webkit_support::RegisterMockedURL(url, response, WebString::fromUTF8(filePath)); + } + + void serveRequests() + { + webkit_support::ServeAsynchronousMockedRequests(); + } +}; + +class TestWebFrameClient : public WebFrameClient { +}; + +TEST_F(WebFrameTest, ContentText) +{ + // Register our resources. + WebURLResponse response; + response.initialize(); + response.setMIMEType("text/html"); + std::string rootURL = "http://www.test.com/"; + const char* files[] = { "iframes_test.html", "visible_iframe.html", + "invisible_iframe.html", "zero_sized_iframe.html" }; + for (int i = 0; i < (sizeof(files) / sizeof(char*)); ++i) { + WebURL webURL = GURL(rootURL + files[i]); + registerMockedURLLoad(webURL, response, WebString::fromUTF8(files[i])); + } + + // Create and initialize the WebView. + TestWebFrameClient webFrameClient; + WebView* webView = WebView::create(0, 0); + webView->initializeMainFrame(&webFrameClient); + + // Load the main frame URL. + WebURL testURL(GURL(rootURL + files[0])); + WebURLRequest urlRequest; + urlRequest.initialize(); + urlRequest.setURL(testURL); + webView->mainFrame()->loadRequest(urlRequest); + + // Load all pending asynchronous requests. + serveRequests(); + + // Now retrieve the frames text and test it only includes visible elements. + std::string content = webView->mainFrame()->contentAsText(1024).utf8(); + EXPECT_NE(std::string::npos, content.find(" visible paragraph")); + EXPECT_NE(std::string::npos, content.find(" visible iframe")); + EXPECT_EQ(std::string::npos, content.find(" invisible pararaph")); + EXPECT_EQ(std::string::npos, content.find(" invisible iframe")); + EXPECT_EQ(std::string::npos, content.find("iframe with zero size")); + + webView->close(); +} + +} diff --git a/WebKit/chromium/tests/WebInputEventFactoryTestGtk.cpp b/WebKit/chromium/tests/WebInputEventFactoryTestGtk.cpp new file mode 100644 index 0000000..7cd4837 --- /dev/null +++ b/WebKit/chromium/tests/WebInputEventFactoryTestGtk.cpp @@ -0,0 +1,112 @@ +/* + * 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 <gdk/gdk.h> +#include <gtest/gtest.h> + +#include "WebInputEvent.h" +#include "WebInputEventFactory.h" + +using WebKit::WebMouseEvent; +using WebKit::WebInputEventFactory; + +namespace { + +TEST(WebInputEventFactoryTest, DoubleClick) +{ + GdkEventButton firstClick; + firstClick.type = GDK_BUTTON_PRESS; + firstClick.window = static_cast<GdkWindow*>(GINT_TO_POINTER(1)); + firstClick.x = firstClick.y = firstClick.x_root = firstClick.y_root = 100; + firstClick.state = 0; + firstClick.time = 0; + firstClick.button = 1; + + // Single click works. + WebMouseEvent firstClickEvent = WebInputEventFactory::mouseEvent(&firstClick); + EXPECT_EQ(1, firstClickEvent.clickCount); + + // Make sure double click works. + GdkEventButton secondClick = firstClick; + secondClick.time = firstClick.time + 100; + WebMouseEvent secondClickEvent = WebInputEventFactory::mouseEvent(&secondClick); + EXPECT_EQ(2, secondClickEvent.clickCount); + + // Reset the click count. + firstClick.time += 10000; + firstClickEvent = WebInputEventFactory::mouseEvent(&firstClick); + EXPECT_EQ(1, firstClickEvent.clickCount); + + // Two clicks with a long gap in between aren't counted as a double click. + secondClick = firstClick; + secondClick.time = firstClick.time + 1000; + secondClickEvent = WebInputEventFactory::mouseEvent(&secondClick); + EXPECT_EQ(1, secondClickEvent.clickCount); + + // Reset the click count. + firstClick.time += 10000; + firstClickEvent = WebInputEventFactory::mouseEvent(&firstClick); + EXPECT_EQ(1, firstClickEvent.clickCount); + + // Two clicks far apart (horizontally) aren't counted as a double click. + secondClick = firstClick; + secondClick.time = firstClick.time + 1; + secondClick.x = firstClick.x + 100; + secondClickEvent = WebInputEventFactory::mouseEvent(&secondClick); + EXPECT_EQ(1, secondClickEvent.clickCount); + + // Reset the click count. + firstClick.time += 10000; + firstClickEvent = WebInputEventFactory::mouseEvent(&firstClick); + EXPECT_EQ(1, firstClickEvent.clickCount); + + // Two clicks far apart (vertically) aren't counted as a double click. + secondClick = firstClick; + secondClick.time = firstClick.time + 1; + secondClick.x = firstClick.y + 100; + secondClickEvent = WebInputEventFactory::mouseEvent(&secondClick); + EXPECT_EQ(1, secondClickEvent.clickCount); + + // Reset the click count. + firstClick.time += 10000; + firstClickEvent = WebInputEventFactory::mouseEvent(&firstClick); + EXPECT_EQ(1, firstClickEvent.clickCount); + + // Two clicks on different windows aren't a double click. + secondClick = firstClick; + secondClick.time = firstClick.time + 1; + secondClick.window = static_cast<GdkWindow*>(GINT_TO_POINTER(2)); + secondClickEvent = WebInputEventFactory::mouseEvent(&secondClick); + EXPECT_EQ(1, secondClickEvent.clickCount); +} + +} // anonymous namespace diff --git a/WebKit/chromium/tests/WebUnitTests.cpp b/WebKit/chromium/tests/WebUnitTests.cpp new file mode 100644 index 0000000..5e207f3 --- /dev/null +++ b/WebKit/chromium/tests/WebUnitTests.cpp @@ -0,0 +1,44 @@ +/* + * 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 "WebUnitTests.h" + +#include <base/test/test_suite.h> + +namespace WebKit { + +int RunAllUnitTests(int argc, char** argv) +{ + TestSuite testSuite(argc, argv); + return testSuite.Run(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/tests/WebUnitTests.h b/WebKit/chromium/tests/WebUnitTests.h new file mode 100644 index 0000000..3add1c2 --- /dev/null +++ b/WebKit/chromium/tests/WebUnitTests.h @@ -0,0 +1,44 @@ +/* + * 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. + */ + +#ifndef WebUnitTests_h +#define WebUnitTests_h + +#include "WebCommon.h" + +namespace WebKit { + +// In chromium multi-dll build, webkit unittest code are compiled in webkit.dll. +// This is the API to run all unittests inside webkit.dll. +WEBKIT_API int RunAllUnitTests(int argc, char** argv); + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/tests/data/iframes_test.html b/WebKit/chromium/tests/data/iframes_test.html new file mode 100644 index 0000000..425709b --- /dev/null +++ b/WebKit/chromium/tests/data/iframes_test.html @@ -0,0 +1,9 @@ +<html> + <body> + <iframe src="visible_iframe.html"></iframe> + <iframe width=0 height=0 src="zero_sized_iframe.html"></iframe> + <iframe style="visibility:hidden;" src="invisible_iframe.html"></iframe> + <p>This is a visible paragraph.</p> + <p style="visibility:hidden;">This is an invisible paragraph.</p> + </body> +</html> diff --git a/WebKit/chromium/tests/data/invisible_iframe.html b/WebKit/chromium/tests/data/invisible_iframe.html new file mode 100644 index 0000000..e5686c7 --- /dev/null +++ b/WebKit/chromium/tests/data/invisible_iframe.html @@ -0,0 +1,5 @@ +<html> + <body> + This is an invisible frame. + </body> +</html> diff --git a/WebKit/chromium/tests/data/visible_iframe.html b/WebKit/chromium/tests/data/visible_iframe.html new file mode 100644 index 0000000..291af3d --- /dev/null +++ b/WebKit/chromium/tests/data/visible_iframe.html @@ -0,0 +1,5 @@ +<html> + <body> + This is a visible iframe. + </body> +</html> diff --git a/WebKit/chromium/tests/data/zero_sized_iframe.html b/WebKit/chromium/tests/data/zero_sized_iframe.html new file mode 100644 index 0000000..6728cab --- /dev/null +++ b/WebKit/chromium/tests/data/zero_sized_iframe.html @@ -0,0 +1,5 @@ +<html> + <body> + This is an iframe with zero size. + </body> +</html> |