OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "webkit/fileapi/file_system_usage_cache.h" | 5 #include "webkit/fileapi/file_system_usage_cache.h" |
6 | 6 |
7 #include "base/basictypes.h" | 7 #include "base/basictypes.h" |
8 #include "base/file_util.h" | 8 #include "base/file_util.h" |
9 #include "base/files/scoped_temp_dir.h" | 9 #include "base/files/scoped_temp_dir.h" |
10 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
11 | 11 |
12 namespace fileapi { | 12 namespace fileapi { |
13 | 13 |
14 class FileSystemUsageCacheTest : public testing::Test { | 14 class FileSystemUsageCacheTest : public testing::Test { |
15 public: | 15 public: |
16 FileSystemUsageCacheTest() {} | 16 FileSystemUsageCacheTest() {} |
17 | 17 |
18 void SetUp() { | 18 void SetUp() { |
19 ASSERT_TRUE(data_dir_.CreateUniqueTempDir()); | 19 ASSERT_TRUE(data_dir_.CreateUniqueTempDir()); |
20 } | 20 } |
21 | 21 |
22 protected: | 22 protected: |
23 FilePath GetUsageFilePath() { | 23 base::FilePath GetUsageFilePath() { |
24 return data_dir_.path().Append(FileSystemUsageCache::kUsageFileName); | 24 return data_dir_.path().Append(FileSystemUsageCache::kUsageFileName); |
25 } | 25 } |
26 | 26 |
27 private: | 27 private: |
28 base::ScopedTempDir data_dir_; | 28 base::ScopedTempDir data_dir_; |
29 | 29 |
30 DISALLOW_COPY_AND_ASSIGN(FileSystemUsageCacheTest); | 30 DISALLOW_COPY_AND_ASSIGN(FileSystemUsageCacheTest); |
31 }; | 31 }; |
32 | 32 |
33 TEST_F(FileSystemUsageCacheTest, CreateTest) { | 33 TEST_F(FileSystemUsageCacheTest, CreateTest) { |
34 FilePath usage_file_path = GetUsageFilePath(); | 34 base::FilePath usage_file_path = GetUsageFilePath(); |
35 EXPECT_EQ(FileSystemUsageCache::kUsageFileSize, | 35 EXPECT_EQ(FileSystemUsageCache::kUsageFileSize, |
36 FileSystemUsageCache::UpdateUsage(usage_file_path, 0)); | 36 FileSystemUsageCache::UpdateUsage(usage_file_path, 0)); |
37 } | 37 } |
38 | 38 |
39 TEST_F(FileSystemUsageCacheTest, SetSizeTest) { | 39 TEST_F(FileSystemUsageCacheTest, SetSizeTest) { |
40 static const int64 size = 240122; | 40 static const int64 size = 240122; |
41 FilePath usage_file_path = GetUsageFilePath(); | 41 base::FilePath usage_file_path = GetUsageFilePath(); |
42 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, | 42 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, |
43 FileSystemUsageCache::UpdateUsage(usage_file_path, size)); | 43 FileSystemUsageCache::UpdateUsage(usage_file_path, size)); |
44 EXPECT_EQ(size, FileSystemUsageCache::GetUsage(usage_file_path)); | 44 EXPECT_EQ(size, FileSystemUsageCache::GetUsage(usage_file_path)); |
45 } | 45 } |
46 | 46 |
47 TEST_F(FileSystemUsageCacheTest, SetLargeSizeTest) { | 47 TEST_F(FileSystemUsageCacheTest, SetLargeSizeTest) { |
48 static const int64 size = kint64max; | 48 static const int64 size = kint64max; |
49 FilePath usage_file_path = GetUsageFilePath(); | 49 base::FilePath usage_file_path = GetUsageFilePath(); |
50 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, | 50 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, |
51 FileSystemUsageCache::UpdateUsage(usage_file_path, size)); | 51 FileSystemUsageCache::UpdateUsage(usage_file_path, size)); |
52 EXPECT_EQ(size, FileSystemUsageCache::GetUsage(usage_file_path)); | 52 EXPECT_EQ(size, FileSystemUsageCache::GetUsage(usage_file_path)); |
53 } | 53 } |
54 | 54 |
55 TEST_F(FileSystemUsageCacheTest, IncAndGetSizeTest) { | 55 TEST_F(FileSystemUsageCacheTest, IncAndGetSizeTest) { |
56 FilePath usage_file_path = GetUsageFilePath(); | 56 base::FilePath usage_file_path = GetUsageFilePath(); |
57 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, | 57 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, |
58 FileSystemUsageCache::UpdateUsage(usage_file_path, 98214)); | 58 FileSystemUsageCache::UpdateUsage(usage_file_path, 98214)); |
59 ASSERT_TRUE(FileSystemUsageCache::IncrementDirty(usage_file_path)); | 59 ASSERT_TRUE(FileSystemUsageCache::IncrementDirty(usage_file_path)); |
60 EXPECT_EQ(1, FileSystemUsageCache::GetDirty(usage_file_path)); | 60 EXPECT_EQ(1, FileSystemUsageCache::GetDirty(usage_file_path)); |
61 EXPECT_EQ(98214, FileSystemUsageCache::GetUsage(usage_file_path)); | 61 EXPECT_EQ(98214, FileSystemUsageCache::GetUsage(usage_file_path)); |
62 } | 62 } |
63 | 63 |
64 TEST_F(FileSystemUsageCacheTest, DecAndGetSizeTest) { | 64 TEST_F(FileSystemUsageCacheTest, DecAndGetSizeTest) { |
65 static const int64 size = 71839; | 65 static const int64 size = 71839; |
66 FilePath usage_file_path = GetUsageFilePath(); | 66 base::FilePath usage_file_path = GetUsageFilePath(); |
67 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, | 67 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, |
68 FileSystemUsageCache::UpdateUsage(usage_file_path, size)); | 68 FileSystemUsageCache::UpdateUsage(usage_file_path, size)); |
69 // DecrementDirty for dirty = 0 is invalid. It returns false. | 69 // DecrementDirty for dirty = 0 is invalid. It returns false. |
70 ASSERT_FALSE(FileSystemUsageCache::DecrementDirty(usage_file_path)); | 70 ASSERT_FALSE(FileSystemUsageCache::DecrementDirty(usage_file_path)); |
71 EXPECT_EQ(size, FileSystemUsageCache::GetUsage(usage_file_path)); | 71 EXPECT_EQ(size, FileSystemUsageCache::GetUsage(usage_file_path)); |
72 } | 72 } |
73 | 73 |
74 TEST_F(FileSystemUsageCacheTest, IncDecAndGetSizeTest) { | 74 TEST_F(FileSystemUsageCacheTest, IncDecAndGetSizeTest) { |
75 static const int64 size = 198491; | 75 static const int64 size = 198491; |
76 FilePath usage_file_path = GetUsageFilePath(); | 76 base::FilePath usage_file_path = GetUsageFilePath(); |
77 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, | 77 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, |
78 FileSystemUsageCache::UpdateUsage(usage_file_path, size)); | 78 FileSystemUsageCache::UpdateUsage(usage_file_path, size)); |
79 ASSERT_TRUE(FileSystemUsageCache::IncrementDirty(usage_file_path)); | 79 ASSERT_TRUE(FileSystemUsageCache::IncrementDirty(usage_file_path)); |
80 ASSERT_TRUE(FileSystemUsageCache::DecrementDirty(usage_file_path)); | 80 ASSERT_TRUE(FileSystemUsageCache::DecrementDirty(usage_file_path)); |
81 EXPECT_EQ(size, FileSystemUsageCache::GetUsage(usage_file_path)); | 81 EXPECT_EQ(size, FileSystemUsageCache::GetUsage(usage_file_path)); |
82 } | 82 } |
83 | 83 |
84 TEST_F(FileSystemUsageCacheTest, DecIncAndGetSizeTest) { | 84 TEST_F(FileSystemUsageCacheTest, DecIncAndGetSizeTest) { |
85 FilePath usage_file_path = GetUsageFilePath(); | 85 base::FilePath usage_file_path = GetUsageFilePath(); |
86 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, | 86 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, |
87 FileSystemUsageCache::UpdateUsage(usage_file_path, 854238)); | 87 FileSystemUsageCache::UpdateUsage(usage_file_path, 854238)); |
88 // DecrementDirty for dirty = 0 is invalid. It returns false. | 88 // DecrementDirty for dirty = 0 is invalid. It returns false. |
89 ASSERT_FALSE(FileSystemUsageCache::DecrementDirty(usage_file_path)); | 89 ASSERT_FALSE(FileSystemUsageCache::DecrementDirty(usage_file_path)); |
90 ASSERT_TRUE(FileSystemUsageCache::IncrementDirty(usage_file_path)); | 90 ASSERT_TRUE(FileSystemUsageCache::IncrementDirty(usage_file_path)); |
91 // It tests DecrementDirty (which returns false) has no effect, i.e | 91 // It tests DecrementDirty (which returns false) has no effect, i.e |
92 // does not make dirty = -1 after DecrementDirty. | 92 // does not make dirty = -1 after DecrementDirty. |
93 EXPECT_EQ(1, FileSystemUsageCache::GetDirty(usage_file_path)); | 93 EXPECT_EQ(1, FileSystemUsageCache::GetDirty(usage_file_path)); |
94 EXPECT_EQ(854238, FileSystemUsageCache::GetUsage(usage_file_path)); | 94 EXPECT_EQ(854238, FileSystemUsageCache::GetUsage(usage_file_path)); |
95 } | 95 } |
96 | 96 |
97 TEST_F(FileSystemUsageCacheTest, ManyIncsSameDecsAndGetSizeTest) { | 97 TEST_F(FileSystemUsageCacheTest, ManyIncsSameDecsAndGetSizeTest) { |
98 static const int64 size = 82412; | 98 static const int64 size = 82412; |
99 FilePath usage_file_path = GetUsageFilePath(); | 99 base::FilePath usage_file_path = GetUsageFilePath(); |
100 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, | 100 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, |
101 FileSystemUsageCache::UpdateUsage(usage_file_path, size)); | 101 FileSystemUsageCache::UpdateUsage(usage_file_path, size)); |
102 for (int i = 0; i < 20; i++) | 102 for (int i = 0; i < 20; i++) |
103 ASSERT_TRUE(FileSystemUsageCache::IncrementDirty(usage_file_path)); | 103 ASSERT_TRUE(FileSystemUsageCache::IncrementDirty(usage_file_path)); |
104 for (int i = 0; i < 20; i++) | 104 for (int i = 0; i < 20; i++) |
105 ASSERT_TRUE(FileSystemUsageCache::DecrementDirty(usage_file_path)); | 105 ASSERT_TRUE(FileSystemUsageCache::DecrementDirty(usage_file_path)); |
106 EXPECT_EQ(size, FileSystemUsageCache::GetUsage(usage_file_path)); | 106 EXPECT_EQ(size, FileSystemUsageCache::GetUsage(usage_file_path)); |
107 } | 107 } |
108 | 108 |
109 TEST_F(FileSystemUsageCacheTest, ManyIncsLessDecsAndGetSizeTest) { | 109 TEST_F(FileSystemUsageCacheTest, ManyIncsLessDecsAndGetSizeTest) { |
110 FilePath usage_file_path = GetUsageFilePath(); | 110 base::FilePath usage_file_path = GetUsageFilePath(); |
111 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, | 111 ASSERT_EQ(FileSystemUsageCache::kUsageFileSize, |
112 FileSystemUsageCache::UpdateUsage(usage_file_path, 19319)); | 112 FileSystemUsageCache::UpdateUsage(usage_file_path, 19319)); |
113 for (int i = 0; i < 20; i++) | 113 for (int i = 0; i < 20; i++) |
114 ASSERT_TRUE(FileSystemUsageCache::IncrementDirty(usage_file_path)); | 114 ASSERT_TRUE(FileSystemUsageCache::IncrementDirty(usage_file_path)); |
115 for (int i = 0; i < 19; i++) | 115 for (int i = 0; i < 19; i++) |
116 ASSERT_TRUE(FileSystemUsageCache::DecrementDirty(usage_file_path)); | 116 ASSERT_TRUE(FileSystemUsageCache::DecrementDirty(usage_file_path)); |
117 EXPECT_EQ(1, FileSystemUsageCache::GetDirty(usage_file_path)); | 117 EXPECT_EQ(1, FileSystemUsageCache::GetDirty(usage_file_path)); |
118 EXPECT_EQ(19319, FileSystemUsageCache::GetUsage(usage_file_path)); | 118 EXPECT_EQ(19319, FileSystemUsageCache::GetUsage(usage_file_path)); |
119 } | 119 } |
120 | 120 |
121 TEST_F(FileSystemUsageCacheTest, GetSizeWithoutCacheFileTest) { | 121 TEST_F(FileSystemUsageCacheTest, GetSizeWithoutCacheFileTest) { |
122 FilePath usage_file_path = GetUsageFilePath(); | 122 base::FilePath usage_file_path = GetUsageFilePath(); |
123 EXPECT_EQ(-1, FileSystemUsageCache::GetUsage(usage_file_path)); | 123 EXPECT_EQ(-1, FileSystemUsageCache::GetUsage(usage_file_path)); |
124 } | 124 } |
125 | 125 |
126 TEST_F(FileSystemUsageCacheTest, IncrementDirtyWithoutCacheFileTest) { | 126 TEST_F(FileSystemUsageCacheTest, IncrementDirtyWithoutCacheFileTest) { |
127 FilePath usage_file_path = GetUsageFilePath(); | 127 base::FilePath usage_file_path = GetUsageFilePath(); |
128 EXPECT_FALSE(FileSystemUsageCache::IncrementDirty(usage_file_path)); | 128 EXPECT_FALSE(FileSystemUsageCache::IncrementDirty(usage_file_path)); |
129 } | 129 } |
130 | 130 |
131 TEST_F(FileSystemUsageCacheTest, DecrementDirtyWithoutCacheFileTest) { | 131 TEST_F(FileSystemUsageCacheTest, DecrementDirtyWithoutCacheFileTest) { |
132 FilePath usage_file_path = GetUsageFilePath(); | 132 base::FilePath usage_file_path = GetUsageFilePath(); |
133 EXPECT_FALSE(FileSystemUsageCache::IncrementDirty(usage_file_path)); | 133 EXPECT_FALSE(FileSystemUsageCache::IncrementDirty(usage_file_path)); |
134 } | 134 } |
135 | 135 |
136 } // namespace fileapi | 136 } // namespace fileapi |
OLD | NEW |