OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/extensions/api/image_writer_private/test_utils.h" | 5 #include "chrome/browser/extensions/api/image_writer_private/test_utils.h" |
6 | 6 |
7 #if defined(OS_CHROMEOS) | 7 #if defined(OS_CHROMEOS) |
8 #include "chromeos/dbus/dbus_thread_manager.h" | 8 #include "chromeos/dbus/dbus_thread_manager.h" |
9 #include "chromeos/dbus/fake_dbus_thread_manager.h" | 9 #include "chromeos/dbus/fake_dbus_thread_manager.h" |
10 #include "chromeos/dbus/fake_image_burner_client.h" | 10 #include "chromeos/dbus/fake_image_burner_client.h" |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
48 }; | 48 }; |
49 | 49 |
50 } // namespace | 50 } // namespace |
51 #endif | 51 #endif |
52 | 52 |
53 MockOperationManager::MockOperationManager() : OperationManager(NULL) {} | 53 MockOperationManager::MockOperationManager() : OperationManager(NULL) {} |
54 MockOperationManager::MockOperationManager(Profile* profile) | 54 MockOperationManager::MockOperationManager(Profile* profile) |
55 : OperationManager(profile) {} | 55 : OperationManager(profile) {} |
56 MockOperationManager::~MockOperationManager() {} | 56 MockOperationManager::~MockOperationManager() {} |
57 | 57 |
| 58 FakeImageWriterClient::FakeImageWriterClient() {} |
| 59 FakeImageWriterClient::~FakeImageWriterClient() {} |
| 60 |
| 61 void FakeImageWriterClient::Write(const ProgressCallback& progress_callback, |
| 62 const SuccessCallback& success_callback, |
| 63 const ErrorCallback& error_callback, |
| 64 const base::FilePath& source, |
| 65 const base::FilePath& target) { |
| 66 progress_callback_ = progress_callback; |
| 67 success_callback_ = success_callback; |
| 68 error_callback_ = error_callback; |
| 69 } |
| 70 |
| 71 void FakeImageWriterClient::Verify(const ProgressCallback& progress_callback, |
| 72 const SuccessCallback& success_callback, |
| 73 const ErrorCallback& error_callback, |
| 74 const base::FilePath& source, |
| 75 const base::FilePath& target) { |
| 76 progress_callback_ = progress_callback; |
| 77 success_callback_ = success_callback; |
| 78 error_callback_ = error_callback; |
| 79 } |
| 80 |
| 81 void FakeImageWriterClient::Cancel(const CancelCallback& cancel_callback) { |
| 82 cancel_callback_ = cancel_callback; |
| 83 } |
| 84 |
| 85 void FakeImageWriterClient::Shutdown() { |
| 86 // Clear handlers to not hold any reference to the caller. |
| 87 success_callback_ = base::Closure(); |
| 88 progress_callback_ = base::Callback<void(int64)>(); |
| 89 error_callback_ = base::Callback<void(const std::string&)>(); |
| 90 cancel_callback_ = base::Closure(); |
| 91 } |
| 92 |
| 93 void FakeImageWriterClient::Progress(int64 progress) { |
| 94 progress_callback_.Run(progress); |
| 95 } |
| 96 |
| 97 void FakeImageWriterClient::Success() { success_callback_.Run(); } |
| 98 |
| 99 void FakeImageWriterClient::Error(const std::string& message) { |
| 100 error_callback_.Run(message); |
| 101 } |
| 102 |
| 103 void FakeImageWriterClient::Cancel() { cancel_callback_.Run(); } |
| 104 |
| 105 scoped_refptr<FakeImageWriterClient> FakeImageWriterClient::Create() { |
| 106 return scoped_refptr<FakeImageWriterClient>(new FakeImageWriterClient()); |
| 107 } |
| 108 |
58 ImageWriterUnitTestBase::ImageWriterUnitTestBase() | 109 ImageWriterUnitTestBase::ImageWriterUnitTestBase() |
59 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {} | 110 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {} |
60 ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {} | 111 ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {} |
61 | 112 |
62 void ImageWriterUnitTestBase::SetUp() { | 113 void ImageWriterUnitTestBase::SetUp() { |
63 testing::Test::SetUp(); | 114 testing::Test::SetUp(); |
| 115 |
64 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); | 116 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
65 | |
66 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), | 117 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), |
67 &test_image_path_)); | 118 &test_image_path_)); |
68 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), | 119 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), |
69 &test_device_path_)); | 120 &test_device_path_)); |
70 | 121 |
71 ASSERT_TRUE(FillFile(test_image_path_, kImagePattern, kTestFileSize)); | 122 ASSERT_TRUE(FillFile(test_image_path_, kImagePattern, kTestFileSize)); |
72 ASSERT_TRUE(FillFile(test_device_path_, kDevicePattern, kTestFileSize)); | 123 ASSERT_TRUE(FillFile(test_device_path_, kDevicePattern, kTestFileSize)); |
73 | 124 |
74 #if defined(OS_CHROMEOS) | 125 #if defined(OS_CHROMEOS) |
75 if (!chromeos::DBusThreadManager::IsInitialized()) { | 126 if (!chromeos::DBusThreadManager::IsInitialized()) { |
76 chromeos::FakeDBusThreadManager* fake_dbus_thread_manager = | 127 chromeos::FakeDBusThreadManager* fake_dbus_thread_manager = |
77 new chromeos::FakeDBusThreadManager; | 128 new chromeos::FakeDBusThreadManager; |
78 scoped_ptr<chromeos::ImageBurnerClient> | 129 scoped_ptr<chromeos::ImageBurnerClient> |
79 image_burner_fake(new ImageWriterFakeImageBurnerClient()); | 130 image_burner_fake(new ImageWriterFakeImageBurnerClient()); |
80 fake_dbus_thread_manager->SetImageBurnerClient(image_burner_fake.Pass()); | 131 fake_dbus_thread_manager->SetImageBurnerClient(image_burner_fake.Pass()); |
81 chromeos::DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager); | 132 chromeos::DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager); |
82 } | 133 } |
83 #endif | 134 #endif |
84 } | 135 } |
85 | 136 |
86 void ImageWriterUnitTestBase::TearDown() { | 137 void ImageWriterUnitTestBase::TearDown() { |
87 #if defined(OS_CHROMEOS) | 138 #if defined(OS_CHROMEOS) |
88 chromeos::DBusThreadManager::Shutdown(); | 139 chromeos::DBusThreadManager::Shutdown(); |
89 #endif | 140 #endif |
90 } | 141 } |
91 | 142 |
| 143 bool ImageWriterUnitTestBase::ImageWrittenToDevice( |
| 144 const base::FilePath& image_path, |
| 145 const base::FilePath& device_path) { |
| 146 scoped_ptr<char[]> image_buffer(new char[kTestFileSize]); |
| 147 scoped_ptr<char[]> device_buffer(new char[kTestFileSize]); |
| 148 |
| 149 int image_bytes_read = |
| 150 ReadFile(image_path, image_buffer.get(), kTestFileSize); |
| 151 |
| 152 if (image_bytes_read < 0) |
| 153 return false; |
| 154 |
| 155 int device_bytes_read = |
| 156 ReadFile(device_path, device_buffer.get(), kTestFileSize); |
| 157 |
| 158 if (image_bytes_read != device_bytes_read) |
| 159 return false; |
| 160 |
| 161 return memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) == 0; |
| 162 } |
| 163 |
92 bool ImageWriterUnitTestBase::FillFile(const base::FilePath& file, | 164 bool ImageWriterUnitTestBase::FillFile(const base::FilePath& file, |
93 const int pattern, | 165 const int pattern, |
94 const int length) { | 166 const int length) { |
95 scoped_ptr<char[]> buffer(new char[length]); | 167 scoped_ptr<char[]> buffer(new char[length]); |
96 memset(buffer.get(), pattern, length); | 168 memset(buffer.get(), pattern, length); |
97 | 169 |
98 return file_util::WriteFile(file, buffer.get(), length) == length; | 170 return file_util::WriteFile(file, buffer.get(), length) == length; |
99 } | 171 } |
100 | 172 |
101 } // namespace image_writer | 173 } // namespace image_writer |
102 } // namespace extensions | 174 } // namespace extensions |
OLD | NEW |