src/chrome/browser/extensions/api/image_writer_private/test_utils.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/image_writer_private/test_utils.h"
   6
   7 #if defined(OS_CHROMEOS)
   8 #include "chromeos/dbus/dbus_thread_manager.h"
   9 #include "chromeos/dbus/fake_dbus_thread_manager.h"
  10 #include "chromeos/dbus/fake_image_burner_client.h"
  11 #endif
  12
  13 namespace extensions {
  14 namespace image_writer {
  15
  16 #if defined(OS_CHROMEOS)
  17 namespace {
  18
  19 class ImageWriterFakeImageBurnerClient
  20     : public chromeos::FakeImageBurnerClient {
  21  public:
  22   ImageWriterFakeImageBurnerClient() {}
  23   virtual ~ImageWriterFakeImageBurnerClient() {}
  24
  25   virtual void SetEventHandlers(
  26       const BurnFinishedHandler& burn_finished_handler,
  27       const BurnProgressUpdateHandler& burn_progress_update_handler) OVERRIDE {
  28     burn_finished_handler_ = burn_finished_handler;
  29     burn_progress_update_handler_ = burn_progress_update_handler;
  30   }
  31
  32   virtual void BurnImage(const std::string& from_path,
  33                          const std::string& to_path,
  34                          const ErrorCallback& error_callback) OVERRIDE {
  35     base::MessageLoop::current()->PostTask(FROM_HERE,
  36         base::Bind(burn_progress_update_handler_, to_path, 0, 100));
  37     base::MessageLoop::current()->PostTask(FROM_HERE,
  38         base::Bind(burn_progress_update_handler_, to_path, 50, 100));
  39     base::MessageLoop::current()->PostTask(FROM_HERE,
  40         base::Bind(burn_progress_update_handler_, to_path, 100, 100));
  41     base::MessageLoop::current()->PostTask(FROM_HERE,
  42         base::Bind(burn_finished_handler_, to_path, true, ""));
  43   }
  44
  45  private:
  46   BurnFinishedHandler burn_finished_handler_;
  47   BurnProgressUpdateHandler burn_progress_update_handler_;
  48
  49 };
  50
  51 } // namespace
  52 #endif
  53
  54 MockOperationManager::MockOperationManager() : OperationManager(NULL) {}
  55 MockOperationManager::~MockOperationManager() {}
  56
  57 ImageWriterUnitTestBase::ImageWriterUnitTestBase() {}
  58 ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {}
  59
  60 void ImageWriterUnitTestBase::SetUp() {
  61   testing::Test::SetUp();
  62   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  63
  64   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
  65                                              &test_image_path_));
  66   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
  67                                              &test_device_path_));
  68
  69   ASSERT_TRUE(FillFile(test_image_path_, kImagePattern, kTestFileSize));
  70   ASSERT_TRUE(FillFile(test_device_path_, kDevicePattern, kTestFileSize));
  71
  72 #if defined(OS_CHROMEOS)
  73   if (!chromeos::DBusThreadManager::IsInitialized()) {
  74     chromeos::FakeDBusThreadManager* fake_dbus_thread_manager =
  75         new chromeos::FakeDBusThreadManager;
  76     scoped_ptr<chromeos::ImageBurnerClient>
  77         image_burner_fake(new ImageWriterFakeImageBurnerClient());
  78     fake_dbus_thread_manager->SetImageBurnerClient(image_burner_fake.Pass());
  79     chromeos::DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager);
  80   }
  81 #endif
  82 }
  83
  84 void ImageWriterUnitTestBase::TearDown() {
  85 #if defined(OS_CHROMEOS)
  86   chromeos::DBusThreadManager::Shutdown();
  87 #endif
  88 }
  89
  90 bool ImageWriterUnitTestBase::CompareImageAndDevice() {
  91   scoped_ptr<char[]> image_buffer(new char[kTestFileSize]);
  92   scoped_ptr<char[]> device_buffer(new char[kTestFileSize]);
  93
  94   while (true) {
  95     int image_bytes_read = ReadFile(test_image_path_,
  96                                     image_buffer.get(),
  97                                     kTestFileSize);
  98     int device_bytes_read = ReadFile(test_device_path_,
  99                                      device_buffer.get(),
 100                                      kTestFileSize);
 101
 102     if (image_bytes_read != device_bytes_read)
 103       return false;
 104
 105     if (image_bytes_read == 0)
 106       return true;
 107
 108     if (memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) != 0)
 109       return false;
 110   }
 111
 112   return false;
 113 }
 114
 115 bool ImageWriterUnitTestBase::FillFile(const base::FilePath& file,
 116                                        const int pattern,
 117                                        const int length) {
 118   scoped_ptr<char[]> buffer(new char[length]);
 119   memset(buffer.get(), pattern, length);
 120
 121   return file_util::WriteFile(file, buffer.get(), length) == length;
 122 }
 123
 124 }  // namespace image_writer
 125 }  // namespace extensions