Web MIDI: running status should be reset on receiving a system message
[chromium-blink-merge.git] / components / search_provider_logos / logo_cache_unittest.cc
bloba483c988e1ccfd5d2e408747f281c7ac293fa978
1 // Copyright 2014 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.
5 #include "components/search_provider_logos/logo_cache.h"
7 #include <string>
9 #include "base/bind.h"
10 #include "base/callback.h"
11 #include "base/files/file_util.h"
12 #include "base/files/scoped_temp_dir.h"
13 #include "base/run_loop.h"
14 #include "base/time/time.h"
15 #include "testing/gtest/include/gtest/gtest.h"
17 namespace search_provider_logos {
19 LogoMetadata GetExampleMetadata() {
20 LogoMetadata metadata;
21 metadata.source_url = "http://google.com/mylogo";
22 metadata.fingerprint = "LC4JVIZ5HVITQFKH0V70";
23 EXPECT_TRUE(base::Time::FromString("98-05-05 05:05:06 GMT",
24 &metadata.expiration_time));
25 metadata.can_show_after_expiration = true;
26 metadata.on_click_url = "https://www.google.com/search?q=chicken";
27 metadata.alt_text = "A logo about chickens";
28 metadata.mime_type = "image/jpeg";
29 return metadata;
32 LogoMetadata GetExampleMetadata2() {
33 LogoMetadata metadata;
34 metadata.source_url = "https://www.example.com/thebestlogo?size=large";
35 metadata.fingerprint = "bh4PLHdnEaQAPxNGRyMao1rOmVFTXuOdVhdrMmPV";
36 EXPECT_TRUE(base::Time::FromString("17-04-04 07:10:58 GMT",
37 &metadata.expiration_time));
38 metadata.can_show_after_expiration = false;
39 metadata.on_click_url = "http://www.example.co.uk/welcome.php#top";
40 metadata.alt_text = "This is a logo";
41 metadata.mime_type = "image/png";
42 return metadata;
45 base::RefCountedString* CreateExampleImage(size_t num_bytes) {
46 base::RefCountedString* encoded_image_str = new base::RefCountedString();
47 std::string& str = encoded_image_str->data();
48 str.resize(num_bytes);
49 for (size_t i = 0; i < num_bytes; ++i)
50 str[i] = static_cast<char>(i);
51 return encoded_image_str;
54 EncodedLogo GetExampleLogo() {
55 EncodedLogo logo;
56 logo.encoded_image = CreateExampleImage(837);
57 logo.metadata = GetExampleMetadata();
58 return logo;
61 EncodedLogo GetExampleLogo2() {
62 EncodedLogo logo;
63 logo.encoded_image = CreateExampleImage(345);
64 logo.metadata = GetExampleMetadata2();
65 return logo;
68 void ExpectMetadataEqual(const LogoMetadata& expected_metadata,
69 const LogoMetadata& actual_metadata) {
70 EXPECT_EQ(expected_metadata.source_url, actual_metadata.source_url);
71 EXPECT_EQ(expected_metadata.fingerprint, actual_metadata.fingerprint);
72 EXPECT_EQ(expected_metadata.can_show_after_expiration,
73 actual_metadata.can_show_after_expiration);
74 EXPECT_EQ(expected_metadata.expiration_time, actual_metadata.expiration_time);
75 EXPECT_EQ(expected_metadata.on_click_url, actual_metadata.on_click_url);
76 EXPECT_EQ(expected_metadata.alt_text, actual_metadata.alt_text);
77 EXPECT_EQ(expected_metadata.mime_type, actual_metadata.mime_type);
80 void ExpectLogosEqual(const EncodedLogo& expected_logo,
81 const EncodedLogo& actual_logo) {
82 ASSERT_TRUE(expected_logo.encoded_image.get());
83 ASSERT_TRUE(actual_logo.encoded_image.get());
84 EXPECT_TRUE(expected_logo.encoded_image->Equals(actual_logo.encoded_image));
85 ExpectMetadataEqual(expected_logo.metadata, actual_logo.metadata);
88 // Removes 1 byte from the end of the file at |path|.
89 void ShortenFile(base::FilePath path) {
90 base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_WRITE);
91 int64 file_length = file.GetLength();
92 ASSERT_NE(file_length, 0);
93 file.SetLength(file_length - 1);
96 class LogoCacheTest : public ::testing::Test {
97 protected:
98 void SetUp() override {
99 ASSERT_TRUE(cache_parent_dir_.CreateUniqueTempDir());
100 InitCache();
103 void InitCache() {
104 cache_.reset(new LogoCache(
105 cache_parent_dir_.path().Append(FILE_PATH_LITERAL("cache"))));
108 void ExpectMetadata(const LogoMetadata* expected_metadata) {
109 const LogoMetadata* retrieved_metadata = cache_->GetCachedLogoMetadata();
110 if (expected_metadata) {
111 ASSERT_TRUE(retrieved_metadata != NULL);
112 ExpectMetadataEqual(*expected_metadata, *retrieved_metadata);
113 } else {
114 ASSERT_TRUE(retrieved_metadata == NULL);
118 void ExpectLogo(const EncodedLogo* expected_logo) {
119 scoped_ptr<EncodedLogo> retrieved_logo(cache_->GetCachedLogo());
120 if (expected_logo) {
121 ASSERT_TRUE(retrieved_logo.get() != NULL);
122 ExpectLogosEqual(*expected_logo, *retrieved_logo);
123 } else {
124 ASSERT_TRUE(retrieved_logo.get() == NULL);
128 // Deletes the existing LogoCache and creates a new one. This clears any
129 // logo or metadata cached in memory to simulate restarting Chrome.
130 void SimulateRestart() {
131 InitCache();
134 scoped_ptr<LogoCache> cache_;
135 base::ScopedTempDir cache_parent_dir_;
138 // Tests -----------------------------------------------------------------------
140 TEST(LogoCacheSerializationTest, SerializeMetadata) {
141 LogoMetadata metadata = GetExampleMetadata();
142 std::string metadata_str;
143 int logo_num_bytes = 33;
144 LogoCache::LogoMetadataToString(metadata, logo_num_bytes, &metadata_str);
145 scoped_ptr<LogoMetadata> metadata2 =
146 LogoCache::LogoMetadataFromString(metadata_str, &logo_num_bytes);
147 ASSERT_TRUE(metadata2);
148 ExpectMetadataEqual(metadata, *metadata2);
151 TEST(LogoCacheSerializationTest, DeserializeCorruptMetadata) {
152 int logo_num_bytes = 33;
153 scoped_ptr<LogoMetadata> metadata =
154 LogoCache::LogoMetadataFromString("", &logo_num_bytes);
155 ASSERT_TRUE(metadata.get() == NULL);
157 LogoMetadata example_metadata = GetExampleMetadata2();
158 std::string corrupt_str;
159 LogoCache::LogoMetadataToString(
160 example_metadata, logo_num_bytes, &corrupt_str);
161 corrupt_str.append("@");
162 metadata = LogoCache::LogoMetadataFromString(corrupt_str, &logo_num_bytes);
163 ASSERT_TRUE(metadata.get() == NULL);
166 TEST_F(LogoCacheTest, StoreAndRetrieveMetadata) {
167 // Expect no metadata at first.
168 ExpectMetadata(NULL);
170 // Set initial metadata.
171 EncodedLogo logo = GetExampleLogo();
172 LogoMetadata& metadata = logo.metadata;
173 cache_->SetCachedLogo(&logo);
174 ExpectMetadata(&metadata);
176 // Update metadata.
177 metadata.on_click_url = "http://anotherwebsite.com";
178 cache_->UpdateCachedLogoMetadata(metadata);
179 ExpectMetadata(&metadata);
181 // Read metadata back from disk.
182 SimulateRestart();
183 ExpectMetadata(&metadata);
185 // Ensure metadata is cached in memory.
186 base::DeleteFile(cache_->GetMetadataPath(), false);
187 ExpectMetadata(&metadata);
190 TEST_F(LogoCacheTest, StoreAndRetrieveLogo) {
191 // Expect no metadata at first.
192 ExpectLogo(NULL);
194 // Set initial logo.
195 EncodedLogo logo = GetExampleLogo();
196 cache_->SetCachedLogo(&logo);
197 ExpectLogo(&logo);
199 // Update logo to NULL.
200 cache_->SetCachedLogo(NULL);
201 ExpectLogo(NULL);
203 // Read logo back from disk.
204 SimulateRestart();
205 ExpectLogo(NULL);
207 // Update logo.
208 logo = GetExampleLogo2();
209 cache_->SetCachedLogo(&logo);
210 ExpectLogo(&logo);
212 // Read logo back from disk.
213 SimulateRestart();
214 ExpectLogo(&logo);
217 TEST_F(LogoCacheTest, RetrieveCorruptMetadata) {
218 // Set initial logo.
219 EncodedLogo logo = GetExampleLogo2();
220 cache_->SetCachedLogo(&logo);
221 ExpectLogo(&logo);
223 // Corrupt metadata and expect NULL for both logo and metadata.
224 SimulateRestart();
225 ShortenFile(cache_->GetMetadataPath());
226 ExpectMetadata(NULL);
227 ExpectLogo(NULL);
229 // Ensure corrupt cache files are deleted.
230 EXPECT_FALSE(base::PathExists(cache_->GetMetadataPath()));
231 EXPECT_FALSE(base::PathExists(cache_->GetLogoPath()));
234 TEST_F(LogoCacheTest, RetrieveCorruptLogo) {
235 // Set initial logo.
236 EncodedLogo logo = GetExampleLogo();
237 cache_->SetCachedLogo(&logo);
238 ExpectLogo(&logo);
240 // Corrupt logo and expect NULL.
241 SimulateRestart();
242 ShortenFile(cache_->GetLogoPath());
243 ExpectLogo(NULL);
244 // Once the logo is noticed to be NULL, the metadata should also be cleared.
245 ExpectMetadata(NULL);
247 // Ensure corrupt cache files are deleted.
248 EXPECT_FALSE(base::PathExists(cache_->GetMetadataPath()));
249 EXPECT_FALSE(base::PathExists(cache_->GetLogoPath()));
252 } // namespace search_provider_logos