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 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
44 | 44 |
45 private: | 45 private: |
46 BurnFinishedHandler burn_finished_handler_; | 46 BurnFinishedHandler burn_finished_handler_; |
47 BurnProgressUpdateHandler burn_progress_update_handler_; | 47 BurnProgressUpdateHandler burn_progress_update_handler_; |
48 | 48 |
49 }; | 49 }; |
50 | 50 |
51 } // namespace | 51 } // namespace |
52 #endif | 52 #endif |
53 | 53 |
54 QuittingMockManager::QuittingMockManager(const base::Closure& quit_closure) | |
55 : quit_closure_(quit_closure) {} | |
56 | |
57 void QuittingMockManager::OnComplete(const ExtensionId& extension_id) { | |
58 MockOperationManager::OnComplete(extension_id); | |
59 quit_closure_.Run(); | |
60 } | |
61 | |
62 void QuittingMockManager::OnError(const ExtensionId& extension_id, | |
63 image_writer_api::Stage stage, | |
64 int progress, | |
65 const std::string& error_message) { | |
66 MockOperationManager::OnError(extension_id, stage, progress, error_message); | |
67 quit_closure_.Run(); | |
68 } | |
69 | |
54 MockOperationManager::MockOperationManager() : OperationManager(NULL) {} | 70 MockOperationManager::MockOperationManager() : OperationManager(NULL) {} |
55 MockOperationManager::~MockOperationManager() {} | 71 MockOperationManager::~MockOperationManager() {} |
56 | 72 |
57 ImageWriterUnitTestBase::ImageWriterUnitTestBase() {} | 73 ImageWriterUnitTestBase::ImageWriterUnitTestBase() |
74 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {} | |
58 ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {} | 75 ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {} |
59 | 76 |
60 void ImageWriterUnitTestBase::SetUp() { | 77 void ImageWriterUnitTestBase::SetUp() { |
61 testing::Test::SetUp(); | 78 testing::Test::SetUp(); |
79 | |
62 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); | 80 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
63 | |
64 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), | 81 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), |
65 &test_image_path_)); | 82 &test_image_path_)); |
66 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), | 83 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), |
67 &test_device_path_)); | 84 &test_device_path_)); |
68 | 85 |
69 ASSERT_TRUE(FillFile(test_image_path_, kImagePattern, kTestFileSize)); | 86 ASSERT_TRUE(FillFile(test_image_path_, kImagePattern, kTestFileSize)); |
70 ASSERT_TRUE(FillFile(test_device_path_, kDevicePattern, kTestFileSize)); | 87 ASSERT_TRUE(FillFile(test_device_path_, kDevicePattern, kTestFileSize)); |
71 | 88 |
72 #if defined(OS_CHROMEOS) | 89 #if defined(OS_CHROMEOS) |
73 if (!chromeos::DBusThreadManager::IsInitialized()) { | 90 if (!chromeos::DBusThreadManager::IsInitialized()) { |
74 chromeos::FakeDBusThreadManager* fake_dbus_thread_manager = | 91 chromeos::FakeDBusThreadManager* fake_dbus_thread_manager = |
75 new chromeos::FakeDBusThreadManager; | 92 new chromeos::FakeDBusThreadManager; |
76 scoped_ptr<chromeos::ImageBurnerClient> | 93 scoped_ptr<chromeos::ImageBurnerClient> |
77 image_burner_fake(new ImageWriterFakeImageBurnerClient()); | 94 image_burner_fake(new ImageWriterFakeImageBurnerClient()); |
78 fake_dbus_thread_manager->SetImageBurnerClient(image_burner_fake.Pass()); | 95 fake_dbus_thread_manager->SetImageBurnerClient(image_burner_fake.Pass()); |
79 chromeos::DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager); | 96 chromeos::DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager); |
80 } | 97 } |
81 #endif | 98 #endif |
82 } | 99 } |
83 | 100 |
84 void ImageWriterUnitTestBase::TearDown() { | 101 void ImageWriterUnitTestBase::TearDown() { |
85 #if defined(OS_CHROMEOS) | 102 #if defined(OS_CHROMEOS) |
86 chromeos::DBusThreadManager::Shutdown(); | 103 chromeos::DBusThreadManager::Shutdown(); |
87 #endif | 104 #endif |
88 } | 105 } |
89 | 106 |
90 bool ImageWriterUnitTestBase::CompareImageAndDevice() { | 107 bool ImageWriterUnitTestBase::ImageWrittenToDevice( |
108 const base::FilePath& image_path, | |
109 const base::FilePath& device_path) { | |
91 scoped_ptr<char[]> image_buffer(new char[kTestFileSize]); | 110 scoped_ptr<char[]> image_buffer(new char[kTestFileSize]); |
92 scoped_ptr<char[]> device_buffer(new char[kTestFileSize]); | 111 scoped_ptr<char[]> device_buffer(new char[kTestFileSize]); |
93 | 112 |
94 while (true) { | 113 int image_bytes_read = |
95 int image_bytes_read = ReadFile(test_image_path_, | 114 ReadFile(image_path, image_buffer.get(), kTestFileSize); |
96 image_buffer.get(), | 115 ReadFile(device_path, device_buffer.get(), kTestFileSize); |
Lei Zhang
2014/02/15 00:26:59
Why aren't you checking the return value here anym
Drew Haven
2014/02/15 01:23:58
I think i assumed the memcmp would do the work, bu
| |
97 kTestFileSize); | |
98 int device_bytes_read = ReadFile(test_device_path_, | |
99 device_buffer.get(), | |
100 kTestFileSize); | |
101 | 116 |
102 if (image_bytes_read != device_bytes_read) | 117 return memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) == 0; |
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 } | 118 } |
114 | 119 |
115 bool ImageWriterUnitTestBase::FillFile(const base::FilePath& file, | 120 bool ImageWriterUnitTestBase::FillFile(const base::FilePath& file, |
116 const int pattern, | 121 const int pattern, |
117 const int length) { | 122 const int length) { |
118 scoped_ptr<char[]> buffer(new char[length]); | 123 scoped_ptr<char[]> buffer(new char[length]); |
119 memset(buffer.get(), pattern, length); | 124 memset(buffer.get(), pattern, length); |
120 | 125 |
121 return file_util::WriteFile(file, buffer.get(), length) == length; | 126 return file_util::WriteFile(file, buffer.get(), length) == length; |
122 } | 127 } |
123 | 128 |
124 } // namespace image_writer | 129 } // namespace image_writer |
125 } // namespace extensions | 130 } // namespace extensions |
OLD | NEW |