1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.seasar.cubby.routing.impl;
17
18 import static org.junit.Assert.assertEquals;
19 import static org.junit.Assert.fail;
20
21 import org.junit.Test;
22 import org.seasar.cubby.routing.PathTemplateException;
23 import org.seasar.cubby.routing.PathTemplateParser;
24 import org.seasar.cubby.routing.impl.PathTemplateParserImpl;
25
26 public class PathTemplateParserImplTest {
27
28 private PathTemplateParser parser = new PathTemplateParserImpl();
29
30 @Test
31 public void parseFail() {
32 assertIllegalTemplate("/foo/bar/{}");
33 assertIllegalTemplate("/foo/bar/{");
34 assertIllegalTemplate("/foo/bar/{a");
35 assertIllegalTemplate("/foo/bar/{a,");
36 assertIllegalTemplate("/foo/bar/{a,b");
37 assertIllegalTemplate("/foo/bar/{a,}");
38 }
39
40 private void assertIllegalTemplate(String template) {
41 try {
42 parser.parse(template, new PathTemplateParser.Handler() {
43
44 public String handle(String name, String regex) {
45 fail();
46 return regex;
47 }
48
49 });
50 fail();
51 } catch (PathTemplateException e) {
52
53 e.printStackTrace();
54 }
55 }
56
57 @Test
58 public void parse1() {
59 String regex = parser.parse("/foo/{abc}",
60 new PathTemplateParser.Handler() {
61
62 private int count = 0;
63
64 public String handle(String name, String regex) {
65 switch (count) {
66 case 0:
67 assertEquals("abc", name);
68 assertEquals("[a-zA-Z0-9]+", regex);
69 break;
70 default:
71 fail();
72 }
73 count++;
74 return "(" + regex + ")";
75 }
76
77 });
78 assertEquals("/foo/([a-zA-Z0-9]+)", regex);
79 }
80
81 @Test
82 public void parse2() {
83 String regex = parser.parse("/foo/{abc}/bar/{def}",
84 new PathTemplateParser.Handler() {
85
86 private int count = 0;
87
88 public String handle(String name, String regex) {
89 switch (count) {
90 case 0:
91 assertEquals("abc", name);
92 assertEquals("[a-zA-Z0-9]+", regex);
93 break;
94 case 1:
95 assertEquals("def", name);
96 assertEquals("[a-zA-Z0-9]+", regex);
97 break;
98 default:
99 fail();
100 }
101 count++;
102 return "(" + regex + ")";
103 }
104
105 });
106 assertEquals("/foo/([a-zA-Z0-9]+)/bar/([a-zA-Z0-9]+)", regex);
107 }
108
109 @Test
110 public void parse3() {
111 String regex = parser.parse("/foo/bar/{abc,{3}a}",
112 new PathTemplateParser.Handler() {
113
114 private int count = 0;
115
116 public String handle(String name, String regex) {
117 switch (count) {
118 case 0:
119 assertEquals("abc", name);
120 assertEquals("{3}a", regex);
121 break;
122 default:
123 fail();
124 }
125 count++;
126 return "(" + regex + ")";
127 }
128
129 });
130 assertEquals("/foo/bar/({3}a)", regex);
131 }
132
133 @Test
134 public void parse4() {
135 String regex = parser.parse("/foo/bar/{abc,\\{aa}",
136 new PathTemplateParser.Handler() {
137
138 private int count = 0;
139
140 public String handle(String name, String regex) {
141 switch (count) {
142 case 0:
143 assertEquals("abc", name);
144 assertEquals("\\{aa", regex);
145 break;
146 default:
147 fail();
148 }
149 count++;
150 return "(" + regex + ")";
151 }
152
153 });
154 assertEquals("/foo/bar/(\\{aa)", regex);
155 }
156
157 @Test
158 public void parse5() {
159 String regex = parser.parse("/foo/bar/{abc,\\{aa}/{def,a\\}a}",
160 new PathTemplateParser.Handler() {
161
162 private int count = 0;
163
164 public String handle(String name, String regex) {
165 switch (count) {
166 case 0:
167 assertEquals("abc", name);
168 assertEquals("\\{aa", regex);
169 break;
170 case 1:
171 assertEquals("def", name);
172 assertEquals("a\\}a", regex);
173 break;
174 default:
175 fail();
176 }
177 count++;
178 return "(" + regex + ")";
179 }
180
181 });
182 assertEquals("/foo/bar/(\\{aa)/(a\\}a)", regex);
183 }
184
185 @Test
186 public void parse6() {
187 String regex = parser.parse("/foo/bar/{abc,aa\\\\}",
188 new PathTemplateParser.Handler() {
189
190 private int count = 0;
191
192 public String handle(String name, String regex) {
193 switch (count) {
194 case 0:
195 assertEquals("abc", name);
196 assertEquals("aa\\\\", regex);
197 break;
198 default:
199 fail();
200 }
201 count++;
202 return "(" + regex + ")";
203 }
204
205 });
206 assertEquals("/foo/bar/(aa\\\\)", regex);
207 }
208
209 }