1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.net;
18
19 import static com.google.common.base.Charsets.UTF_8;
20 import static com.google.common.net.MediaType.ANY_APPLICATION_TYPE;
21 import static com.google.common.net.MediaType.ANY_AUDIO_TYPE;
22 import static com.google.common.net.MediaType.ANY_IMAGE_TYPE;
23 import static com.google.common.net.MediaType.ANY_TEXT_TYPE;
24 import static com.google.common.net.MediaType.ANY_TYPE;
25 import static com.google.common.net.MediaType.ANY_VIDEO_TYPE;
26 import static com.google.common.net.MediaType.HTML_UTF_8;
27 import static com.google.common.net.MediaType.JPEG;
28 import static com.google.common.net.MediaType.PLAIN_TEXT_UTF_8;
29
30 import com.google.common.annotations.Beta;
31 import com.google.common.annotations.GwtCompatible;
32 import com.google.common.base.Optional;
33 import com.google.common.collect.ImmutableListMultimap;
34 import com.google.common.collect.ImmutableMultimap;
35 import com.google.common.testing.EqualsTester;
36
37 import junit.framework.TestCase;
38
39 import java.nio.charset.IllegalCharsetNameException;
40 import java.nio.charset.UnsupportedCharsetException;
41
42
43
44
45
46
47 @Beta
48 @GwtCompatible(emulated = true)
49 public class MediaTypeTest extends TestCase {
50
51 public void testCreate_invalidType() {
52 try {
53 MediaType.create("te><t", "plaintext");
54 fail();
55 } catch (IllegalArgumentException expected) {}
56 }
57
58 public void testCreate_invalidSubtype() {
59 try {
60 MediaType.create("text", "pl@intext");
61 fail();
62 } catch (IllegalArgumentException expected) {}
63 }
64
65 public void testCreate_wildcardTypeDeclaredSubtype() {
66 try {
67 MediaType.create("*", "text");
68 fail();
69 } catch (IllegalArgumentException expected) {}
70 }
71
72 public void testCreateApplicationType() {
73 MediaType newType = MediaType.createApplicationType("yams");
74 assertEquals("application", newType.type());
75 assertEquals("yams", newType.subtype());
76 }
77
78 public void testCreateAudioType() {
79 MediaType newType = MediaType.createAudioType("yams");
80 assertEquals("audio", newType.type());
81 assertEquals("yams", newType.subtype());
82 }
83
84 public void testCreateImageType() {
85 MediaType newType = MediaType.createImageType("yams");
86 assertEquals("image", newType.type());
87 assertEquals("yams", newType.subtype());
88 }
89
90 public void testCreateTextType() {
91 MediaType newType = MediaType.createTextType("yams");
92 assertEquals("text", newType.type());
93 assertEquals("yams", newType.subtype());
94 }
95
96 public void testCreateVideoType() {
97 MediaType newType = MediaType.createVideoType("yams");
98 assertEquals("video", newType.type());
99 assertEquals("yams", newType.subtype());
100 }
101
102 public void testGetType() {
103 assertEquals("text", MediaType.parse("text/plain").type());
104 assertEquals("application",
105 MediaType.parse("application/atom+xml; charset=utf-8").type());
106 }
107
108 public void testGetSubtype() {
109 assertEquals("plain", MediaType.parse("text/plain").subtype());
110 assertEquals("atom+xml",
111 MediaType.parse("application/atom+xml; charset=utf-8").subtype());
112 }
113
114 private static final ImmutableListMultimap<String, String> PARAMETERS =
115 ImmutableListMultimap.of("a", "1", "a", "2", "b", "3");
116
117 public void testGetParameters() {
118 assertEquals(ImmutableListMultimap.of(), MediaType.parse("text/plain").parameters());
119 assertEquals(ImmutableListMultimap.of("charset", "utf-8"),
120 MediaType.parse("application/atom+xml; charset=utf-8").parameters());
121 assertEquals(PARAMETERS,
122 MediaType.parse("application/atom+xml; a=1; a=2; b=3").parameters());
123 }
124
125 public void testWithoutParameters() {
126 assertSame(MediaType.parse("image/gif"),
127 MediaType.parse("image/gif").withoutParameters());
128 assertEquals(MediaType.parse("image/gif"),
129 MediaType.parse("image/gif; foo=bar").withoutParameters());
130 }
131
132 public void testWithParameters() {
133 assertEquals(MediaType.parse("text/plain; a=1; a=2; b=3"),
134 MediaType.parse("text/plain").withParameters(PARAMETERS));
135 assertEquals(MediaType.parse("text/plain; a=1; a=2; b=3"),
136 MediaType.parse("text/plain; a=1; a=2; b=3").withParameters(PARAMETERS));
137 }
138
139 public void testWithParameters_invalidAttribute() {
140 MediaType mediaType = MediaType.parse("text/plain");
141 ImmutableListMultimap<String, String> parameters =
142 ImmutableListMultimap.of("a", "1", "@", "2", "b", "3");
143 try {
144 mediaType.withParameters(parameters);
145 fail();
146 } catch (IllegalArgumentException expected) {}
147 }
148
149 public void testWithParameter() {
150 assertEquals(MediaType.parse("text/plain; a=1"),
151 MediaType.parse("text/plain").withParameter("a", "1"));
152 assertEquals(MediaType.parse("text/plain; a=1"),
153 MediaType.parse("text/plain; a=1; a=2").withParameter("a", "1"));
154 assertEquals(MediaType.parse("text/plain; a=3"),
155 MediaType.parse("text/plain; a=1; a=2").withParameter("a", "3"));
156 assertEquals(MediaType.parse("text/plain; a=1; a=2; b=3"),
157 MediaType.parse("text/plain; a=1; a=2").withParameter("b", "3"));
158 }
159
160 public void testWithParameter_invalidAttribute() {
161 MediaType mediaType = MediaType.parse("text/plain");
162 try {
163 mediaType.withParameter("@", "2");
164 fail();
165 } catch (IllegalArgumentException expected) {}
166 }
167
168 public void testWithCharset() {
169 assertEquals(MediaType.parse("text/plain; charset=utf-8"),
170 MediaType.parse("text/plain").withCharset(UTF_8));
171 assertEquals(MediaType.parse("text/plain; charset=utf-8"),
172 MediaType.parse("text/plain; charset=utf-16").withCharset(UTF_8));
173 }
174
175 public void testHasWildcard() {
176 assertFalse(PLAIN_TEXT_UTF_8.hasWildcard());
177 assertFalse(JPEG.hasWildcard());
178 assertTrue(ANY_TYPE.hasWildcard());
179 assertTrue(ANY_APPLICATION_TYPE.hasWildcard());
180 assertTrue(ANY_AUDIO_TYPE.hasWildcard());
181 assertTrue(ANY_IMAGE_TYPE.hasWildcard());
182 assertTrue(ANY_TEXT_TYPE.hasWildcard());
183 assertTrue(ANY_VIDEO_TYPE.hasWildcard());
184 }
185
186 public void testIs() {
187 assertTrue(PLAIN_TEXT_UTF_8.is(ANY_TYPE));
188 assertTrue(JPEG.is(ANY_TYPE));
189 assertTrue(ANY_TEXT_TYPE.is(ANY_TYPE));
190 assertTrue(PLAIN_TEXT_UTF_8.is(ANY_TEXT_TYPE));
191 assertTrue(PLAIN_TEXT_UTF_8.withoutParameters().is(ANY_TEXT_TYPE));
192 assertFalse(JPEG.is(ANY_TEXT_TYPE));
193 assertTrue(PLAIN_TEXT_UTF_8.is(PLAIN_TEXT_UTF_8));
194 assertTrue(PLAIN_TEXT_UTF_8.is(PLAIN_TEXT_UTF_8.withoutParameters()));
195 assertFalse(PLAIN_TEXT_UTF_8.withoutParameters().is(PLAIN_TEXT_UTF_8));
196 assertFalse(PLAIN_TEXT_UTF_8.is(HTML_UTF_8));
197 assertFalse(PLAIN_TEXT_UTF_8.withParameter("charset", "UTF-16").is(PLAIN_TEXT_UTF_8));
198 assertFalse(PLAIN_TEXT_UTF_8.is(PLAIN_TEXT_UTF_8.withParameter("charset", "UTF-16")));
199 }
200
201 public void testParse_empty() {
202 try {
203 MediaType.parse("");
204 fail();
205 } catch (IllegalArgumentException expected) {}
206 }
207
208 public void testParse_badInput() {
209 try {
210 MediaType.parse("/");
211 fail();
212 } catch (IllegalArgumentException expected) {}
213 try {
214 MediaType.parse("text");
215 fail();
216 } catch (IllegalArgumentException expected) {}
217 try {
218 MediaType.parse("text/");
219 fail();
220 } catch (IllegalArgumentException expected) {}
221 try {
222 MediaType.parse("te<t/plain");
223 fail();
224 } catch (IllegalArgumentException expected) {}
225 try {
226 MediaType.parse("text/pl@in");
227 fail();
228 } catch (IllegalArgumentException expected) {}
229 try {
230 MediaType.parse("text/plain;");
231 fail();
232 } catch (IllegalArgumentException expected) {}
233 try {
234 MediaType.parse("text/plain; ");
235 fail();
236 } catch (IllegalArgumentException expected) {}
237 try {
238 MediaType.parse("text/plain; a");
239 fail();
240 } catch (IllegalArgumentException expected) {}
241 try {
242 MediaType.parse("text/plain; a=");
243 fail();
244 } catch (IllegalArgumentException expected) {}
245 try {
246 MediaType.parse("text/plain; a=@");
247 fail();
248 } catch (IllegalArgumentException expected) {}
249 try {
250 MediaType.parse("text/plain; a=\"@");
251 fail();
252 } catch (IllegalArgumentException expected) {}
253 try {
254 MediaType.parse("text/plain; a=1;");
255 fail();
256 } catch (IllegalArgumentException expected) {}
257 try {
258 MediaType.parse("text/plain; a=1; ");
259 fail();
260 } catch (IllegalArgumentException expected) {}
261 try {
262 MediaType.parse("text/plain; a=1; b");
263 fail();
264 } catch (IllegalArgumentException expected) {}
265 try {
266 MediaType.parse("text/plain; a=1; b=");
267 fail();
268 } catch (IllegalArgumentException expected) {}
269 try {
270 MediaType.parse("text/plain; a=\u2025");
271 fail();
272 } catch (IllegalArgumentException expected) {}
273 }
274
275 public void testGetCharset() {
276 assertEquals(Optional.absent(), MediaType.parse("text/plain").charset());
277 assertEquals(Optional.of(UTF_8),
278 MediaType.parse("text/plain; charset=utf-8").charset());
279 }
280
281 public void testGetCharset_tooMany() {
282 MediaType mediaType = MediaType.parse("text/plain; charset=utf-8; charset=utf-16");
283 try {
284 mediaType.charset();
285 fail();
286 } catch (IllegalStateException expected) {}
287 }
288
289 public void testGetCharset_illegalCharset() {
290 MediaType mediaType = MediaType.parse(
291 "text/plain; charset=\"!@#$%^&*()\"");
292 try {
293 mediaType.charset();
294 fail();
295 } catch (IllegalCharsetNameException expected) {}
296 }
297
298 public void testGetCharset_unsupportedCharset() {
299 MediaType mediaType = MediaType.parse(
300 "text/plain; charset=utf-wtf");
301 try {
302 mediaType.charset();
303 fail();
304 } catch (UnsupportedCharsetException expected) {}
305 }
306
307 public void testEquals() {
308 new EqualsTester()
309 .addEqualityGroup(MediaType.create("text", "plain"),
310 MediaType.create("TEXT", "PLAIN"),
311 MediaType.parse("text/plain"),
312 MediaType.parse("TEXT/PLAIN"),
313 MediaType.create("text", "plain").withParameter("a", "1").withoutParameters())
314 .addEqualityGroup(
315 MediaType.create("text", "plain").withCharset(UTF_8),
316 MediaType.create("text", "plain").withParameter("CHARSET", "UTF-8"),
317 MediaType.create("text", "plain").withParameters(
318 ImmutableMultimap.of("charset", "utf-8")),
319 MediaType.parse("text/plain;charset=utf-8"),
320 MediaType.parse("text/plain; charset=utf-8"),
321 MediaType.parse("text/plain; charset=utf-8"),
322 MediaType.parse("text/plain; \tcharset=utf-8"),
323 MediaType.parse("text/plain; \r\n\tcharset=utf-8"),
324 MediaType.parse("text/plain; CHARSET=utf-8"),
325 MediaType.parse("text/plain; charset=\"utf-8\""),
326 MediaType.parse("text/plain; charset=\"\\u\\tf-\\8\""),
327 MediaType.parse("text/plain; charset=UTF-8"))
328 .addEqualityGroup(MediaType.parse("text/plain; charset=utf-8; charset=utf-8"))
329 .addEqualityGroup(MediaType.create("text", "plain").withParameter("a", "value"),
330 MediaType.create("text", "plain").withParameter("A", "value"))
331 .addEqualityGroup(MediaType.create("text", "plain").withParameter("a", "VALUE"),
332 MediaType.create("text", "plain").withParameter("A", "VALUE"))
333 .addEqualityGroup(
334 MediaType.create("text", "plain")
335 .withParameters(ImmutableListMultimap.of("a", "1", "a", "2")),
336 MediaType.create("text", "plain")
337 .withParameters(ImmutableListMultimap.of("a", "2", "a", "1")))
338 .addEqualityGroup(MediaType.create("text", "csv"))
339 .addEqualityGroup(MediaType.create("application", "atom+xml"))
340 .testEquals();
341 }
342
343 public void testToString() {
344 assertEquals("text/plain", MediaType.create("text", "plain").toString());
345 assertEquals("text/plain; something=\"cr@zy\"; something-else=\"crazy with spaces\"",
346 MediaType.create("text", "plain")
347 .withParameter("something", "cr@zy")
348 .withParameter("something-else", "crazy with spaces")
349 .toString());
350 }
351 }
352