KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > opencms > util > TestCmsMacroResolver


1 /*
2  * File : $Source: /usr/local/cvs/opencms/test/org/opencms/util/TestCmsMacroResolver.java,v $
3  * Date : $Date: 2006/10/20 10:36:51 $
4  * Version: $Revision: 1.10 $
5  *
6  * This library is part of OpenCms -
7  * the Open Source Content Mananagement System
8  *
9  * Copyright (c) 2005 Alkacon Software GmbH (http://www.alkacon.com)
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * For further information about Alkacon Software GmbH, please see the
22  * company website: http://www.alkacon.com
23  *
24  * For further information about OpenCms, please see the
25  * project website: http://www.opencms.org
26  *
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30  */

31  
32 package org.opencms.util;
33
34 import org.opencms.i18n.CmsMessages;
35
36 import java.util.Locale JavaDoc;
37
38 import junit.framework.TestCase;
39
40 /**
41  * Test cases for {@link org.opencms.util.CmsMacroResolver}.<p>
42  *
43  * @author Alexander Kandzior
44  * @version $Revision: 1.10 $
45  */

46 public class TestCmsMacroResolver extends TestCase {
47       
48     /**
49      * Default JUnit constructor.<p>
50      *
51      * @param arg0 JUnit parameters
52      */

53     public TestCmsMacroResolver(String JavaDoc arg0) {
54         super(arg0);
55     }
56     
57     /**
58      * Tests the macro resolver "recursive" functions.<p>
59      */

60     public void testResolveLocalizedMacros() {
61         
62         CmsMacroResolver resolver = CmsMacroResolver.newInstance();
63         
64         // add the messages to the resolver
65
CmsMessages messages = new CmsMessages(org.opencms.xml.content.Messages.get().getBundleName(), Locale.ENGLISH);
66         resolver.setMessages(messages);
67         
68         // resgister some macros for the validation
69
resolver.addMacro("onesecond", "This is the final result");
70         resolver.addMacro("twofirst", "second");
71         resolver.addMacro("three", "first");
72         
73         String JavaDoc value1, value2;
74         String JavaDoc keyName;
75         
76         keyName = org.opencms.xml.content.Messages.GUI_EDITOR_XMLCONTENT_VALIDATION_ERROR_2;
77         value1 = messages.key(keyName);
78         value2 = resolver.resolveMacros("${key." + keyName + "}");
79         assertEquals("Invalid value \"{0}\" according to rule {1}", value1);
80         assertEquals(value1, value2);
81         
82         value1 = messages.key(keyName, new Object JavaDoc[]{"'value'", "'rule'"});
83         value2 = resolver.resolveMacros("${key." + keyName + "|'value'|'rule'}");
84         assertEquals("Invalid value \"'value'\" according to rule 'rule'", value1);
85         assertEquals(value1, value2);
86         
87         value1 = messages.key(keyName, new Object JavaDoc[]{"This is the final result", "second"});
88         value2 = resolver.resolveMacros("${key." + keyName + "|${one${two${three}}}|${two${three}}}");
89         assertEquals("Invalid value \"This is the final result\" according to rule second", value1);
90         assertEquals(value1, value2);
91         
92         keyName = org.opencms.xml.content.Messages.GUI_EDITOR_XMLCONTENT_VALIDATION_WARNING_2;
93         value1 = messages.key(keyName);
94         value2 = resolver.resolveMacros("${key." + keyName + "}");
95         assertEquals("Bad value \"{0}\" according to rule {1}", value1);
96         assertEquals(value1, value2);
97         
98         value1 = messages.key(keyName, new Object JavaDoc[]{"some value", "the rule"});
99         value2 = resolver.resolveMacros("${key." + keyName + "|some value|the rule}");
100         assertEquals("Bad value \"some value\" according to rule the rule", value1);
101         assertEquals(value1, value2);
102         
103         value1 = messages.key(keyName, new Object JavaDoc[]{"This is the final result", "second"});
104         value2 = resolver.resolveMacros("${key." + keyName + "|${one${two${three}}}|${two${three}}}");
105         assertEquals("Bad value \"This is the final result\" according to rule second", value1);
106         assertEquals(value1, value2);
107     }
108     
109     
110     /**
111      * Tests the macro resolver "nested macro" functions.<p>
112      */

113     public void testResolveNestedMacros() {
114         
115         CmsMacroResolver resolver = CmsMacroResolver.newInstance();
116         resolver.addMacro("onesecond", "This is the final result");
117         resolver.addMacro("twofirst", "second");
118         resolver.addMacro("three", "first");
119      
120         String JavaDoc content, result;
121         
122         content = "${three}";
123         result = resolver.resolveMacros(content);
124         assertEquals("first", result);
125         
126         content = "${two${three}}";
127         result = resolver.resolveMacros(content);
128         assertEquals("second", result);
129                 
130         content = "${one${two${three}}}";
131         result = resolver.resolveMacros(content);
132         assertEquals("This is the final result", result);
133         
134         content = "${one ${two${three}}}";
135         result = resolver.resolveMacros(content);
136         assertEquals("", result);
137         
138         resolver.setKeepEmptyMacros(true);
139         content = "${one ${two${three}}}";
140         result = resolver.resolveMacros(content);
141         assertEquals("${one second}", result);
142     }
143     
144     /**
145      * Tests the macro resolver main functions.<p>
146      */

147     public void testResolveMacros() {
148            
149         CmsMacroResolver resolver = CmsMacroResolver.newInstance();
150         resolver.addMacro("test", "REPLACED");
151         
152         String JavaDoc content, result;
153         
154         content = "<<This is a prefix >>${test}<<This is a suffix>>";
155         result = resolver.resolveMacros(content);
156         assertEquals("<<This is a prefix >>REPLACED<<This is a suffix>>", result);
157         
158         content = "${test}<<This is a suffix>>";
159         result = resolver.resolveMacros(content);
160         assertEquals("REPLACED<<This is a suffix>>", result);
161         
162         content = "<<This is a prefix >>${test}";
163         result = resolver.resolveMacros(content);
164         assertEquals("<<This is a prefix >>REPLACED", result);
165         
166         content = "<<This is a prefix >>$<<This is a suffix>>";
167         result = resolver.resolveMacros(content);
168         assertEquals("<<This is a prefix >>$<<This is a suffix>>", result);
169
170         content = "$<<This is a suffix>>";
171         result = resolver.resolveMacros(content);
172         assertEquals("$<<This is a suffix>>", result);
173         
174         content = "${<<This is a suffix>>";
175         result = resolver.resolveMacros(content);
176         assertEquals("${<<This is a suffix>>", result);
177         
178         content = "<<This is a prefix >>$";
179         result = resolver.resolveMacros(content);
180         assertEquals("<<This is a prefix >>$", result);
181         
182         content = "<<This is a prefix >>${";
183         result = resolver.resolveMacros(content);
184         assertEquals("<<This is a prefix >>${", result);
185         
186         content = "<<This is a prefix >>${}<<This is a suffix>>";
187         result = resolver.resolveMacros(content);
188         assertEquals("<<This is a prefix >><<This is a suffix>>", result);
189         
190         content = "<<This is a prefix >>${unknown}<<This is a suffix>>";
191         result = resolver.resolveMacros(content);
192         assertEquals("<<This is a prefix >><<This is a suffix>>", result);
193         
194         content = "<<This is a prefix >>${test<<This is a suffix>>";
195         result = resolver.resolveMacros(content);
196         assertEquals("<<This is a prefix >>${test<<This is a suffix>>", result);
197         
198         content = "<<This is a prefix >>${";
199         result = resolver.resolveMacros(content);
200         assertEquals("<<This is a prefix >>${", result);
201         
202         content = "<<This is a prefix >>${${}";
203         result = resolver.resolveMacros(content);
204         assertEquals("<<This is a prefix >>${", result);
205         
206         content = "${$<<This $}{ is$}$ a {{pr${{${efix >>${${}";
207         result = resolver.resolveMacros(content);
208         assertEquals("${$<<This $}{ is$}$ a {{pr${{${efix >>${", result);
209         
210         // test for unknown macros
211

212         content = "<<This is a prefix >>${unknown}<<This is a suffix>>";
213         result = resolver.resolveMacros(content);
214         assertEquals("<<This is a prefix >><<This is a suffix>>", result);
215                 
216         content = "<<This is a prefix >>${unknown}";
217         result = resolver.resolveMacros(content);
218         assertEquals("<<This is a prefix >>", result);
219         
220         content = "${unknown}<<This is a suffix>>";
221         result = resolver.resolveMacros(content);
222         assertEquals("<<This is a suffix>>", result);
223         
224         content = "${test}<<This is a prefix >>${test}${unknown}${test}<<This is a suffix>>${test}";
225         result = resolver.resolveMacros(content);
226         assertEquals("REPLACED<<This is a prefix >>REPLACEDREPLACED<<This is a suffix>>REPLACED", result);
227         
228         // set the "keep unknown macros" flag
229
resolver.setKeepEmptyMacros(true);
230         
231         content = "<<This is a prefix >>${${}";
232         result = resolver.resolveMacros(content);
233         assertEquals("<<This is a prefix >>${${}", result);
234         
235         content = "<<This is a prefix >>${unknown}<<This is a suffix>>";
236         result = resolver.resolveMacros(content);
237         assertEquals("<<This is a prefix >>${unknown}<<This is a suffix>>", result);
238         
239         content = "<<This is a prefix >>${unknown}";
240         result = resolver.resolveMacros(content);
241         assertEquals("<<This is a prefix >>${unknown}", result);
242         
243         content = "${unknown}<<This is a suffix>>";
244         result = resolver.resolveMacros(content);
245         assertEquals("${unknown}<<This is a suffix>>", result);
246         
247         content = "${test}<<This is a prefix >>${test}${unknown}${test}<<This is a suffix>>${test}";
248         result = resolver.resolveMacros(content);
249         assertEquals("REPLACED<<This is a prefix >>REPLACED${unknown}REPLACED<<This is a suffix>>REPLACED", result);
250     }
251     
252     
253     /**
254      * Tests a minimal interface implementation.<p>
255      */

256     public void testResolverInterface() {
257     
258         I_CmsMacroResolver resolver = new I_CmsMacroResolver() {
259             public String JavaDoc getMacroValue(String JavaDoc key) {
260                 if ("test".equals(key)) {
261                     return "REPLACED";
262                 } else {
263                     return null;
264                 }
265             }
266
267             public boolean isKeepEmptyMacros() {
268                 return true;
269             }
270
271             public String JavaDoc resolveMacros(String JavaDoc input) {
272                 return CmsMacroResolver.resolveMacros(input, this);
273             }
274         };
275         
276         String JavaDoc content, result;
277         
278         content = null;
279         result = resolver.resolveMacros(null);
280         assertEquals(null, result);
281         
282         content = "";
283         result = resolver.resolveMacros(content);
284         assertEquals("", result);
285         
286         content = "${test}";
287         result = resolver.resolveMacros(content);
288         assertEquals("REPLACED", result);
289         
290         content = "<<This is a prefix >>${test}<<This is a suffix>>";
291         result = resolver.resolveMacros(content);
292         assertEquals("<<This is a prefix >>REPLACED<<This is a suffix>>", result);
293         
294         content = "${test}<<This is a suffix>>";
295         result = resolver.resolveMacros(content);
296         assertEquals("REPLACED<<This is a suffix>>", result);
297         
298         content = "<<This is a prefix >>${test}";
299         result = resolver.resolveMacros(content);
300         assertEquals("<<This is a prefix >>REPLACED", result);
301         
302         content = "<<This is a prefix >>$<<This is a suffix>>";
303         result = resolver.resolveMacros(content);
304         assertEquals("<<This is a prefix >>$<<This is a suffix>>", result);
305
306         content = "$<<This is a suffix>>";
307         result = resolver.resolveMacros(content);
308         assertEquals("$<<This is a suffix>>", result);
309         
310         content = "<<This is a prefix >>$";
311         result = resolver.resolveMacros(content);
312         assertEquals("<<This is a prefix >>$", result);
313         
314         content = "<<This is a prefix >>${}<<This is a suffix>>";
315         result = resolver.resolveMacros(content);
316         assertEquals("<<This is a prefix >>${}<<This is a suffix>>", result);
317         
318         content = "<<This is a prefix >>${test<<This is a suffix>>";
319         result = resolver.resolveMacros(content);
320         assertEquals("<<This is a prefix >>${test<<This is a suffix>>", result);
321         
322         content = "<<This is a prefix >>${unknown}<<This is a suffix>>";
323         result = resolver.resolveMacros(content);
324         assertEquals("<<This is a prefix >>${unknown}<<This is a suffix>>", result);
325         
326         content = "${test}<<This is a prefix >>${test}${unknown}${test}<<This is a suffix>>${test}";
327         result = resolver.resolveMacros(content);
328         assertEquals("REPLACED<<This is a prefix >>REPLACED${unknown}REPLACED<<This is a suffix>>REPLACED", result);
329         
330         content = "<<This is a prefix >>${unknown}";
331         result = resolver.resolveMacros(content);
332         assertEquals("<<This is a prefix >>${unknown}", result);
333         
334         content = "${unknown}<<This is a suffix>>";
335         result = resolver.resolveMacros(content);
336         assertEquals("${unknown}<<This is a suffix>>", result);
337         
338         content = "Uncle Scrooge owns many $$$$";
339         result = resolver.resolveMacros(content);
340         assertEquals(content, result);
341         
342         content = "$$$$ is what uncle Scrooge owns";
343         result = resolver.resolveMacros(content);
344         assertEquals(content, result);
345         
346         content = "$$$$ is $ what $ uncle $$$ Scrooge $ owns $$$";
347         result = resolver.resolveMacros(content);
348         assertEquals(content, result);
349         
350         content = "$${test}$}${test} is ${ what ${test}{$} uncle ${${test} Scrooge $ owns ${${test}}";
351         result = resolver.resolveMacros(content);
352         assertEquals("$REPLACED$}REPLACED is ${ what REPLACED{$} uncle ${REPLACED Scrooge $ owns ${REPLACED}", result);
353     }
354     
355     /**
356      * Tests macro util functions.<p>
357      */

358     public void testMacroUtils() {
359         
360         assertTrue(CmsMacroResolver.isMacro("%(newStyle)"));
361         assertTrue(CmsMacroResolver.isMacro("${oldStyle}"));
362         assertTrue(CmsMacroResolver.isMacro("%(newStyle)", "newStyle"));
363         assertTrue(CmsMacroResolver.isMacro("${oldStyle}", "oldStyle"));
364         assertFalse(CmsMacroResolver.isMacro("${oldStyle}", "newStyle"));
365         assertFalse(CmsMacroResolver.isMacro("%(newStyle)", "oldStyle"));
366         assertTrue(CmsMacroResolver.isMacro(CmsMacroResolver.formatMacro("macroName")));
367         assertTrue(CmsMacroResolver.isMacro(CmsMacroResolver.formatMacro("macroName"), "macroName"));
368     }
369 }
Popular Tags