Adds imageWriterPrivate support for Windows

chrome/utility/image_writer/image_writer_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 "base/callback.h"
+#include "base/file_util.h"
+#include "base/run_loop.h"
+#include "chrome/common/chrome_utility_messages.h"
+#include "chrome/utility/image_writer/error_messages.h"
+#include "chrome/utility/image_writer/image_writer.h"
+#include "chrome/utility/image_writer/image_writer_handler.h"
+#include "chrome/utility/image_writer/image_writer_test_utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chrome {
+namespace image_writer {
+
+using testing::_;
+using testing::AnyNumber;
+using testing::AtLeast;
+using testing::Lt;
+
+namespace {
+
+class ImageWriterUtilityTest : public testing::Test {
+ protected:
+  virtual void SetUp() OVERRIDE {
+    temp_files_.SetUp();
+  }
+
+  virtual void TearDown() OVERRIDE {
+  }
+
+  TempFilesForTesting temp_files_;
+
+ private:
+  base::MessageLoop message_loop_;
+};
+
+class MockHandler : public ImageWriterHandler {
+ public:
+  MOCK_METHOD1(SendProgress,  void(int));
+  MOCK_METHOD1(SendFailed,    void(const std::string& message));
+  MOCK_METHOD0(SendSucceeded, void());
+  MOCK_METHOD1(OnMessageReceived, bool(const IPC::Message& message));
+};
+
+} // namespace
+
+TEST_F(ImageWriterUtilityTest, WriteSuccessful) {
+  MockHandler mock_handler;
+  base::WeakPtrFactory<ImageWriterHandler> mock_handler_factory(&mock_handler);
+  scoped_refptr<ImageWriter> image_writer(
+      new ImageWriter(mock_handler_factory.GetWeakPtr()));
+
+  EXPECT_CALL(mock_handler, SendProgress(Lt(100))).Times(AnyNumber());
+  EXPECT_CALL(mock_handler, SendProgress(100)).Times(AtLeast(1));
+  EXPECT_CALL(mock_handler, SendSucceeded()).Times(1);
+  EXPECT_CALL(mock_handler, SendFailed(_)).Times(0);
+
+  temp_files_.InitializeImage();
+  image_writer->Write(temp_files_.ImagePath(), temp_files_.DevicePath());
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(ImageWriterUtilityTest, WriteInvalidImageFile) {
+  MockHandler mock_handler;
+  base::WeakPtrFactory<ImageWriterHandler> mock_handler_factory(&mock_handler);
+  scoped_refptr<ImageWriter> image_writer(
+      new ImageWriter(mock_handler_factory.GetWeakPtr()));
+
+  EXPECT_CALL(mock_handler, SendProgress(_)).Times(0);
+  EXPECT_CALL(mock_handler, SendSucceeded()).Times(0);
+  EXPECT_CALL(mock_handler, SendFailed(error::kOpenImage)).Times(1);
+
+  base::DeleteFile(temp_files_.ImagePath(), false);
+  image_writer->Write(temp_files_.ImagePath(), temp_files_.DevicePath());
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(ImageWriterUtilityTest, WriteInvalidDeviceFile) {
+  MockHandler mock_handler;
+  base::WeakPtrFactory<ImageWriterHandler> mock_handler_factory(&mock_handler);
+  scoped_refptr<ImageWriter> image_writer(
+      new ImageWriter(mock_handler_factory.GetWeakPtr()));
+
+  EXPECT_CALL(mock_handler, SendProgress(_)).Times(0);
+  EXPECT_CALL(mock_handler, SendSucceeded()).Times(0);
+  EXPECT_CALL(mock_handler, SendFailed(error::kOpenDevice)).Times(1);
+
+  base::DeleteFile(temp_files_.DevicePath(), false);
+  image_writer->Write(temp_files_.ImagePath(), temp_files_.DevicePath());
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(ImageWriterUtilityTest, VerifySuccessful) {
+  MockHandler mock_handler;
+  base::WeakPtrFactory<ImageWriterHandler> mock_handler_factory(&mock_handler);
+  scoped_refptr<ImageWriter> image_writer(
+      new ImageWriter(mock_handler_factory.GetWeakPtr()));
+
+  EXPECT_CALL(mock_handler, SendProgress(Lt(100))).Times(AnyNumber());
+  EXPECT_CALL(mock_handler, SendProgress(100)).Times(AtLeast(1));
+  EXPECT_CALL(mock_handler, SendSucceeded()).Times(1);
+  EXPECT_CALL(mock_handler, SendFailed(_)).Times(0);
+
+  temp_files_.InitializeImage();
+  temp_files_.InitializeFile(temp_files_.DevicePath(),
+                             kTestFileSize,
+                             kTestBytePattern);
+
+  image_writer->Verify(temp_files_.ImagePath(), temp_files_.DevicePath());
+
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(ImageWriterUtilityTest, VerifyInvalidImageFile) {
+  MockHandler mock_handler;
+  base::WeakPtrFactory<ImageWriterHandler> mock_handler_factory(&mock_handler);
+  scoped_refptr<ImageWriter> image_writer(
+      new ImageWriter(mock_handler_factory.GetWeakPtr()));
+
+  EXPECT_CALL(mock_handler, SendProgress(_)).Times(0);
+  EXPECT_CALL(mock_handler, SendSucceeded()).Times(0);
+  EXPECT_CALL(mock_handler, SendFailed(error::kOpenImage)).Times(1);
+
+  base::DeleteFile(temp_files_.ImagePath(), false);
+
+  image_writer->Verify(temp_files_.ImagePath(), temp_files_.DevicePath());
+
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(ImageWriterUtilityTest, VerifyInvalidDeviceFile) {
+  MockHandler mock_handler;
+  base::WeakPtrFactory<ImageWriterHandler> mock_handler_factory(&mock_handler);
+  scoped_refptr<ImageWriter> image_writer(
+      new ImageWriter(mock_handler_factory.GetWeakPtr()));
+
+  EXPECT_CALL(mock_handler, SendProgress(_)).Times(0);
+  EXPECT_CALL(mock_handler, SendSucceeded()).Times(0);
+  EXPECT_CALL(mock_handler, SendFailed(error::kOpenDevice)).Times(1);
+
+  base::DeleteFile(temp_files_.DevicePath(), false);
+
+  image_writer->Verify(temp_files_.ImagePath(), temp_files_.DevicePath());
+
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(ImageWriterUtilityTest, VerifyFailed) {
+  MockHandler mock_handler;
+  base::WeakPtrFactory<ImageWriterHandler> mock_handler_factory(&mock_handler);
+  scoped_refptr<ImageWriter> image_writer(
+      new ImageWriter(mock_handler_factory.GetWeakPtr()));
+
+  EXPECT_CALL(mock_handler, SendProgress(_)).Times(0);
+  EXPECT_CALL(mock_handler, SendSucceeded()).Times(0);
+  EXPECT_CALL(mock_handler, SendFailed(error::kVerificationFailed)).Times(1);
+
+  temp_files_.InitializeImage();
+  image_writer->Verify(temp_files_.ImagePath(), temp_files_.DevicePath());
+
+  base::RunLoop().RunUntilIdle();
+}
+
+
+} // namespace image_writer
+} // namespace chrome