cobalt/dom/window_test.cc - cobalt - Git at Google

 // Copyright 2015 The Cobalt Authors. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "cobalt/dom/window.h"

 #include <memory>
 #include <string>

 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "cobalt/bindings/testing/utils.h"
 #include "cobalt/dom/screen.h"
 #include "cobalt/dom/testing/test_with_javascript.h"
 #include "cobalt/network_bridge/net_poster.h"
 #include "cobalt/script/testing/fake_script_value.h"
 #include "cobalt/web/error_event.h"
 #include "cobalt/web/message_event.h"
 #include "cobalt/web/testing/mock_event_listener.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace cobalt {
 namespace dom {

 using script::testing::FakeScriptValue;

 class WindowTestBase {
  protected:
   WindowTestBase() {
     fake_event_listener_ = web::testing::MockEventListener::Create();
   }

   virtual ~WindowTestBase() {}

   std::unique_ptr<web::testing::MockEventListener> fake_event_listener_;
 };

 class WindowTest : public WindowTestBase, public testing::TestWithJavaScript {};

 TEST_F(WindowTest, WindowShouldNotHaveChildren) {
   EXPECT_EQ(window(), window()->window());
   EXPECT_EQ(window(), window()->self());
   EXPECT_EQ(window(), window()->frames());
   EXPECT_EQ(0, window()->length());
   EXPECT_EQ(window(), window()->top());
   EXPECT_EQ(window(), window()->opener());
   EXPECT_EQ(window(), window()->parent());
   EXPECT_FALSE(window()->AnonymousIndexedGetter(0));
 }

 TEST_F(WindowTest, ViewportSize) {
   EXPECT_FLOAT_EQ(window()->inner_width(), 1920.0f);
   EXPECT_FLOAT_EQ(window()->inner_height(), 1080.0f);
   EXPECT_FLOAT_EQ(window()->screen_x(), 0.0f);
   EXPECT_FLOAT_EQ(window()->screen_y(), 0.0f);
   EXPECT_FLOAT_EQ(window()->outer_width(), 1920.0f);
   EXPECT_FLOAT_EQ(window()->outer_height(), 1080.0f);
   EXPECT_FLOAT_EQ(window()->device_pixel_ratio(), 1.0f);
   EXPECT_FLOAT_EQ(window()->screen()->width(), 1920.0f);
   EXPECT_FLOAT_EQ(window()->screen()->height(), 1080.0f);
   EXPECT_FLOAT_EQ(window()->screen()->avail_width(), 1920.0f);
   EXPECT_FLOAT_EQ(window()->screen()->avail_height(), 1080.0f);
 }

 TEST_F(WindowTest, WindowIsWindow) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window", &result));
   EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));

   EXPECT_TRUE(EvaluateScript("typeof window.window", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window.window", &result));
   EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
 }

 TEST_F(WindowTest, SelfIsWindow) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.self", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window.self", &result));
   EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
 }

 TEST_F(WindowTest, DocumentIsDocument) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.document", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window.document", &result));
   EXPECT_TRUE(
       bindings::testing::IsAcceptablePrototypeString("Document", result));
 }

 TEST_F(WindowTest, LocationIsObject) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.location", &result));
   EXPECT_EQ("object", result);

   // Note: Due the stringifier of URLUtils.href implemented by this attribute,
   // the prototype is not recognized as type Location, and the href is returned.
   EXPECT_TRUE(EvaluateScript("window.location", &result));
   EXPECT_EQ("about:blank", result);
 }

 TEST_F(WindowTest, HistoryIsHistory) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.history", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window.history", &result));
   EXPECT_TRUE(
       bindings::testing::IsAcceptablePrototypeString("History", result));
 }

 TEST_F(WindowTest, FramesIsWindow) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.frames", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window.frames", &result));
   EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
 }

 TEST_F(WindowTest, LengthIsZero) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.length", &result));
   EXPECT_EQ("number", result);

   EXPECT_TRUE(EvaluateScript("window.length", &result));
   EXPECT_EQ("0", result);
 }

 TEST_F(WindowTest, TopIsWindow) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.top", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window.top", &result));
   EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
 }

 TEST_F(WindowTest, OpenerIsWindow) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.opener", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window.opener", &result));
   EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
 }

 TEST_F(WindowTest, ParentIsWindow) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.parent", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window.parent", &result));
   EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
 }

 TEST_F(WindowTest, NavigatorIsNavigator) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.navigator", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window.navigator", &result));
   EXPECT_TRUE(
       bindings::testing::IsAcceptablePrototypeString("Navigator", result));
 }

 TEST_F(WindowTest, Btoa) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.btoa", &result));
   EXPECT_EQ("function", result);

   EXPECT_TRUE(EvaluateScript("window.btoa", &result));
   EXPECT_EQ("function btoa() { [native code] }", result);
   EXPECT_TRUE(EvaluateScript("window.btoa('test')", &result));
   EXPECT_EQ("dGVzdA==", result);
 }

 TEST_F(WindowTest, Atob) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.atob", &result));
   EXPECT_EQ("function", result);

   EXPECT_TRUE(EvaluateScript("window.atob", &result));
   EXPECT_EQ("function atob() { [native code] }", result);
   EXPECT_TRUE(EvaluateScript("window.atob('dGVzdA==')", &result));
   EXPECT_EQ("test", result);
 }

 TEST_F(WindowTest, Camera3DIsCamera3D) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.camera3D", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript("window.camera3D", &result));
   EXPECT_TRUE(
       bindings::testing::IsAcceptablePrototypeString("Camera3D", result));
 }

 TEST_F(WindowTest, Gc) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.gc", &result));
   EXPECT_EQ("function", result);

   EXPECT_TRUE(EvaluateScript("window.gc", &result));
   EXPECT_EQ("function gc() { [native code] }", result);
   EXPECT_TRUE(EvaluateScript("window.gc()", &result));
   EXPECT_EQ("undefined", result);
 }

 TEST_F(WindowTest, Minimize) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.minimize", &result));
   EXPECT_EQ("function", result);

   EXPECT_TRUE(EvaluateScript("window.minimize", &result));
   EXPECT_EQ("function minimize() { [native code] }", result);
   EXPECT_TRUE(EvaluateScript("window.minimize()", &result));
   EXPECT_EQ("undefined", result);
 }

 TEST_F(WindowTest, Screenshot) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.screenshot", &result));
   EXPECT_EQ("function", result);

   EXPECT_TRUE(EvaluateScript("window.screenshot", &result));
   EXPECT_EQ("function screenshot() { [native code] }", result);

   // Note we can't call screenshot in this unit test, since StubWindow doesn't
   // pass in the screenshot function callback.
 }

 TEST_F(WindowTest, MessageEvent) {
   window()->AddEventListener(
       "message",
       FakeScriptValue<web::EventListener>(fake_event_listener_.get()), true);
   fake_event_listener_->ExpectHandleEventCall("message", window());
   window()->DispatchEvent(new web::MessageEvent("message"));
 }

 TEST_F(WindowTest, OnMessageEvent) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.onmessage", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript(R"(
     logString = '(empty)';
     window.onmessage= function() {
       logString = 'handled';
     };
     window.dispatchEvent(new MessageEvent('message'));
     logString;
   )",
                              &result));
   EXPECT_EQ("handled", result);
 }

 TEST_F(WindowTest, MessageErrorEvent) {
   window()->AddEventListener(
       "messageerror",
       FakeScriptValue<web::EventListener>(fake_event_listener_.get()), true);
   fake_event_listener_->ExpectHandleEventCall("messageerror", window());
   window()->DispatchEvent(new web::MessageEvent("messageerror"));
 }

 TEST_F(WindowTest, OnMessageErrorEvent) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.onmessageerror", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript(R"(
     logString = '(empty)';
     window.onmessageerror = function() {
       logString = 'handled';
     };
     window.dispatchEvent(new Event('messageerror'));
     logString;
   )",
                              &result));
   EXPECT_EQ("handled", result);
 }

 TEST_F(WindowTest, ErrorEvent) {
   window()->AddEventListener(
       "error", FakeScriptValue<web::EventListener>(fake_event_listener_.get()),
       true);
   fake_event_listener_->ExpectHandleEventCall("error", window());
   window()->DispatchEvent(
       new web::ErrorEvent(/*environment_settings=*/nullptr));
 }

 TEST_F(WindowTest, OnErrorEvent) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof window.onerror", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript(R"(
     logString = '(empty)';
     window.onerror = function() {
       logString = 'handled';
     };
     window.dispatchEvent(new ErrorEvent('error'));
     logString;
   )",
                              &result));
   EXPECT_EQ("handled", result);
 }

 namespace {
 class WindowTestEventTest : public WindowTestBase,
                             public testing::TestWithJavaScriptBase,
                             public ::testing::TestWithParam<const char*> {};

 std::string GetEventName(::testing::TestParamInfo<const char*> info) {
   return std::string(info.param);
 }

 const char* events[] = {"beforeunload",
                         "blur",
                         "click",
                         "focus",
                         "hashchange",
                         "keydown",
                         "keypress",
                         "keyup",
                         "languagechange",
                         "load",
                         "loadeddata",
                         "loadedmetadata",
                         "loadstart",
                         "mousedown",
                         "mouseenter",
                         "mouseleave",
                         "mousemove",
                         "mouseout",
                         "mouseover",
                         "mouseup",
                         "offline",
                         "online",
                         "pause",
                         "play",
                         "playing",
                         "resize",
                         "scroll",
                         "transitionend",
                         "gotpointercapture",
                         "lostpointercapture",
                         "pointercancel",
                         "pointerdown",
                         "pointerenter",
                         "pointerleave",
                         "pointermove",
                         "pointerout",
                         "pointerover",
                         "pointerup",
                         "progress",
                         "ratechange",
                         "rejectionhandled",
                         "seeked",
                         "seeking",
                         "timeupdate",
                         "unhandledrejection",
                         "volumechange",
                         "waiting",
                         "wheel"};
 }  // namespace

 TEST_P(WindowTestEventTest, AddEventListener) {
   const char* event_name = GetParam();
   window()->AddEventListener(
       event_name,
       FakeScriptValue<web::EventListener>(fake_event_listener_.get()), true);
   fake_event_listener_->ExpectHandleEventCall(event_name, window());
   window()->DispatchEvent(new web::Event(event_name));
 }

 TEST_P(WindowTestEventTest, OnEvent) {
   const char* event_name = GetParam();
   std::string result;
   EXPECT_TRUE(EvaluateScript(
       base::StringPrintf("typeof window.on%s", event_name), &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(
       EvaluateScript(base::StringPrintf(R"(
     logString = '(empty)';
     self.on%s = function() {
       logString = '%s';
     };
     self.dispatchEvent(new Event('%s'));
     logString;
   )",
                                         event_name, event_name, event_name),
                      &result));
   EXPECT_EQ(event_name, result);
 }

 INSTANTIATE_TEST_CASE_P(WindowTest, WindowTestEventTest,
                         ::testing::ValuesIn(events), GetEventName);

 // Test that when Window's network status change callbacks are triggered,
 // corresponding online and offline events are fired to listeners.
 TEST_F(WindowTest, OfflineEvent) {
   window()->AddEventListener(
       "offline",
       FakeScriptValue<web::EventListener>(fake_event_listener_.get()), true);
   fake_event_listener_->ExpectHandleEventCall("offline", window());
   window()->OnWindowOnOfflineEvent();
 }

 TEST_F(WindowTest, OnlineEvent) {
   window()->AddEventListener(
       "online", FakeScriptValue<web::EventListener>(fake_event_listener_.get()),
       true);
   fake_event_listener_->ExpectHandleEventCall("online", window());
   window()->OnWindowOnOnlineEvent();
 }

 TEST_F(WindowTest, UnloadEvent) {
   window()->AddEventListener(
       "unload", FakeScriptValue<web::EventListener>(fake_event_listener_.get()),
       true);
   fake_event_listener_->ExpectHandleEventCall("unload", window());
   window()->DispatchEvent(new web::Event("unload"));

   // Remove the unload event listener here so that the fixture destructor
   // doesn't call into this event handler after it has been destroyed.
   window()->RemoveEventListener(
       "unload", FakeScriptValue<web::EventListener>(fake_event_listener_.get()),
       true);
 }

 TEST_F(WindowTest, OnUnloadEvent) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("typeof self.onunload", &result));
   EXPECT_EQ("object", result);

   EXPECT_TRUE(EvaluateScript(R"(
     logString = '(empty)';
     self.onunload = function() {
       logString = 'handled';
     };
     self.dispatchEvent(new Event('unload'));
     logString;
   )",
                              &result));
   EXPECT_EQ("handled", result);
 }

 }  // namespace dom
 }  // namespace cobalt
	// Copyright 2015 The Cobalt Authors. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "cobalt/dom/window.h"

	#include <memory>
	#include <string>

	#include "base/bind.h"
	#include "base/strings/stringprintf.h"
	#include "cobalt/bindings/testing/utils.h"
	#include "cobalt/dom/screen.h"
	#include "cobalt/dom/testing/test_with_javascript.h"
	#include "cobalt/network_bridge/net_poster.h"
	#include "cobalt/script/testing/fake_script_value.h"
	#include "cobalt/web/error_event.h"
	#include "cobalt/web/message_event.h"
	#include "cobalt/web/testing/mock_event_listener.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace cobalt {
	namespace dom {

	using script::testing::FakeScriptValue;

	class WindowTestBase {
	protected:
	WindowTestBase() {
	fake_event_listener_ = web::testing::MockEventListener::Create();
	}

	virtual ~WindowTestBase() {}

	std::unique_ptr<web::testing::MockEventListener> fake_event_listener_;
	};

	class WindowTest : public WindowTestBase, public testing::TestWithJavaScript {};

	TEST_F(WindowTest, WindowShouldNotHaveChildren) {
	EXPECT_EQ(window(), window()->window());
	EXPECT_EQ(window(), window()->self());
	EXPECT_EQ(window(), window()->frames());
	EXPECT_EQ(0, window()->length());
	EXPECT_EQ(window(), window()->top());
	EXPECT_EQ(window(), window()->opener());
	EXPECT_EQ(window(), window()->parent());
	EXPECT_FALSE(window()->AnonymousIndexedGetter(0));
	}

	TEST_F(WindowTest, ViewportSize) {
	EXPECT_FLOAT_EQ(window()->inner_width(), 1920.0f);
	EXPECT_FLOAT_EQ(window()->inner_height(), 1080.0f);
	EXPECT_FLOAT_EQ(window()->screen_x(), 0.0f);
	EXPECT_FLOAT_EQ(window()->screen_y(), 0.0f);
	EXPECT_FLOAT_EQ(window()->outer_width(), 1920.0f);
	EXPECT_FLOAT_EQ(window()->outer_height(), 1080.0f);
	EXPECT_FLOAT_EQ(window()->device_pixel_ratio(), 1.0f);
	EXPECT_FLOAT_EQ(window()->screen()->width(), 1920.0f);
	EXPECT_FLOAT_EQ(window()->screen()->height(), 1080.0f);
	EXPECT_FLOAT_EQ(window()->screen()->avail_width(), 1920.0f);
	EXPECT_FLOAT_EQ(window()->screen()->avail_height(), 1080.0f);
	}

	TEST_F(WindowTest, WindowIsWindow) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window", &result));
	EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));

	EXPECT_TRUE(EvaluateScript("typeof window.window", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window.window", &result));
	EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
	}

	TEST_F(WindowTest, SelfIsWindow) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.self", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window.self", &result));
	EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
	}

	TEST_F(WindowTest, DocumentIsDocument) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.document", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window.document", &result));
	EXPECT_TRUE(
	bindings::testing::IsAcceptablePrototypeString("Document", result));
	}

	TEST_F(WindowTest, LocationIsObject) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.location", &result));
	EXPECT_EQ("object", result);

	// Note: Due the stringifier of URLUtils.href implemented by this attribute,
	// the prototype is not recognized as type Location, and the href is returned.
	EXPECT_TRUE(EvaluateScript("window.location", &result));
	EXPECT_EQ("about:blank", result);
	}

	TEST_F(WindowTest, HistoryIsHistory) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.history", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window.history", &result));
	EXPECT_TRUE(
	bindings::testing::IsAcceptablePrototypeString("History", result));
	}

	TEST_F(WindowTest, FramesIsWindow) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.frames", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window.frames", &result));
	EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
	}

	TEST_F(WindowTest, LengthIsZero) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.length", &result));
	EXPECT_EQ("number", result);

	EXPECT_TRUE(EvaluateScript("window.length", &result));
	EXPECT_EQ("0", result);
	}

	TEST_F(WindowTest, TopIsWindow) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.top", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window.top", &result));
	EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
	}

	TEST_F(WindowTest, OpenerIsWindow) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.opener", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window.opener", &result));
	EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
	}

	TEST_F(WindowTest, ParentIsWindow) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.parent", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window.parent", &result));
	EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Window", result));
	}

	TEST_F(WindowTest, NavigatorIsNavigator) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.navigator", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window.navigator", &result));
	EXPECT_TRUE(
	bindings::testing::IsAcceptablePrototypeString("Navigator", result));
	}

	TEST_F(WindowTest, Btoa) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.btoa", &result));
	EXPECT_EQ("function", result);

	EXPECT_TRUE(EvaluateScript("window.btoa", &result));
	EXPECT_EQ("function btoa() { [native code] }", result);
	EXPECT_TRUE(EvaluateScript("window.btoa('test')", &result));
	EXPECT_EQ("dGVzdA==", result);
	}

	TEST_F(WindowTest, Atob) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.atob", &result));
	EXPECT_EQ("function", result);

	EXPECT_TRUE(EvaluateScript("window.atob", &result));
	EXPECT_EQ("function atob() { [native code] }", result);
	EXPECT_TRUE(EvaluateScript("window.atob('dGVzdA==')", &result));
	EXPECT_EQ("test", result);
	}

	TEST_F(WindowTest, Camera3DIsCamera3D) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.camera3D", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript("window.camera3D", &result));
	EXPECT_TRUE(
	bindings::testing::IsAcceptablePrototypeString("Camera3D", result));
	}

	TEST_F(WindowTest, Gc) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.gc", &result));
	EXPECT_EQ("function", result);

	EXPECT_TRUE(EvaluateScript("window.gc", &result));
	EXPECT_EQ("function gc() { [native code] }", result);
	EXPECT_TRUE(EvaluateScript("window.gc()", &result));
	EXPECT_EQ("undefined", result);
	}

	TEST_F(WindowTest, Minimize) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.minimize", &result));
	EXPECT_EQ("function", result);

	EXPECT_TRUE(EvaluateScript("window.minimize", &result));
	EXPECT_EQ("function minimize() { [native code] }", result);
	EXPECT_TRUE(EvaluateScript("window.minimize()", &result));
	EXPECT_EQ("undefined", result);
	}

	TEST_F(WindowTest, Screenshot) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.screenshot", &result));
	EXPECT_EQ("function", result);

	EXPECT_TRUE(EvaluateScript("window.screenshot", &result));
	EXPECT_EQ("function screenshot() { [native code] }", result);

	// Note we can't call screenshot in this unit test, since StubWindow doesn't
	// pass in the screenshot function callback.
	}

	TEST_F(WindowTest, MessageEvent) {
	window()->AddEventListener(
	"message",
	FakeScriptValue<web::EventListener>(fake_event_listener_.get()), true);
	fake_event_listener_->ExpectHandleEventCall("message", window());
	window()->DispatchEvent(new web::MessageEvent("message"));
	}

	TEST_F(WindowTest, OnMessageEvent) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.onmessage", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript(R"(
	logString = '(empty)';
	window.onmessage= function() {
	logString = 'handled';
	};
	window.dispatchEvent(new MessageEvent('message'));
	logString;
	)",
	&result));
	EXPECT_EQ("handled", result);
	}

	TEST_F(WindowTest, MessageErrorEvent) {
	window()->AddEventListener(
	"messageerror",
	FakeScriptValue<web::EventListener>(fake_event_listener_.get()), true);
	fake_event_listener_->ExpectHandleEventCall("messageerror", window());
	window()->DispatchEvent(new web::MessageEvent("messageerror"));
	}

	TEST_F(WindowTest, OnMessageErrorEvent) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.onmessageerror", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript(R"(
	logString = '(empty)';
	window.onmessageerror = function() {
	logString = 'handled';
	};
	window.dispatchEvent(new Event('messageerror'));
	logString;
	)",
	&result));
	EXPECT_EQ("handled", result);
	}

	TEST_F(WindowTest, ErrorEvent) {
	window()->AddEventListener(
	"error", FakeScriptValue<web::EventListener>(fake_event_listener_.get()),
	true);
	fake_event_listener_->ExpectHandleEventCall("error", window());
	window()->DispatchEvent(
	new web::ErrorEvent(/environment_settings=/nullptr));
	}

	TEST_F(WindowTest, OnErrorEvent) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof window.onerror", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript(R"(
	logString = '(empty)';
	window.onerror = function() {
	logString = 'handled';
	};
	window.dispatchEvent(new ErrorEvent('error'));
	logString;
	)",
	&result));
	EXPECT_EQ("handled", result);
	}

	namespace {
	class WindowTestEventTest : public WindowTestBase,
	public testing::TestWithJavaScriptBase,
	public ::testing::TestWithParam<const char*> {};

	std::string GetEventName(::testing::TestParamInfo<const char*> info) {
	return std::string(info.param);
	}

	const char* events[] = {"beforeunload",
	"blur",
	"click",
	"focus",
	"hashchange",
	"keydown",
	"keypress",
	"keyup",
	"languagechange",
	"load",
	"loadeddata",
	"loadedmetadata",
	"loadstart",
	"mousedown",
	"mouseenter",
	"mouseleave",
	"mousemove",
	"mouseout",
	"mouseover",
	"mouseup",
	"offline",
	"online",
	"pause",
	"play",
	"playing",
	"resize",
	"scroll",
	"transitionend",
	"gotpointercapture",
	"lostpointercapture",
	"pointercancel",
	"pointerdown",
	"pointerenter",
	"pointerleave",
	"pointermove",
	"pointerout",
	"pointerover",
	"pointerup",
	"progress",
	"ratechange",
	"rejectionhandled",
	"seeked",
	"seeking",
	"timeupdate",
	"unhandledrejection",
	"volumechange",
	"waiting",
	"wheel"};
	} // namespace

	TEST_P(WindowTestEventTest, AddEventListener) {
	const char* event_name = GetParam();
	window()->AddEventListener(
	event_name,
	FakeScriptValue<web::EventListener>(fake_event_listener_.get()), true);
	fake_event_listener_->ExpectHandleEventCall(event_name, window());
	window()->DispatchEvent(new web::Event(event_name));
	}

	TEST_P(WindowTestEventTest, OnEvent) {
	const char* event_name = GetParam();
	std::string result;
	EXPECT_TRUE(EvaluateScript(
	base::StringPrintf("typeof window.on%s", event_name), &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(
	EvaluateScript(base::StringPrintf(R"(
	logString = '(empty)';
	self.on%s = function() {
	logString = '%s';
	};
	self.dispatchEvent(new Event('%s'));
	logString;
	)",
	event_name, event_name, event_name),
	&result));
	EXPECT_EQ(event_name, result);
	}

	INSTANTIATE_TEST_CASE_P(WindowTest, WindowTestEventTest,
	::testing::ValuesIn(events), GetEventName);

	// Test that when Window's network status change callbacks are triggered,
	// corresponding online and offline events are fired to listeners.
	TEST_F(WindowTest, OfflineEvent) {
	window()->AddEventListener(
	"offline",
	FakeScriptValue<web::EventListener>(fake_event_listener_.get()), true);
	fake_event_listener_->ExpectHandleEventCall("offline", window());
	window()->OnWindowOnOfflineEvent();
	}

	TEST_F(WindowTest, OnlineEvent) {
	window()->AddEventListener(
	"online", FakeScriptValue<web::EventListener>(fake_event_listener_.get()),
	true);
	fake_event_listener_->ExpectHandleEventCall("online", window());
	window()->OnWindowOnOnlineEvent();
	}

	TEST_F(WindowTest, UnloadEvent) {
	window()->AddEventListener(
	"unload", FakeScriptValue<web::EventListener>(fake_event_listener_.get()),
	true);
	fake_event_listener_->ExpectHandleEventCall("unload", window());
	window()->DispatchEvent(new web::Event("unload"));

	// Remove the unload event listener here so that the fixture destructor
	// doesn't call into this event handler after it has been destroyed.
	window()->RemoveEventListener(
	"unload", FakeScriptValue<web::EventListener>(fake_event_listener_.get()),
	true);
	}

	TEST_F(WindowTest, OnUnloadEvent) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("typeof self.onunload", &result));
	EXPECT_EQ("object", result);

	EXPECT_TRUE(EvaluateScript(R"(
	logString = '(empty)';
	self.onunload = function() {
	logString = 'handled';
	};
	self.dispatchEvent(new Event('unload'));
	logString;
	)",
	&result));
	EXPECT_EQ("handled", result);
	}

	} // namespace dom
	} // namespace cobalt