[chromedriver] Remove dll build target.

chrome/test/chromedriver/chromedriver_unittest.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <list>
-#include <string>
-
-#include "base/bind.h"
-#include "base/compiler_specific.h"
-#include "base/json/json_reader.h"
-#include "base/location.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/scoped_vector.h"
-#include "base/message_loop.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
-#include "base/values.h"
-#include "chrome/test/chromedriver/chrome/status.h"
-#include "chrome/test/chromedriver/chromedriver.h"
-#include "chrome/test/chromedriver/command_executor.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-void ExpectExecuteError(const std::string& command) {
-  std::string response;
-  ExecuteCommand(command, &response);
-  scoped_ptr<base::Value> value(base::JSONReader::Read(response));
-  ASSERT_TRUE(value.get());
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(value->GetAsDictionary(&dict));
-  int status;
-  ASSERT_TRUE(dict->GetInteger("status", &status));
-  EXPECT_EQ(kUnknownError, status);
-}
-
-class DummyExecutor : public CommandExecutor {
- public:
-  virtual ~DummyExecutor() {}
-
-  virtual void Init() OVERRIDE {}
-  virtual void ExecuteCommand(const std::string& name,
-                              const base::DictionaryValue& params,
-                              const std::string& session_id,
-                              StatusCode* status,
-                              scoped_ptr<base::Value>* value,
-                              std::string* out_session_id) OVERRIDE {}
-};
-
-
-struct ExpectedCommand {
-  ExpectedCommand(
-      const std::string& name,
-      const base::DictionaryValue& in_params,
-      const std::string& session_id,
-      StatusCode return_status,
-      scoped_ptr<base::Value> return_value,
-      const std::string& return_session_id)
-      : name(name),
-        session_id(session_id),
-        return_status(return_status),
-        return_value(return_value.Pass()),
-        return_session_id(return_session_id) {
-    params.MergeDictionary(&in_params);
-  }
-
-  ~ExpectedCommand() {}
-
-  std::string name;
-  base::DictionaryValue params;
-  std::string session_id;
-  StatusCode return_status;
-  scoped_ptr<base::Value> return_value;
-  std::string return_session_id;
-};
-
-class ExecutorMock : public CommandExecutor {
- public:
-  virtual ~ExecutorMock() {
-    EXPECT_TRUE(DidSatisfyExpectations());
-  }
-
-  virtual void Init() OVERRIDE {}
-
-  virtual void ExecuteCommand(const std::string& name,
-                              const base::DictionaryValue& params,
-                              const std::string& session_id,
-                              StatusCode* status,
-                              scoped_ptr<base::Value>* value,
-                              std::string* out_session_id) OVERRIDE {
-    ASSERT_TRUE(expectations_.size());
-    ASSERT_STREQ(expectations_[0]->name.c_str(), name.c_str());
-    ASSERT_TRUE(expectations_[0]->params.Equals(&params));
-    ASSERT_STREQ(expectations_[0]->session_id.c_str(), session_id.c_str());
-    *status = expectations_[0]->return_status;
-    value->reset(expectations_[0]->return_value.release());
-    *out_session_id = expectations_[0]->return_session_id;
-    expectations_.erase(expectations_.begin());
-  }
-
-  void Expect(scoped_ptr<ExpectedCommand> expected) {
-    expectations_.push_back(expected.release());
-  }
-
-  bool DidSatisfyExpectations() const {
-    return expectations_.empty();
-  }
-
- private:
-  ScopedVector<ExpectedCommand> expectations_;
-};
-
-}  // namespace
-
-TEST(ChromeDriver, InvalidCommands) {
-  Init(scoped_ptr<CommandExecutor>(new DummyExecutor()));
-  ExpectExecuteError("hi[]");
-  ExpectExecuteError("[]");
-  ExpectExecuteError(
-      "{\"parameters\": {}, \"sessionId\": \"\"}");
-  ExpectExecuteError(
-      "{\"name\": 1, \"parameters\": {}, \"sessionId\": \"\"}");
-  ExpectExecuteError(
-      "{\"name\": \"\", \"sessionId\": \"\"}");
-  ExpectExecuteError(
-      "{\"name\": \"\", \"parameters\": 1, \"sessionId\": \"\"}");
-  ExpectExecuteError(
-      "{\"name\": \"\", \"parameters\": {}}");
-  ExpectExecuteError(
-      "{\"name\": \"\", \"parameters\": {}, \"sessionId\": 1}");
-  Shutdown();
-}
-
-TEST(ChromeDriver, ExecuteCommand) {
-  scoped_ptr<ExecutorMock> scoped_mock(new ExecutorMock());
-  ExecutorMock* mock = scoped_mock.get();
-  Init(scoped_mock.PassAs<CommandExecutor>());
-  {
-    base::DictionaryValue params;
-    params.SetInteger("param", 100);
-    scoped_ptr<base::Value> value(new base::StringValue("stuff"));
-    mock->Expect(scoped_ptr<ExpectedCommand>(new ExpectedCommand(
-        "name", params, "id", kOk, value.Pass(), "session_id")));
-  }
-  std::string response;
-  ExecuteCommand("{\"name\": \"name\", "
-                 " \"parameters\": {\"param\": 100}, "
-                 " \"sessionId\": \"id\"}",
-                 &response);
-  ASSERT_TRUE(mock->DidSatisfyExpectations());
-  {
-    scoped_ptr<base::Value> value(base::JSONReader::Read(response));
-    ASSERT_TRUE(value.get());
-    base::DictionaryValue* dict;
-    ASSERT_TRUE(value->GetAsDictionary(&dict));
-    int status;
-    ASSERT_TRUE(dict->GetInteger("status", &status));
-    std::string value_str;
-    ASSERT_TRUE(dict->GetString("value", &value_str));
-    EXPECT_STREQ("stuff", value_str.c_str());
-    EXPECT_EQ(kOk, status);
-  }
-  {
-    base::DictionaryValue params;
-    scoped_ptr<base::Value> value(base::Value::CreateNullValue());
-    mock->Expect(scoped_ptr<ExpectedCommand>(new ExpectedCommand(
-        "quitAll", params, std::string(), kOk, value.Pass(), std::string())));
-  }
-  Shutdown();
-}