webkit/common/dom_storage/dom_storage_map_unittest.cc - Issue 22297005: Move webkit/{browser,common}/dom_storage into content/

Side by Side Diff: webkit/common/dom_storage/dom_storage_map_unittest.cc

Issue 22297005: Move webkit/{browser,common}/dom_storage into content/ (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Created 7 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

« content/renderer/dom_storage/dom_storage_cached_area.h ('K') | « webkit/common/dom_storage/dom_storage_map.cc ('k') | webkit/common/dom_storage/dom_storage_types.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
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

3 // found in the LICENSE file.

4

5 #include "base/strings/utf_string_conversions.h"

6 #include "testing/gtest/include/gtest/gtest.h"

7 #include "webkit/common/dom_storage/dom_storage_map.h"

8

9 namespace dom_storage {

10

11 TEST(DomStorageMapTest, DomStorageMapBasics) {

12 const base::string16 kKey(ASCIIToUTF16("key"));

13 const base::string16 kValue(ASCIIToUTF16("value"));

14 const size_t kValueBytes = kValue.size() * sizeof(char16);

15 const size_t kItemBytes =

16 (kKey.size() + kValue.size()) * sizeof(char16);

17 const base::string16 kKey2(ASCIIToUTF16("key2"));

18 const size_t kKey2Bytes = kKey2.size() * sizeof(char16);

19 const base::string16 kValue2(ASCIIToUTF16("value2"));

20 const size_t kItem2Bytes =

21 (kKey2.size() + kValue2.size()) * sizeof(char16);

22 const size_t kQuota = 1024; // 1K quota for this test.

23

24 scoped_refptr<DomStorageMap> map(new DomStorageMap(kQuota));

25 base::string16 old_value;

26 base::NullableString16 old_nullable_value;

27 ValuesMap swap;

28 scoped_refptr<DomStorageMap> copy;

29

30 // Check the behavior of an empty map.

31 EXPECT_EQ(0u, map->Length());

32 EXPECT_TRUE(map->Key(0).is_null());

33 EXPECT_TRUE(map->Key(100).is_null());

34 EXPECT_TRUE(map->GetItem(kKey).is_null());

35 EXPECT_FALSE(map->RemoveItem(kKey, &old_value));

36 EXPECT_EQ(0u, map->bytes_used());

37 copy = map->DeepCopy();

38 EXPECT_EQ(0u, copy->Length());

39 EXPECT_EQ(0u, copy->bytes_used());

40 map->SwapValues(&swap);

41 EXPECT_TRUE(swap.empty());

42

43 // Check the behavior of a map containing some values.

44 EXPECT_TRUE(map->SetItem(kKey, kValue, &old_nullable_value));

45 EXPECT_TRUE(old_nullable_value.is_null());

46 EXPECT_EQ(1u, map->Length());

47 EXPECT_EQ(kKey, map->Key(0).string());

48 EXPECT_TRUE(map->Key(1).is_null());

49 EXPECT_EQ(kValue, map->GetItem(kKey).string());

50 EXPECT_TRUE(map->GetItem(kKey2).is_null());

51 EXPECT_EQ(kItemBytes, map->bytes_used());

52 EXPECT_TRUE(map->RemoveItem(kKey, &old_value));

53 EXPECT_EQ(0u, map->bytes_used());

54 EXPECT_EQ(kValue, old_value);

55 old_value.clear();

56

57 EXPECT_TRUE(map->SetItem(kKey, kValue, &old_nullable_value));

58 EXPECT_TRUE(map->SetItem(kKey2, kValue, &old_nullable_value));

59 EXPECT_TRUE(old_nullable_value.is_null());

60 EXPECT_EQ(kItemBytes + kKey2Bytes + kValueBytes, map->bytes_used());

61 EXPECT_TRUE(map->SetItem(kKey2, kValue2, &old_nullable_value));

62 EXPECT_EQ(kItemBytes + kItem2Bytes, map->bytes_used());

63 EXPECT_EQ(kValue, old_nullable_value.string());

64 EXPECT_EQ(2u, map->Length());

65 EXPECT_EQ(kKey, map->Key(0).string());

66 EXPECT_EQ(kKey2, map->Key(1).string());

67 EXPECT_EQ(kKey, map->Key(0).string());

68 EXPECT_EQ(kItemBytes + kItem2Bytes, map->bytes_used());

69

70 copy = map->DeepCopy();

71 EXPECT_EQ(2u, copy->Length());

72 EXPECT_EQ(kValue, copy->GetItem(kKey).string());

73 EXPECT_EQ(kValue2, copy->GetItem(kKey2).string());

74 EXPECT_EQ(kKey, copy->Key(0).string());

75 EXPECT_EQ(kKey2, copy->Key(1).string());

76 EXPECT_TRUE(copy->Key(2).is_null());

77 EXPECT_EQ(kItemBytes + kItem2Bytes, copy->bytes_used());

78

79 map->SwapValues(&swap);

80 EXPECT_EQ(2ul, swap.size());

81 EXPECT_EQ(0u, map->Length());

82 EXPECT_EQ(0u, map->bytes_used());

83 }

84

85 TEST(DomStorageMapTest, EnforcesQuota) {

86 const base::string16 kKey = ASCIIToUTF16("test_key");

87 const base::string16 kValue = ASCIIToUTF16("test_value");

88 const base::string16 kKey2 = ASCIIToUTF16("test_key_2");

89

90 // A 50 byte quota is too small to hold both keys, so we

91 // should see the DomStorageMap enforcing it.

92 const size_t kQuota = 50;

93

94 base::string16 old_value;

95 base::NullableString16 old_nullable_value;

96

97 scoped_refptr<DomStorageMap> map(new DomStorageMap(kQuota));

98 EXPECT_TRUE(map->SetItem(kKey, kValue, &old_nullable_value));

99 EXPECT_FALSE(map->SetItem(kKey2, kValue, &old_nullable_value));

100 EXPECT_EQ(1u, map->Length());

101

102 EXPECT_TRUE(map->RemoveItem(kKey, &old_value));

103 EXPECT_EQ(kValue, old_value);

104 EXPECT_EQ(0u, map->Length());

105 EXPECT_TRUE(map->SetItem(kKey2, kValue, &old_nullable_value));

106 EXPECT_EQ(1u, map->Length());

107

108 // Verify that the SwapValues method does not do quota checking.

109 ValuesMap swap;

110 swap[kKey] = base::NullableString16(kValue, false);

111 swap[kKey2] = base::NullableString16(kValue, false);

112 map->SwapValues(&swap);

113 EXPECT_GT(map->bytes_used(), kQuota);

114

115 // When overbudget, a new value of greater size than the existing value can

116 // not be set, but a new value of lesser or equal size can be set.

117 EXPECT_TRUE(map->SetItem(kKey, kValue, &old_nullable_value));

118 EXPECT_FALSE(map->SetItem(kKey, base::string16(kValue + kValue),

119 &old_nullable_value));

120 EXPECT_TRUE(map->SetItem(kKey, base::string16(), &old_nullable_value));

121 EXPECT_EQ(kValue, old_nullable_value.string());

122 }

123

124 } // namespace dom_storage

OLD	NEW