1
2
3
4 package org.melati.template.test;
5
6 import org.melati.Melati;
7 import org.melati.MelatiConfig;
8 import org.melati.PoemContext;
9 import org.melati.poem.AccessPoemException;
10 import org.melati.poem.Capability;
11 import org.melati.poem.Field;
12 import org.melati.poem.test.PoemTestCase;
13 import org.melati.template.ClassNameTempletLoader;
14 import org.melati.template.MarkupLanguage;
15 import org.melati.template.NotFoundException;
16 import org.melati.template.Template;
17 import org.melati.template.TemplateContext;
18 import org.melati.template.TemplateEngine;
19 import org.melati.template.TemplateEngineException;
20 import org.melati.util.MelatiStringWriter;
21
22
23
24
25
26
27
28 public class ClassNameTempletLoaderTest extends PoemTestCase {
29
30
31
32
33 public ClassNameTempletLoaderTest(String name) {
34 super(name);
35 }
36
37
38
39
40
41 protected void setUp() throws Exception {
42 super.setUp();
43 }
44
45
46
47
48
49 protected void tearDown() throws Exception {
50 super.tearDown();
51 }
52
53
54
55
56 public void testGetInstance() {
57
58 }
59
60
61
62
63 public void testTempletTemplateEngineMarkupLanguageStringString() throws Exception {
64 MelatiConfig mc = new MelatiConfig();
65 TemplateEngine templateEngine = mc.getTemplateEngine();
66 Templated templated = new Templated();
67 templateEngine.init(mc);
68 Melati m = new Melati(mc, new MelatiStringWriter());
69 m.setTemplateEngine(templateEngine);
70 m.setPoemContext(new PoemContext());
71 assertNotNull(m.getTemplateEngine());
72 MarkupLanguage ml = m.getMarkupLanguage();
73 Template t = ClassNameTempletLoader.getInstance().templet(
74 templateEngine, ml, templated.getClass());
75 TemplateContext tc =
76 templateEngine.getTemplateContext(m);
77 m.setTemplateContext(tc);
78 tc.put("melati", m);
79 tc.put("ml", ml);
80 tc.put("object", new Integer("1"));
81 m.setTemplateContext(tc);
82 t.write(m.getWriter(), m.getTemplateContext(), templateEngine);
83 try {
84 t = ClassNameTempletLoader.getInstance().templet(
85 templateEngine, ml, "error", new Exception().getClass());
86 tc = m.getTemplateContext();
87 tc.put("melati", m);
88 tc.put("ml", ml);
89 tc.put("object", new Integer("1"));
90 t.write(m.getWriter(),tc, m.getTemplateEngine());
91 System.err.println(m.getWriter().toString());
92 fail("Should have bombed");
93 } catch (TemplateEngineException e) {
94 e = null;
95
96 }
97
98 t = ClassNameTempletLoader.getInstance().templet(
99 templateEngine, ml, "error",new Exception().getClass());
100 tc = m.getTemplateContext();
101 tc.put("melati", m);
102 tc.put("ml", ml);
103 tc.put("object",new Exception("A message"));
104 m.setTemplateContext(tc);
105 t.write(m.getWriter(),tc, m.getTemplateEngine());
106 assertTrue(m.getWriter().toString().indexOf("A message") != -1);
107
108 t = ClassNameTempletLoader.getInstance().templet(
109 templateEngine, ml, "error", new AccessPoemException().getClass());
110 tc = m.getTemplateContext();
111 tc.put("melati", m);
112 tc.put("ml", m.getMarkupLanguage());
113 tc.put("object", new AccessPoemException(getDb().getUserTable().guestUser(),new Capability("Cool")));
114 m.setTemplateContext(tc);
115 t.write(m.getWriter(),tc, m.getTemplateEngine());
116
117 assertTrue(m.getWriter().toString().indexOf("[Access denied to Melati guest user]") != -1);
118
119 }
120
121
122
123
124
125 public void testTempletTemplateEngineMarkupLanguageString() throws Exception {
126 MelatiConfig mc = new MelatiConfig();
127 TemplateEngine templateEngine = mc.getTemplateEngine();
128 templateEngine.init(mc);
129 Melati m = new Melati(mc, new MelatiStringWriter());
130 m.setTemplateEngine(templateEngine);
131 m.setPoemContext(new PoemContext());
132 assertNotNull(m.getTemplateEngine());
133 MarkupLanguage ml = m.getMarkupLanguage();
134 try {
135 ClassNameTempletLoader.getInstance().templet(
136 templateEngine, ml,new Integer("1").getClass().getName());
137 fail("Should have bombed");
138 } catch (NotFoundException e) {
139 e = null;
140 }
141 Template t = ClassNameTempletLoader.getInstance().templet(
142 templateEngine, ml, new Object().getClass().getName());
143 TemplateContext tc =
144 templateEngine.getTemplateContext(m);
145 m.setTemplateContext(tc);
146 tc.put("melati", m);
147 tc.put("ml", ml);
148 tc.put("object", new Object());
149 t.write(m.getWriter(),tc, m.getTemplateEngine());
150 assertTrue(m.getWriter().toString().startsWith("[java.lang.Object@"));
151
152 t = ClassNameTempletLoader.getInstance().templet(
153 templateEngine, ml,"org.melati.poem.ReferencePoemType-SelectionWindow");
154 tc = m.getTemplateContext();
155 tc.put("melati", m);
156 tc.put("ml", ml);
157 Field tableField = getDb().getColumnInfoTable().
158 getColumnInfoObject(0).getField("tableinfo");
159 tc.put("object", tableField);
160 t.write(m.getWriter(),tc, m.getTemplateEngine());
161 System.err.println(m.getWriter().toString());
162 assertTrue(m.getWriter().toString().indexOf("tableinfo_button") != -1);
163
164
165 }
166
167
168
169
170
171
172
173
174 public void testTempletTemplateEngineMarkupLanguageStringClass() throws Exception {
175 MelatiConfig mc = new MelatiConfig();
176 TemplateEngine templateEngine = mc.getTemplateEngine();
177 Templated templated = new Templated();
178 templateEngine.init(mc);
179 Melati m = new Melati(mc, new MelatiStringWriter());
180 m.setTemplateEngine(templateEngine);
181 m.setPoemContext(new PoemContext());
182 assertNotNull(m.getTemplateEngine());
183 MarkupLanguage ml = m.getMarkupLanguage();
184 Template t = ClassNameTempletLoader.getInstance().templet(
185 templateEngine, ml, templated.getClass());
186 TemplateContext tc =
187 templateEngine.getTemplateContext(m);
188 m.setTemplateContext(tc);
189 tc.put("melati", m);
190 tc.put("ml", ml);
191 tc.put("object", new Integer("1"));
192 m.setTemplateContext(tc);
193 t.write(m.getWriter(), m.getTemplateContext(), templateEngine);
194 assertEquals("Hi, this is from a template.", m.getWriter().toString());
195 }
196
197
198
199
200
201
202
203 public void testTempletTemplateEngineMarkupLanguageClass() throws Exception {
204 MelatiConfig mc = new MelatiConfig();
205 TemplateEngine templateEngine = mc.getTemplateEngine();
206 templateEngine.init(mc);
207 Melati m = new Melati(mc, new MelatiStringWriter());
208 m.setTemplateEngine(templateEngine);
209 m.setPoemContext(new PoemContext());
210 assertNotNull(m.getTemplateEngine());
211 TemplateContext templateContext =
212 templateEngine.getTemplateContext(m);
213 m.setTemplateContext(templateContext);
214 MarkupLanguage ml = m.getMarkupLanguage();
215 Template t = ClassNameTempletLoader.getInstance().templet(
216 templateEngine, ml,
217 new Integer("1").getClass());
218 TemplateContext tc = m.getTemplateContext();
219 tc.put("melati", m);
220 tc.put("ml", ml);
221 tc.put("object", new Integer("1"));
222 t.write(m.getWriter(), tc, m.getTemplateEngine());
223
224 assertEquals("[1]", m.getWriter().toString().trim());
225
226 }
227
228
229
230
231 public void testTempletTemplateEngineMarkupLanguageFieldAttributes() {
232
233 }
234
235 }