OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2013 Google Inc. All rights reserved. | 2 * Copyright (C) 2013 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 11 matching lines...) Expand all Loading... |
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
29 */ | 29 */ |
30 | 30 |
31 #include "config.h" | 31 #include "config.h" |
32 #include "core/html/HTMLDimension.h" | |
33 | 32 |
| 33 #include "core/platform/Length.h" |
34 #include "wtf/text/WTFString.h" | 34 #include "wtf/text/WTFString.h" |
35 #include <gtest/gtest.h> | 35 #include <gtest/gtest.h> |
36 | 36 |
37 namespace WebCore { | 37 namespace WebCore { |
38 | 38 |
39 // This assertion-prettify function needs to be in the WebCore namespace. | 39 // This assertion-prettify function needs to be in the WebCore namespace. |
40 void PrintTo(const Length& length, ::std::ostream* os) | 40 void PrintTo(const Length& length, ::std::ostream* os) |
41 { | 41 { |
42 *os << "Length => lengthType: " << length.type() << ", value=" << length.val
ue(); | 42 *os << "Length => lengthType: " << length.type() << ", value=" << length.val
ue(); |
43 } | 43 } |
44 | 44 |
45 } | 45 } |
46 | 46 |
47 using namespace WebCore; | 47 using namespace WebCore; |
48 | 48 |
49 namespace { | 49 namespace { |
50 | 50 |
51 TEST(WebCoreHTMLDimension, parseListOfDimensionsEmptyString) | 51 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsEmptyString) |
52 { | 52 { |
53 Vector<Length> result = parseListOfDimensions(String("")); | 53 Vector<Length> result = parseFrameSetListOfDimensions(String("")); |
54 ASSERT_EQ(Vector<Length>(), result); | 54 ASSERT_EQ(Vector<Length>(), result); |
55 } | 55 } |
56 | 56 |
57 TEST(WebCoreHTMLDimension, parseListOfDimensionsNoNumberAbsolute) | 57 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsNoNumberAbsolute) |
58 { | 58 { |
59 Vector<Length> result = parseListOfDimensions(String(" \t")); | 59 Vector<Length> result = parseFrameSetListOfDimensions(String(" \t")); |
60 ASSERT_EQ(1U, result.size()); | 60 ASSERT_EQ(Vector<Length>(), result); |
61 ASSERT_EQ(Length(0, Relative), result[0]); | |
62 } | 61 } |
63 | 62 |
64 TEST(WebCoreHTMLDimension, parseListOfDimensionsNoNumberPercent) | 63 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsNoNumberPercent) |
65 { | 64 { |
66 Vector<Length> result = parseListOfDimensions(String(" \t%")); | 65 Vector<Length> result = parseFrameSetListOfDimensions(String(" \t%")); |
67 ASSERT_EQ(1U, result.size()); | 66 ASSERT_EQ(1U, result.size()); |
68 ASSERT_EQ(Length(0, Percent), result[0]); | 67 ASSERT_EQ(Length(1, Relative), result[0]); |
69 } | 68 } |
70 | 69 |
71 TEST(WebCoreHTMLDimension, parseListOfDimensionsNoNumberRelative) | 70 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsNoNumberRelative) |
72 { | 71 { |
73 Vector<Length> result = parseListOfDimensions(String("\t *")); | 72 Vector<Length> result = parseFrameSetListOfDimensions(String("\t *")); |
74 ASSERT_EQ(1U, result.size()); | 73 ASSERT_EQ(1U, result.size()); |
75 ASSERT_EQ(Length(0, Relative), result[0]); | 74 ASSERT_EQ(Length(1, Relative), result[0]); |
76 } | 75 } |
77 | 76 |
78 TEST(WebCoreHTMLDimension, parseListOfDimensionsSingleAbsolute) | 77 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsSingleAbsolute) |
79 { | 78 { |
80 Vector<Length> result = parseListOfDimensions(String("10")); | 79 Vector<Length> result = parseFrameSetListOfDimensions(String("10")); |
81 | 80 |
82 ASSERT_EQ(1U, result.size()); | 81 ASSERT_EQ(1U, result.size()); |
83 ASSERT_EQ(Length(10, Fixed), result[0]); | 82 ASSERT_EQ(Length(10, Fixed), result[0]); |
84 } | 83 } |
85 | 84 |
86 TEST(WebCoreHTMLDimension, parseListOfDimensionsSinglePercentageWithSpaces) | 85 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsSinglePercentageWithSpac
es) |
87 { | 86 { |
88 Vector<Length> result = parseListOfDimensions(String("50 %")); | 87 Vector<Length> result = parseFrameSetListOfDimensions(String("50 %")); |
89 | 88 |
90 ASSERT_EQ(1U, result.size()); | 89 ASSERT_EQ(1U, result.size()); |
91 ASSERT_EQ(Length(50, Percent), result[0]); | 90 ASSERT_EQ(Length(50, Percent), result[0]); |
92 } | 91 } |
93 | 92 |
94 TEST(WebCoreHTMLDimension, parseListOfDimensionsSingleRelative) | 93 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsSingleRelative) |
95 { | 94 { |
96 Vector<Length> result = parseListOfDimensions(String("25*")); | 95 Vector<Length> result = parseFrameSetListOfDimensions(String("25*")); |
97 | 96 |
98 ASSERT_EQ(1U, result.size()); | 97 ASSERT_EQ(1U, result.size()); |
99 ASSERT_EQ(Length(25, Relative), result[0]); | 98 ASSERT_EQ(Length(25, Relative), result[0]); |
100 } | 99 } |
101 | 100 |
102 TEST(WebCoreHTMLDimension, parseListOfDimensionsDoubleAbsolute) | 101 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsDoubleAbsolute) |
103 { | 102 { |
104 Vector<Length> result = parseListOfDimensions(String("10.054")); | 103 Vector<Length> result = parseFrameSetListOfDimensions(String("10.054")); |
105 | |
106 ASSERT_EQ(1U, result.size()); | |
107 ASSERT_EQ(Length(10.054, Fixed), result[0]); | |
108 } | |
109 | |
110 TEST(WebCoreHTMLDimension, parseListOfDimensionsLeadingSpaceAbsolute) | |
111 { | |
112 Vector<Length> result = parseListOfDimensions(String("\t \t 10")); | |
113 | 104 |
114 ASSERT_EQ(1U, result.size()); | 105 ASSERT_EQ(1U, result.size()); |
115 ASSERT_EQ(Length(10, Fixed), result[0]); | 106 ASSERT_EQ(Length(10, Fixed), result[0]); |
116 } | 107 } |
117 | 108 |
118 TEST(WebCoreHTMLDimension, parseListOfDimensionsLeadingSpaceRelative) | 109 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsLeadingSpaceAbsolute) |
119 { | 110 { |
120 Vector<Length> result = parseListOfDimensions(String(" \r25*")); | 111 Vector<Length> result = parseFrameSetListOfDimensions(String("\t \t 10")); |
| 112 |
| 113 ASSERT_EQ(1U, result.size()); |
| 114 ASSERT_EQ(Length(10, Fixed), result[0]); |
| 115 } |
| 116 |
| 117 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsLeadingSpaceRelative) |
| 118 { |
| 119 Vector<Length> result = parseFrameSetListOfDimensions(String(" \r25*")); |
121 | 120 |
122 ASSERT_EQ(1U, result.size()); | 121 ASSERT_EQ(1U, result.size()); |
123 ASSERT_EQ(Length(25, Relative), result[0]); | 122 ASSERT_EQ(Length(25, Relative), result[0]); |
124 } | 123 } |
125 | 124 |
126 TEST(WebCoreHTMLDimension, parseListOfDimensionsLeadingSpacePercentage) | 125 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsLeadingSpacePercentage) |
127 { | 126 { |
128 Vector<Length> result = parseListOfDimensions(String("\n 25%")); | 127 Vector<Length> result = parseFrameSetListOfDimensions(String("\n 25%")); |
129 | 128 |
130 ASSERT_EQ(1U, result.size()); | 129 ASSERT_EQ(1U, result.size()); |
131 ASSERT_EQ(Length(25, Percent), result[0]); | 130 ASSERT_EQ(Length(25, Percent), result[0]); |
132 } | 131 } |
133 | 132 |
134 TEST(WebCoreHTMLDimension, parseListOfDimensionsDoublePercentage) | 133 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsDoublePercentage) |
135 { | 134 { |
136 Vector<Length> result = parseListOfDimensions(String("10.054%")); | 135 Vector<Length> result = parseFrameSetListOfDimensions(String("10.054%")); |
137 | 136 |
138 ASSERT_EQ(1U, result.size()); | 137 ASSERT_EQ(1U, result.size()); |
139 ASSERT_EQ(Length(10.054, Percent), result[0]); | 138 ASSERT_EQ(Length(10.054, Percent), result[0]); |
140 } | 139 } |
141 | 140 |
142 TEST(WebCoreHTMLDimension, parseListOfDimensionsDoubleRelative) | 141 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsDoubleRelative) |
143 { | 142 { |
144 Vector<Length> result = parseListOfDimensions(String("10.054*")); | 143 Vector<Length> result = parseFrameSetListOfDimensions(String("10.054*")); |
145 | 144 |
146 ASSERT_EQ(1U, result.size()); | 145 ASSERT_EQ(1U, result.size()); |
147 ASSERT_EQ(Length(10.054, Relative), result[0]); | 146 ASSERT_EQ(Length(10, Relative), result[0]); |
148 } | 147 } |
149 | 148 |
150 TEST(WebCoreHTMLDimension, parseListOfDimensionsSpacesInIntegerDoubleAbsolute) | 149 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsSpacesInIntegerDoubleAbs
olute) |
151 { | 150 { |
152 Vector<Length> result = parseListOfDimensions(String("1\n0 .025%")); | 151 Vector<Length> result = parseFrameSetListOfDimensions(String("1\n0 .025%")); |
153 | 152 |
154 ASSERT_EQ(1U, result.size()); | 153 ASSERT_EQ(1U, result.size()); |
155 ASSERT_EQ(Length(1, Fixed), result[0]); | 154 ASSERT_EQ(Length(1, Fixed), result[0]); |
156 } | 155 } |
157 | 156 |
158 TEST(WebCoreHTMLDimension, parseListOfDimensionsSpacesInIntegerDoublePercent) | 157 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsSpacesInIntegerDoublePer
cent) |
159 { | 158 { |
160 Vector<Length> result = parseListOfDimensions(String("1\n0 .025%")); | 159 Vector<Length> result = parseFrameSetListOfDimensions(String("1\n0 .025%")); |
161 | 160 |
162 ASSERT_EQ(1U, result.size()); | 161 ASSERT_EQ(1U, result.size()); |
163 ASSERT_EQ(Length(1, Fixed), result[0]); | 162 ASSERT_EQ(Length(1, Fixed), result[0]); |
164 } | 163 } |
165 | 164 |
166 TEST(WebCoreHTMLDimension, parseListOfDimensionsSpacesInIntegerDoubleRelative) | 165 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsSpacesInIntegerDoubleRel
ative) |
167 { | 166 { |
168 Vector<Length> result = parseListOfDimensions(String("1\n0 .025*")); | 167 Vector<Length> result = parseFrameSetListOfDimensions(String("1\n0 .025*")); |
169 | 168 |
170 ASSERT_EQ(1U, result.size()); | 169 ASSERT_EQ(1U, result.size()); |
171 ASSERT_EQ(Length(1, Fixed), result[0]); | 170 ASSERT_EQ(Length(1, Fixed), result[0]); |
172 } | 171 } |
173 | 172 |
174 TEST(WebCoreHTMLDimension, parseListOfDimensionsSpacesInFractionAfterDotDoublePe
rcent) | 173 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsSpacesInFractionAfterDot
DoublePercent) |
175 { | 174 { |
176 Vector<Length> result = parseListOfDimensions(String("10. 0 25%")); | 175 Vector<Length> result = parseFrameSetListOfDimensions(String("10. 0 25%")); |
177 | |
178 ASSERT_EQ(1U, result.size()); | |
179 ASSERT_EQ(Length(10.025, Percent), result[0]); | |
180 } | |
181 | |
182 TEST(WebCoreHTMLDimension, parseListOfDimensionsSpacesInFractionAfterDigitDouble
Percent) | |
183 { | |
184 Vector<Length> result = parseListOfDimensions(String("10.05\r25%")); | |
185 | |
186 ASSERT_EQ(1U, result.size()); | |
187 ASSERT_EQ(Length(10.0525, Percent), result[0]); | |
188 } | |
189 | |
190 TEST(WebCoreHTMLDimension, parseListOfDimensionsTrailingComma) | |
191 { | |
192 Vector<Length> result = parseListOfDimensions(String("10,")); | |
193 | 176 |
194 ASSERT_EQ(1U, result.size()); | 177 ASSERT_EQ(1U, result.size()); |
195 ASSERT_EQ(Length(10, Fixed), result[0]); | 178 ASSERT_EQ(Length(10, Fixed), result[0]); |
196 } | 179 } |
197 | 180 |
198 TEST(WebCoreHTMLDimension, parseListOfDimensionsTwoDimensions) | 181 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsSpacesInFractionAfterDig
itDoublePercent) |
199 { | 182 { |
200 Vector<Length> result = parseListOfDimensions(String("10*,25 %")); | 183 Vector<Length> result = parseFrameSetListOfDimensions(String("10.05\r25%")); |
| 184 |
| 185 ASSERT_EQ(1U, result.size()); |
| 186 ASSERT_EQ(Length(10, Fixed), result[0]); |
| 187 } |
| 188 |
| 189 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsTrailingComma) |
| 190 { |
| 191 Vector<Length> result = parseFrameSetListOfDimensions(String("10,")); |
| 192 |
| 193 ASSERT_EQ(1U, result.size()); |
| 194 ASSERT_EQ(Length(10, Fixed), result[0]); |
| 195 } |
| 196 |
| 197 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsTwoDimensions) |
| 198 { |
| 199 Vector<Length> result = parseFrameSetListOfDimensions(String("10*,25 %")); |
201 | 200 |
202 ASSERT_EQ(2U, result.size()); | 201 ASSERT_EQ(2U, result.size()); |
203 ASSERT_EQ(Length(10, Relative), result[0]); | 202 ASSERT_EQ(Length(10, Relative), result[0]); |
204 ASSERT_EQ(Length(25, Percent), result[1]); | 203 ASSERT_EQ(Length(25, Percent), result[1]); |
205 } | 204 } |
206 | 205 |
207 TEST(WebCoreHTMLDimension, parseListOfDimensionsMultipleDimensionsWithSpaces) | 206 TEST(WebCoreHTMLDimension, parseFrameSetListOfDimensionsMultipleDimensionsWithSp
aces) |
208 { | 207 { |
209 Vector<Length> result = parseListOfDimensions(String("10 * ,\t25 , 10.05
\n5%")); | 208 Vector<Length> result = parseFrameSetListOfDimensions(String("10 * ,\t25
, 10.05\n5%")); |
210 | 209 |
211 ASSERT_EQ(3U, result.size()); | 210 ASSERT_EQ(3U, result.size()); |
212 ASSERT_EQ(Length(10, Relative), result[0]); | 211 ASSERT_EQ(Length(10, Relative), result[0]); |
213 ASSERT_EQ(Length(25, Fixed), result[1]); | 212 ASSERT_EQ(Length(25, Fixed), result[1]); |
214 ASSERT_EQ(Length(10.055, Percent), result[2]); | 213 ASSERT_EQ(Length(10, Fixed), result[2]); |
215 } | |
216 | |
217 TEST(WebCoreHTMLDimension, parseListOfDimensionsMultipleDimensionsWithOneEmpty) | |
218 { | |
219 Vector<Length> result = parseListOfDimensions(String("2*,,8.%")); | |
220 | |
221 ASSERT_EQ(3U, result.size()); | |
222 ASSERT_EQ(Length(2, Relative), result[0]); | |
223 ASSERT_EQ(Length(0, Relative), result[1]); | |
224 ASSERT_EQ(Length(8., Percent), result[2]); | |
225 } | |
226 | 214 |
227 } | 215 } |
| 216 } |
OLD | NEW |