Changeset 86602 in webkit


Ignore:
Timestamp:
May 16, 2011 1:28:20 PM (13 years ago)
Author:
weinig@apple.com
Message:

2011-05-16 Sam Weinig <​sam@webkit.org>

Reviewed by David Levin.

Convert api tester over to using gtest expectations directly
​https://bugs.webkit.org/show_bug.cgi?id=60862

  • TestWebKitAPI/PlatformUtilities.cpp: (TestWebKitAPI::Util::toSTD):
  • TestWebKitAPI/PlatformUtilities.h: (TestWebKitAPI::Util::assertWKStrigEqual): Add convenience macro to compare WK2 strings. Add some overloads of toSTD to make the implementation of the macro simpler.
  • TestWebKitAPI/Test.h: Remove TEST_ASSERT forwarder.

[Test changes elided]

Location:
trunk/Tools
Files:
30 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r86598 r86602  
     12011-05-16  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by David Levin.
     4
     5        Convert api tester over to using gtest expectations directly
     6        https://bugs.webkit.org/show_bug.cgi?id=60862
     7
     8        * TestWebKitAPI/PlatformUtilities.cpp:
     9        (TestWebKitAPI::Util::toSTD):
     10        * TestWebKitAPI/PlatformUtilities.h:
     11        (TestWebKitAPI::Util::assertWKStrigEqual):
     12        Add convenience macro to compare WK2 strings. Add some overloads of toSTD to make
     13        the implementation of the macro simpler.
     14
     15        * TestWebKitAPI/Test.h:
     16        Remove TEST_ASSERT forwarder.
     17
     18        [Test changes elided]
     19
    1202011-05-16  David Kilzer  <ddkilzer@apple.com>
    221

  • trunk/Tools/TestWebKitAPI/JavaScriptTest.cpp

    r80358 r86602  
    4444static void javaScriptCallback(WKSerializedScriptValueRef resultSerializedScriptValue, WKErrorRef error, void* ctx)
    4545{
    46     TEST_ASSERT(resultSerializedScriptValue);
     46    ASSERT_NOT_NULL(resultSerializedScriptValue);
    4747
    4848    JavaScriptCallbackContext* context = static_cast<JavaScriptCallbackContext*>(ctx);
    4949
    5050    JSGlobalContextRef scriptContext = JSGlobalContextCreate(0);
    51     TEST_ASSERT(scriptContext);
     51    ASSERT_NOT_NULL(scriptContext);
    5252
    5353    JSValueRef scriptValue = WKSerializedScriptValueDeserialize(resultSerializedScriptValue, scriptContext, 0);
    54     TEST_ASSERT(scriptValue);
     54    ASSERT_NOT_NULL(scriptValue);
    5555
    5656    JSStringRef scriptString = JSValueToStringCopy(scriptContext, scriptValue, 0);
    57     TEST_ASSERT(scriptString);
     57    ASSERT_NOT_NULL(scriptString);
    5858
    5959    context->didFinish = true;
    … …  
    6363    JSGlobalContextRelease(scriptContext);
    6464
    65     TEST_ASSERT(!error);
    66 }
    67 
    68 static WKRetainPtr<WKStringRef> wk(const char* utf8String)
    69 {
    70     return WKRetainPtr<WKStringRef>(AdoptWK, WKStringCreateWithUTF8CString(utf8String));
     65    EXPECT_NULL(error);
    7166}
    7267
    … …  
    7469{
    7570    JavaScriptCallbackContext context(expectedResult);
    76     WKPageRunJavaScriptInMainFrame(page, wk(script).get(), &context, javaScriptCallback);
     71    WKPageRunJavaScriptInMainFrame(page, Util::toWK(script).get(), &context, javaScriptCallback);
    7772    Util::run(&context.didFinish);
    7873    return context.didMatchExpectedString;

  • trunk/Tools/TestWebKitAPI/PlatformUtilities.cpp

    r73336 r86602  
    5959}
    6060
     61std::string toSTD(WKRetainPtr<WKStringRef> string)
     62{
     63    return toSTD(string.get());
     64}
     65
     66std::string toSTD(const char* string)
     67{
     68    return std::string(string);
     69}
     70
    6171WKRetainPtr<WKStringRef> toWK(const char* utf8String)
    6272{

  • trunk/Tools/TestWebKitAPI/PlatformUtilities.h

    r83633 r86602  
    2727#define PlatformUtilities_h
    2828
     29#include <WebKit2/WKRetainPtr.h>
    2930#include <WebKit2/WebKit2.h>
    30 #include <WebKit2/WKRetainPtr.h>
     31#include <gtest/gtest.h>
     32#include <string>
    3133#include <wtf/Platform.h>
    32 #include <string>
    3334
    3435namespace TestWebKitAPI {
    … …  
    5354bool isKeyDown(WKNativeEventPtr);
    5455
    55 std::string toSTD(WKStringRef string);
     56std::string toSTD(WKStringRef);
     57std::string toSTD(WKRetainPtr<WKStringRef>);
     58std::string toSTD(const char*);
     59
    5660WKRetainPtr<WKStringRef> toWK(const char* utf8String);
     61
     62template<typename T, typename U>
     63static inline ::testing::AssertionResult assertWKStrigEqual(const char* expected_expression, const char* actual_expression, T expected, U actual)
     64{
     65    return ::testing::internal::CmpHelperSTREQ(expected_expression, actual_expression, Util::toSTD(expected).c_str(), Util::toSTD(actual).c_str());
     66}
     67
     68#define EXPECT_WK_STREQ(expected, actual) \
     69    EXPECT_PRED_FORMAT2(TestWebKitAPI::Util::assertWKStrigEqual, expected, actual)
    5770
    5871} // namespace Util

  • trunk/Tools/TestWebKitAPI/Test.h

    r86287 r86602  
    2727#define Test_h
    2828
    29 #include "TestsController.h"
    30 
    3129#include <gtest/gtest.h>
    3230
    3331namespace TestWebKitAPI {
    3432
    35 #define TEST_ASSERT(expression) EXPECT_TRUE(expression)
     33#define EXPECT_NOT_NULL(expression) \
     34    EXPECT_TRUE(expression)
     35
     36#define EXPECT_NULL(expression) \
     37    EXPECT_TRUE(!(expression))
     38
     39#define ASSERT_NOT_NULL(expression) \
     40    ASSERT_TRUE(expression)
     41
     42#define ASSERT_NULL(expression) \
     43    ASSERT_TRUE(!(expression))
     44
    3645#define TEST_ASSERT_RETURN(expression, returnValue) \
    3746    do { \

  • trunk/Tools/TestWebKitAPI/Tests/WTF/VectorBasic.cpp

    r86287 r86602  
    3333{
    3434    Vector<int> intVector;
    35     ASSERT_TRUE(intVector.isEmpty());
    36     ASSERT_EQ(0ul, intVector.size());
    37     ASSERT_EQ(0ul, intVector.capacity());
     35    EXPECT_TRUE(intVector.isEmpty());
     36    EXPECT_EQ(0ul, intVector.size());
     37    EXPECT_EQ(0ul, intVector.capacity());
    3838}
    3939

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/AboutBlankLoad.cpp

    r82730 r86602  
    3636static void decidePolicyForResponse(WKPageRef, WKFrameRef, WKURLResponseRef response, WKURLRequestRef, WKFramePolicyListenerRef listener, WKTypeRef, const void*)
    3737{
    38     TEST_ASSERT(WKStringIsEqualToUTF8CString(Util::MIMETypeForWKURLResponse(response).get(), "text/html"));
     38    EXPECT_WK_STREQ("text/html", Util::MIMETypeForWKURLResponse(response));
    3939
    4040    WKFramePolicyListenerUse(listener);

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/CanHandleRequest.cpp

    r82730 r86602  
    4040    didReceiveMessage = true;
    4141
    42     TEST_ASSERT(WKStringIsEqualToUTF8CString(messageName, "DidCheckCanHandleRequest"));
    43     TEST_ASSERT(WKGetTypeID(body) == WKBooleanGetTypeID());
     42    EXPECT_WK_STREQ("DidCheckCanHandleRequest", messageName);
     43    EXPECT_EQ(WKBooleanGetTypeID(), WKGetTypeID(body));
     44
    4445    canHandleRequest = WKBooleanGetValue(static_cast<WKBooleanRef>(body));
    4546}
    … …  
    6768    WKContextPostMessageToInjectedBundle(context.get(), Util::toWK("CheckCanHandleRequest").get(), 0);
    6869    Util::run(&didReceiveMessage);
    69     TEST_ASSERT(canHandleRequest);
     70    EXPECT_TRUE(canHandleRequest);
    7071}
    7172

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/CookieManager.cpp

    r82730 r86602  
    4242static void didGetTestHTTPCookieAcceptPolicy(WKHTTPCookieAcceptPolicy policy, WKErrorRef, void* context)
    4343{
    44     TEST_ASSERT(context == reinterpret_cast<void*>(0x1234578));
    45     TEST_ASSERT(policy == testPolicy);
     44    EXPECT_EQ(reinterpret_cast<void*>(0x1234578), context);
     45    EXPECT_EQ(testPolicy, policy);
     46
    4647    WKCookieManagerRef cookieManager = WKContextGetCookieManager(wkContext.get());
    4748    WKCookieManagerSetHTTPCookieAcceptPolicy(cookieManager, userPolicy);
    … …  
    5253static void didGetUserHTTPCookieAcceptPolicy(WKHTTPCookieAcceptPolicy policy, WKErrorRef, void* context)
    5354{
    54     TEST_ASSERT(context == reinterpret_cast<void*>(0x1234578));
     55    EXPECT_EQ(reinterpret_cast<void*>(0x1234578), context);
    5556
    5657    userPolicy = policy;

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/DocumentStartUserScriptAlertCrash.cpp

    r73965 r86602  
    3737static void runJavaScriptAlert(WKPageRef page, WKStringRef alertText, WKFrameRef frame, const void* clientInfo)
    3838{
    39     TEST_ASSERT(frame);
    40     TEST_ASSERT(WKFrameGetPage(frame) == page);
    41     TEST_ASSERT(WKStringIsEqualToUTF8CString(alertText, "an alert"));
     39    ASSERT_NOT_NULL(frame);
     40
     41    EXPECT_EQ(page, WKFrameGetPage(frame));
     42    EXPECT_WK_STREQ("an alert", alertText);
    4243
    4344    done = true;

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/EvaluateJavaScript.cpp

    r80358 r86602  
    3939static void didRunJavaScript(WKSerializedScriptValueRef resultSerializedScriptValue, WKErrorRef error, void* context)
    4040{
    41     TEST_ASSERT(context == reinterpret_cast<void*>(0x1234578));
    42     TEST_ASSERT(!resultSerializedScriptValue);
     41    EXPECT_EQ(reinterpret_cast<void*>(0x1234578), context);
     42    EXPECT_NULL(resultSerializedScriptValue);
    4343
    4444    // FIXME: We should also check the error, but right now it's always null.
    4545    // Assert that it's null so we can revisit when this changes.
    46     TEST_ASSERT(!error);
     46    EXPECT_NULL(error);
    4747
    4848    testDone = true;

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/FailedLoad.cpp

    r73965 r86602  
    3939static void didFailProvisionalLoadWithErrorForFrame(WKPageRef page, WKFrameRef frame, WKErrorRef error, WKTypeRef userData, const void* clientInfo)
    4040{
    41     TEST_ASSERT(WKFrameGetFrameLoadState(frame) == kWKFrameLoadStateFinished);
     41    EXPECT_EQ(kWKFrameLoadStateFinished, WKFrameGetFrameLoadState(frame));
    4242
    4343    WKURLRef url = WKFrameCopyProvisionalURL(frame);
    44     TEST_ASSERT(!url);
     44    EXPECT_NULL(url);
    4545
    4646    testDone = true;

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/Find.cpp

    r73965 r86602  
    4343static void didCountStringMatches(WKPageRef page, WKStringRef string, unsigned numMatches, const void* clientInfo)
    4444{
    45     TEST_ASSERT(WKStringIsEqualToUTF8CString(string, "Hello"));
    46     TEST_ASSERT(numMatches == 3);
     45    EXPECT_WK_STREQ("Hello", string);
     46    EXPECT_EQ(3u, numMatches);
    4747
    4848    didCallCountStringMatches = true;

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/ForceRepaint.cpp

    r78729 r86602  
    3838void didForceRepaint(WKErrorRef error, void*)
    3939{
    40     TEST_ASSERT(!error);
     40    EXPECT_NULL(error);
    4141    test2Done = true;
    4242}

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/FrameMIMETypeHTML.cpp

    r73965 r86602  
    3737static void didStartProvisionalLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
    3838{
    39     WKRetainPtr<WKStringRef> wkMIME(AdoptWK, WKFrameCopyMIMEType(frame));
    40     TEST_ASSERT(WKStringIsEmpty(wkMIME.get()));
     39    WKRetainPtr<WKStringRef> wkMIME = adoptWK(WKFrameCopyMIMEType(frame));
     40    EXPECT_TRUE(WKStringIsEmpty(wkMIME.get()));
    4141}
    4242
    4343static void didCommitLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
    4444{
    45     WKRetainPtr<WKStringRef> wkMIME(AdoptWK, WKFrameCopyMIMEType(frame));
    46     TEST_ASSERT(WKStringIsEqualToUTF8CString(wkMIME.get(), "text/html"));
     45    WKRetainPtr<WKStringRef> wkMIME = adoptWK(WKFrameCopyMIMEType(frame));
     46    EXPECT_WK_STREQ("text/html", wkMIME);
    4747}
    4848
    4949static void didFinishLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
    5050{
    51     WKRetainPtr<WKStringRef> wkMIME(AdoptWK, WKFrameCopyMIMEType(frame));
    52     TEST_ASSERT(WKStringIsEqualToUTF8CString(wkMIME.get(), "text/html"));
     51    WKRetainPtr<WKStringRef> wkMIME = adoptWK(WKFrameCopyMIMEType(frame));
     52    EXPECT_WK_STREQ("text/html", wkMIME);
    5353
    5454    testDone = true;

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/FrameMIMETypePNG.cpp

    r73965 r86602  
    3737static void didStartProvisionalLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
    3838{
    39     WKRetainPtr<WKStringRef> wkMIME(AdoptWK, WKFrameCopyMIMEType(frame));
    40     TEST_ASSERT(WKStringIsEmpty(wkMIME.get()));
     39    WKRetainPtr<WKStringRef> wkMIME = adoptWK(WKFrameCopyMIMEType(frame));
     40    EXPECT_TRUE(WKStringIsEmpty(wkMIME.get()));
    4141}
    4242
    4343static void didCommitLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
    4444{
    45     WKRetainPtr<WKStringRef> wkMIME(AdoptWK, WKFrameCopyMIMEType(frame));
    46     TEST_ASSERT(WKStringIsEqualToUTF8CString(wkMIME.get(), "image/png"));
     45    WKRetainPtr<WKStringRef> wkMIME = adoptWK(WKFrameCopyMIMEType(frame));
     46    EXPECT_WK_STREQ("image/png", wkMIME);
    4747}
    4848
    4949static void didFinishLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
    5050{
    51     WKRetainPtr<WKStringRef> wkMIME(AdoptWK, WKFrameCopyMIMEType(frame));
    52     TEST_ASSERT(WKStringIsEqualToUTF8CString(wkMIME.get(), "image/png"));
     51    WKRetainPtr<WKStringRef> wkMIME = adoptWK(WKFrameCopyMIMEType(frame));
     52    EXPECT_WK_STREQ("image/png", wkMIME);
    5353
    5454    testDone = true;

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/InjectedBundleBasic_Bundle.cpp

    r70194 r86602  
    3939    virtual void didCreatePage(WKBundleRef bundle, WKBundlePageRef page)
    4040    {
    41         WKRetainPtr<WKStringRef> doneMessageName(AdoptWK, WKStringCreateWithUTF8CString("DoneMessageName"));
    42         WKRetainPtr<WKStringRef> doneMessageBody(AdoptWK, WKStringCreateWithUTF8CString("DoneMessageBody"));
     41        WKRetainPtr<WKStringRef> doneMessageName = adoptWK(WKStringCreateWithUTF8CString("DoneMessageName"));
     42        WKRetainPtr<WKStringRef> doneMessageBody = adoptWK(WKStringCreateWithUTF8CString("DoneMessageBody"));
    4343        WKBundlePostMessage(bundle, doneMessageName.get(), doneMessageBody.get());
    4444    }

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/MouseMoveAfterCrash.cpp

    r86354 r86602  
    8484    Util::run(&didFinishLoad);
    8585
    86     TEST_ASSERT(runJSTest(webView.page(), "didMoveMouse()", "false"));
     86    EXPECT_TRUE(runJSTest(webView.page(), "didMoveMouse()", "false"));
    8787
    8888    // Once the page has reloaded, try moving the mouse to verify that we get mouse move events.
    … …  
    9090    webView.simulateMouseMove(20, 20);
    9191
    92     TEST_ASSERT(runJSTest(webView.page(), "didMoveMouse()", "true"));
     92    EXPECT_TRUE(runJSTest(webView.page(), "didMoveMouse()", "true"));
    9393}
    9494

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/PageLoadBasic.cpp

    r80475 r86602  
    5151{
    5252    State* state = reinterpret_cast<State*>(const_cast<void*>(clientInfo));
    53     TEST_ASSERT(state->didDecidePolicyForNavigationAction);
    54     TEST_ASSERT(!state->didCommitLoadForFrame);
     53    EXPECT_TRUE(state->didDecidePolicyForNavigationAction);
     54    EXPECT_FALSE(state->didCommitLoadForFrame);
    5555
    5656    // The commited URL should be null.
    57     TEST_ASSERT(!WKFrameCopyURL(frame));
     57    EXPECT_NULL(WKFrameCopyURL(frame));
    5858
    59     TEST_ASSERT(!state->didStartProvisionalLoadForFrame);
    60 
     59    EXPECT_FALSE(state->didStartProvisionalLoadForFrame);
    6160
    6261    state->didStartProvisionalLoadForFrame = true;
    … …  
    6665{
    6766    State* state = reinterpret_cast<State*>(const_cast<void*>(clientInfo));
    68     TEST_ASSERT(state->didDecidePolicyForNavigationAction);
    69     TEST_ASSERT(state->didStartProvisionalLoadForFrame);
     67    EXPECT_TRUE(state->didDecidePolicyForNavigationAction);
     68    EXPECT_TRUE(state->didStartProvisionalLoadForFrame);
    7069
    7170    // The provisional URL should be null.
    72     TEST_ASSERT(!WKFrameCopyProvisionalURL(frame));
     71    EXPECT_NULL(WKFrameCopyProvisionalURL(frame));
    7372
    7473    state->didCommitLoadForFrame = true;
    … …  
    7877{
    7978    State* state = reinterpret_cast<State*>(const_cast<void*>(clientInfo));
    80     TEST_ASSERT(state->didDecidePolicyForNavigationAction);
    81     TEST_ASSERT(state->didStartProvisionalLoadForFrame);
    82     TEST_ASSERT(state->didCommitLoadForFrame);
     79    EXPECT_TRUE(state->didDecidePolicyForNavigationAction);
     80    EXPECT_TRUE(state->didStartProvisionalLoadForFrame);
     81    EXPECT_TRUE(state->didCommitLoadForFrame);
    8382
    8483    // The provisional URL should be null.
    85     TEST_ASSERT(!WKFrameCopyProvisionalURL(frame));
     84    EXPECT_NULL(WKFrameCopyProvisionalURL(frame));
    8685
    8786    test1Done = true;
    … …  
    9190{
    9291    State* state = reinterpret_cast<State*>(const_cast<void*>(clientInfo));
    93     TEST_ASSERT(!state->didStartProvisionalLoadForFrame);
    94     TEST_ASSERT(!state->didCommitLoadForFrame);
     92    EXPECT_FALSE(state->didStartProvisionalLoadForFrame);
     93    EXPECT_FALSE(state->didCommitLoadForFrame);
    9594
    9695    state->didDecidePolicyForNavigationAction = true;

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/PageLoadDidChangeLocationWithinPageForFrame.cpp

    r82730 r86602  
    4848{
    4949    if (!didPopStateWithinPage) {
    50         TEST_ASSERT(type == kWKSameDocumentNavigationSessionStatePop);
    51         TEST_ASSERT(!didChangeLocationWithinPage);
     50        EXPECT_EQ(type, kWKSameDocumentNavigationSessionStatePop);
     51        EXPECT_FALSE(didChangeLocationWithinPage);
    5252        didPopStateWithinPage = true;
    5353        return;
    5454    }
    5555
    56     TEST_ASSERT(type == kWKSameDocumentNavigationAnchorNavigation);
     56    EXPECT_EQ(kWKSameDocumentNavigationAnchorNavigation, type);
    5757    didChangeLocationWithinPage = true;
    5858}
    … …  
    8080    WKRetainPtr<WKURLRef> urlAfterAnchorClick = adoptWK(WKFrameCopyURL(WKPageGetMainFrame(webView.page())));
    8181
    82     TEST_ASSERT(!WKURLIsEqual(initialURL.get(), urlAfterAnchorClick.get()));
     82    EXPECT_FALSE(WKURLIsEqual(initialURL.get(), urlAfterAnchorClick.get()));
    8383}
    8484

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/PreventEmptyUserAgent.cpp

    r80358 r86602  
    3939static void didRunJavaScript(WKSerializedScriptValueRef resultSerializedScriptValue, WKErrorRef error, void* context)
    4040{
    41     TEST_ASSERT(context == reinterpret_cast<void*>(0x1234578));
    42     TEST_ASSERT(resultSerializedScriptValue);
     41    EXPECT_EQ(reinterpret_cast<void*>(0x1234578), context);
     42    EXPECT_NOT_NULL(resultSerializedScriptValue);
    4343
    4444    JSGlobalContextRef scriptContext = JSGlobalContextCreate(0);
    4545    JSValueRef scriptValue = WKSerializedScriptValueDeserialize(resultSerializedScriptValue, scriptContext, 0);
    46     TEST_ASSERT(JSValueIsString(scriptContext, scriptValue));
     46    EXPECT_TRUE(JSValueIsString(scriptContext, scriptValue));
    4747
    4848    // Make sure that the result of navigator.userAgent isn't empty, even if we set the custom
    4949    // user agent to the empty string.
    5050    JSStringRef scriptString = JSValueToStringCopy(scriptContext, scriptValue, 0);
    51     TEST_ASSERT(JSStringGetLength(scriptString));
     51    EXPECT_GT(JSStringGetLength(scriptString), 0u);
    5252
    5353    JSStringRelease(scriptString);

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/ResponsivenessTimerDoesntFireEarly.cpp

    r82730 r86602  
    3838{
    3939    didBrieflyPause = true;
    40     TEST_ASSERT(WKStringIsEqualToUTF8CString(messageName, "DidBrieflyPause"));
     40    EXPECT_WK_STREQ("DidBrieflyPause", messageName);
    4141}
    4242
    … …  
    9393
    9494    Util::run(&didBrieflyPause);
    95     TEST_ASSERT(!didBecomeUnresponsive);
     95
     96    EXPECT_FALSE(didBecomeUnresponsive);
    9697}
    9798

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/RestoreSessionStateContainingFormData.cpp

    r82730 r86602  
    7676
    7777    WKRetainPtr<WKDataRef> data = createSessionStateContainingFormData(context.get());
    78     TEST_ASSERT(data);
     78    EXPECT_NOT_NULL(data);
    7979
    8080    WKPageRestoreFromSessionState(webView.page(), data.get());
    8181    Util::run(&didFinishLoad);
    8282
    83     TEST_ASSERT(WKPageCanGoBack(webView.page()));
     83    EXPECT_TRUE(WKPageCanGoBack(webView.page()));
    8484}
    8585

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/SpacebarScrolling.cpp

    r77671 r86602  
    6969    Util::run(&didFinishLoad);
    7070
    71     TEST_ASSERT(runJSTest(webView.page(), "isDocumentScrolled()", "false"));
    72     TEST_ASSERT(runJSTest(webView.page(), "textFieldContainsSpace()", "false"));
     71    EXPECT_TRUE(runJSTest(webView.page(), "isDocumentScrolled()", "false"));
     72    EXPECT_TRUE(runJSTest(webView.page(), "textFieldContainsSpace()", "false"));
    7373
    7474    webView.simulateSpacebarKeyPress();
    7575
    76     TEST_ASSERT(runJSTest(webView.page(), "isDocumentScrolled()", "false"));
    77     TEST_ASSERT(runJSTest(webView.page(), "textFieldContainsSpace()", "true"));
     76    EXPECT_TRUE(runJSTest(webView.page(), "isDocumentScrolled()", "false"));
     77    EXPECT_TRUE(runJSTest(webView.page(), "textFieldContainsSpace()", "true"));
    7878
    7979    // On Mac, a key down event represents both a raw key down and a key press. On Windows, a key
    … …  
    8181    // inserts text into the text field). But the raw key down should not be handled.
    8282#if PLATFORM(MAC)
    83     TEST_ASSERT(!didNotHandleKeyDownEvent);
     83    EXPECT_FALSE(didNotHandleKeyDownEvent);
    8484#elif PLATFORM(WIN)
    85     TEST_ASSERT(didNotHandleKeyDownEvent);
     85    EXPECT_TRUE(didNotHandleKeyDownEvent);
    8686#endif
    8787
    88     TEST_ASSERT(runJSTest(webView.page(), "blurTextField()", "undefined"));
     88    EXPECT_TRUE(runJSTest(webView.page(), "blurTextField()", "undefined"));
    8989
    9090    didNotHandleKeyDownEvent = false;
    9191    webView.simulateSpacebarKeyPress();
    9292
    93     TEST_ASSERT(runJSTest(webView.page(), "isDocumentScrolled()", "true"));
    94     TEST_ASSERT(runJSTest(webView.page(), "textFieldContainsSpace()", "true"));
     93    EXPECT_TRUE(runJSTest(webView.page(), "isDocumentScrolled()", "true"));
     94    EXPECT_TRUE(runJSTest(webView.page(), "textFieldContainsSpace()", "true"));
     95
    9596#if PLATFORM(MAC)
    96     TEST_ASSERT(!didNotHandleKeyDownEvent);
     97    EXPECT_FALSE(didNotHandleKeyDownEvent);
    9798#elif PLATFORM(WIN)
    98     TEST_ASSERT(didNotHandleKeyDownEvent);
     99    EXPECT_TRUE(didNotHandleKeyDownEvent);
    99100#endif
    100101}

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/WKPreferences.cpp

    r86267 r86602  
    2626#include "Test.h"
    2727
     28#include "PlatformUtilities.h"
    2829#include <WebKit2/WKPreferences.h>
    2930#include <WebKit2/WKPreferencesPrivate.h>
    … …  
    3839    WKPreferencesRef preference = WKPreferencesCreate();
    3940
    40     TEST_ASSERT(WKGetTypeID(preference) == WKPreferencesGetTypeID());
     41    EXPECT_EQ(WKPreferencesGetTypeID(), WKGetTypeID(preference));
    4142
    4243    WKRelease(preference);
    … …  
    6364    WKPreferencesRef preference = WKPreferencesCreate();
    6465
    65     TEST_ASSERT(WKPreferencesGetJavaScriptEnabled(preference) == true);
    66     TEST_ASSERT(WKPreferencesGetLoadsImagesAutomatically(preference) == true);
    67     TEST_ASSERT(WKPreferencesGetOfflineWebApplicationCacheEnabled(preference) == false);
    68     TEST_ASSERT(WKPreferencesGetLocalStorageEnabled(preference) == true);
    69     TEST_ASSERT(WKPreferencesGetXSSAuditorEnabled(preference) == true);
    70     TEST_ASSERT(WKPreferencesGetFrameFlatteningEnabled(preference) == false);
    71     TEST_ASSERT(WKPreferencesGetPluginsEnabled(preference) == true);
    72     TEST_ASSERT(WKPreferencesGetJavaEnabled(preference) == true);
    73     TEST_ASSERT(WKPreferencesGetJavaScriptCanOpenWindowsAutomatically(preference) == true);
    74     TEST_ASSERT(WKPreferencesGetHyperlinkAuditingEnabled(preference) == true);
    75     WKRetainPtr<WKStringRef> standardFontFamily(AdoptWK, WKPreferencesCopyStandardFontFamily(preference));
    76     TEST_ASSERT(WKStringIsEqualToUTF8CString(standardFontFamily.get(), expectedStandardFontFamily));
    77     WKRetainPtr<WKStringRef> fixedFontFamily(AdoptWK, WKPreferencesCopyFixedFontFamily(preference));
    78     TEST_ASSERT(WKStringIsEqualToUTF8CString(fixedFontFamily.get(), expectedFixedFontFamily));
    79     WKRetainPtr<WKStringRef> serifFontFamily(AdoptWK, WKPreferencesCopySerifFontFamily(preference));
    80     TEST_ASSERT(WKStringIsEqualToUTF8CString(serifFontFamily.get(), expectedSerifFontFamily));
    81     WKRetainPtr<WKStringRef> sansSerifFontFamily(AdoptWK, WKPreferencesCopySansSerifFontFamily(preference));
    82     TEST_ASSERT(WKStringIsEqualToUTF8CString(sansSerifFontFamily.get(), expectedSansSerifFontFamily));
    83     WKRetainPtr<WKStringRef> cursiveFontFamily(AdoptWK, WKPreferencesCopyCursiveFontFamily(preference));
    84     TEST_ASSERT(WKStringIsEqualToUTF8CString(cursiveFontFamily.get(), expectedCursiveFontFamily));
    85     WKRetainPtr<WKStringRef> fantasyFontFamily(AdoptWK, WKPreferencesCopyFantasyFontFamily(preference));
    86     TEST_ASSERT(WKStringIsEqualToUTF8CString(fantasyFontFamily.get(), expectedFantasyFontFamily));
    87     TEST_ASSERT(WKPreferencesGetMinimumFontSize(preference) == 0);
    88     TEST_ASSERT(WKPreferencesGetPrivateBrowsingEnabled(preference) == false);
    89     TEST_ASSERT(WKPreferencesGetDeveloperExtrasEnabled(preference) == false);
    90     TEST_ASSERT(WKPreferencesGetTextAreasAreResizable(preference) == true);
     66    EXPECT_TRUE(WKPreferencesGetJavaScriptEnabled(preference));
     67    EXPECT_TRUE(WKPreferencesGetLoadsImagesAutomatically(preference));
     68    EXPECT_FALSE(WKPreferencesGetOfflineWebApplicationCacheEnabled(preference));
     69    EXPECT_TRUE(WKPreferencesGetLocalStorageEnabled(preference));
     70    EXPECT_TRUE(WKPreferencesGetXSSAuditorEnabled(preference));
     71    EXPECT_FALSE(WKPreferencesGetFrameFlatteningEnabled(preference));
     72    EXPECT_TRUE(WKPreferencesGetPluginsEnabled(preference));
     73    EXPECT_TRUE(WKPreferencesGetJavaEnabled(preference));
     74    EXPECT_TRUE(WKPreferencesGetJavaScriptCanOpenWindowsAutomatically(preference));
     75    EXPECT_TRUE(WKPreferencesGetHyperlinkAuditingEnabled(preference));
     76    EXPECT_WK_STREQ(expectedStandardFontFamily, adoptWK(WKPreferencesCopyStandardFontFamily(preference)));
     77    EXPECT_WK_STREQ(expectedFixedFontFamily, adoptWK(WKPreferencesCopyFixedFontFamily(preference)));
     78    EXPECT_WK_STREQ(expectedSerifFontFamily, adoptWK(WKPreferencesCopySerifFontFamily(preference)));
     79    EXPECT_WK_STREQ(expectedSansSerifFontFamily, adoptWK(WKPreferencesCopySansSerifFontFamily(preference)));
     80    EXPECT_WK_STREQ(expectedCursiveFontFamily, adoptWK(WKPreferencesCopyCursiveFontFamily(preference)));
     81    EXPECT_WK_STREQ(expectedFantasyFontFamily, adoptWK(WKPreferencesCopyFantasyFontFamily(preference)));
     82    EXPECT_EQ(0u, WKPreferencesGetMinimumFontSize(preference));
     83    EXPECT_FALSE(WKPreferencesGetPrivateBrowsingEnabled(preference));
     84    EXPECT_FALSE(WKPreferencesGetDeveloperExtrasEnabled(preference));
     85    EXPECT_TRUE(WKPreferencesGetTextAreasAreResizable(preference));
    9186
    9287#if PLATFORM(WIN)
    93     TEST_ASSERT(WKPreferencesGetFontSmoothingLevel(preference) == kWKFontSmoothingLevelWindows);
     88    EXPECT_EQ(kWKFontSmoothingLevelWindows, WKPreferencesGetFontSmoothingLevel(preference));
    9489#else
    95     TEST_ASSERT(WKPreferencesGetFontSmoothingLevel(preference) == kWKFontSmoothingLevelMedium);
     90    EXPECT_EQ(kWKFontSmoothingLevelMedium, WKPreferencesGetFontSmoothingLevel(preference));
    9691#endif
    9792
    98     TEST_ASSERT(WKPreferencesGetAcceleratedCompositingEnabled(preference) == true);
    99     TEST_ASSERT(WKPreferencesGetCompositingBordersVisible(preference) == false);
    100     TEST_ASSERT(WKPreferencesGetCompositingRepaintCountersVisible(preference) == false);
    101     TEST_ASSERT(WKPreferencesGetNeedsSiteSpecificQuirks(preference) == false);
     93    EXPECT_TRUE(WKPreferencesGetAcceleratedCompositingEnabled(preference));
     94    EXPECT_FALSE(WKPreferencesGetCompositingBordersVisible(preference));
     95    EXPECT_FALSE(WKPreferencesGetCompositingRepaintCountersVisible(preference));
     96    EXPECT_FALSE(WKPreferencesGetNeedsSiteSpecificQuirks(preference));
    10297
    10398    WKRelease(preference);

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/WKString.cpp

    r83198 r86602  
    3333{
    3434    WKStringRef string = WKStringCreateWithUTF8CString("hello");
    35     TEST_ASSERT(!WKStringIsEmpty(string));
    36     TEST_ASSERT(WKStringIsEqual(string, string));
    37     TEST_ASSERT(WKStringIsEqualToUTF8CString(string, "hello"));
    38     TEST_ASSERT(WKStringGetMaximumUTF8CStringSize(string) == 16);
     35    EXPECT_TRUE(!WKStringIsEmpty(string));
     36    EXPECT_TRUE(WKStringIsEqual(string, string));
     37    EXPECT_TRUE(WKStringIsEqualToUTF8CString(string, "hello"));
     38    EXPECT_EQ(16u, WKStringGetMaximumUTF8CStringSize(string));
    3939
    4040    size_t maxSize = WKStringGetMaximumUTF8CStringSize(string);
    … …  
    4242
    4343    size_t actualSize = WKStringGetUTF8CString(string, buffer, maxSize);
    44     TEST_ASSERT(actualSize == 6);
    45     TEST_ASSERT(strcmp(buffer, "hello") == 0);
     44    EXPECT_EQ(6u, actualSize);
     45    EXPECT_STREQ("hello", buffer);
    4646
    4747    delete[] buffer;
    4848   
    4949    maxSize = WKStringGetLength(string);
    50     TEST_ASSERT(maxSize == 5);
     50    EXPECT_EQ(5u, maxSize);
    5151
    5252    // Allocate a buffer one character larger than we need.
    5353    WKChar* uniBuffer = new WKChar[maxSize+1];
    5454    actualSize = WKStringGetCharacters(string, uniBuffer, maxSize);
    55     TEST_ASSERT(actualSize == 5);
     55    EXPECT_EQ(5u, actualSize);
    5656   
    5757    WKChar helloBuffer[] = { 'h', 'e', 'l', 'l', 'o' };
    58     TEST_ASSERT(!memcmp(uniBuffer, helloBuffer, 10));
     58    EXPECT_TRUE(!memcmp(uniBuffer, helloBuffer, 10));
    5959   
    6060    // Test passing a buffer length < the string length.
    61     actualSize = WKStringGetCharacters(string, uniBuffer, maxSize-1);
    62     TEST_ASSERT(actualSize == 4);
     61    actualSize = WKStringGetCharacters(string, uniBuffer, maxSize - 1);
     62    EXPECT_EQ(4u, actualSize);
    6363   
    6464    // Test passing a buffer length > the string length.
    65     actualSize = WKStringGetCharacters(string, uniBuffer, maxSize+1);
    66     TEST_ASSERT(actualSize == 5);
     65    actualSize = WKStringGetCharacters(string, uniBuffer, maxSize + 1);
     66    EXPECT_EQ(5u, actualSize);
    6767   
    6868    delete[] uniBuffer;

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/WKStringJSString.cpp

    r69317 r86602  
    3838   
    3939    WKStringRef convertedJSString = WKStringCreateWithJSString(jsString);
    40     TEST_ASSERT(WKStringIsEqual(wkString, convertedJSString));
     40    EXPECT_TRUE(WKStringIsEqual(wkString, convertedJSString));
    4141   
    4242    JSStringRef convertedWKString = WKStringCopyJSString(wkString);
    43     TEST_ASSERT(JSStringIsEqual(jsString, convertedWKString));
     43    EXPECT_TRUE(JSStringIsEqual(jsString, convertedWKString));
    4444
    4545    WKRelease(wkString);

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/win/AltKeyGeneratesWMSysCommand.cpp

    r73965 r86602  
    8181    // The WM_SYSKEYUP message should have generated a WM_SYSCOMMAND message that was sent to the
    8282    // WKView's parent window.
    83     TEST_ASSERT(observer.windowDidReceiveWMSysCommand());
     83    EXPECT_TRUE(observer.windowDidReceiveWMSysCommand());
    8484}
    8585

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/win/HideFindIndicator.cpp

    r82732 r86602  
    7373    findIndicatorCallbackWasCalled = false;
    7474
    75     TEST_ASSERT(bitmap);
     75    EXPECT_NOT_NULL(bitmap);
    7676    ::DeleteObject(bitmap);
    7777    bitmap = 0;
    … …  
    8080    Util::run(&findIndicatorCallbackWasCalled);
    8181
    82     TEST_ASSERT(!bitmap);
     82    EXPECT_NULL(bitmap);
    8383}
    8484

  • trunk/Tools/TestWebKitAPI/Tests/WebKit2/win/TranslateMessageGeneratesWMChar.cpp

    r83633 r86602  
    8686
    8787    // WebKit should not have called TranslateMessage() on the WM_KEYDOWN message since we installed a didNotHandleKeyEvent callback.
    88     TEST_ASSERT(!didSeeWMChar);
     88    EXPECT_FALSE(didSeeWMChar);
    8989}
    9090
Note: See TracChangeset for help on using the changeset viewer.