root/tlate/tlate-test.cc

Revision 28939ac15506b95f59142a06b7d6794a801f8198, 7.0 KB (checked in by Antti-Juhani Kaijanaho <antti-juhani@…>, 21 months ago)

Allow templates access to literal special characters

The variable "_" refers by default now to a structured value having
the following members:

  • hash containing "#"
  • dollar containing "$"
  • obrace containing "{"
  • cbrace containing "}"

So, for example, $_.dollar$ in a template will, in general, expand to
the dollar sign.

Closes #75.

Signed-off-by: Antti-Juhani Kaijanaho <antti-juhani@…>
  • Property mode set to 100644
Line 
1/*  This file is part of Alue, the multiprotocol Internet discussion daemon
2
3    Copyright © 2009, 2010 Antti-Juhani Kaijanaho
4
5    Alue is free software: you can redistribute it and/or modify it
6    under the terms of the GNU General Public License as published by
7    the Free Software Foundation, either version 3 of the License, or
8    (at your option) any later version.
9
10    Alue is distributed in the hope that it will be useful, but
11    WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with Alue.  If not, see <http://www.gnu.org/licenses/>.
17
18 */
19
20#include "data_model.hh"
21#include "list_value.hh"
22#include "sequential_value.hh"
23#include "structured_value.hh"
24#include "tlate.hh"
25
26#include "../logger/logline.hh"
27
28#include <boost/shared_ptr.hpp>
29#include <boost/test/unit_test.hpp>
30#include <iostream>
31#include <vector>
32
33namespace tlate_test {
34
35        std::string tester(std::string tls, tlate::structured_value::ptr am)
36        {
37                logger::logger.open(std::cerr);
38                logger::logline ll;
39                ll << "-------------------";
40                ll.close();
41                boost::shared_ptr<tlate::tlate> tl =
42                        tlate::tlate::parse_string(tls);
43                std::ostringstream ss;
44                ss << tl->eval(am);
45                logger::logger.flush();
46                return ss.str();
47        }
48
49        BOOST_AUTO_TEST_CASE(literal)
50        {
51                tlate::data_model::ptr am(new tlate::data_model);
52                BOOST_CHECK_EQUAL("foo",tester("foo",am));
53        }
54
55        BOOST_AUTO_TEST_CASE(braces)
56        {
57                tlate::data_model::ptr am(new tlate::data_model);
58                BOOST_CHECK_EQUAL("",tester("{}",am));
59        }
60
61        BOOST_AUTO_TEST_CASE(dollars)
62        {
63                tlate::data_model::ptr am(new tlate::data_model);
64                BOOST_CHECK_EQUAL("",tester("$   $",am));
65        }
66
67        BOOST_AUTO_TEST_CASE(missing_var)
68        {
69                tlate::data_model::ptr am(new tlate::data_model);
70                BOOST_CHECK_EQUAL("",tester("$foo$",am));
71        }
72
73        BOOST_AUTO_TEST_CASE(string_var)
74        {
75                tlate::data_model::ptr am(new tlate::data_model);
76                am->insert("foo", "bar");
77                BOOST_CHECK_EQUAL("bar",tester("$foo$",am));
78        }
79
80        BOOST_AUTO_TEST_CASE(struct_var)
81        {
82                tlate::data_model::ptr sv(new tlate::data_model);
83                sv->insert("baz", "xyzzy");
84                tlate::data_model::ptr am(new tlate::data_model);
85                am->insert("foo", sv);
86                BOOST_CHECK_EQUAL("",tester("$foo$",am));
87        }
88
89        BOOST_AUTO_TEST_CASE(struct_var_access)
90        {
91                tlate::data_model::ptr sv(new tlate::data_model);
92                sv->insert("baz", "xyzzy");
93                tlate::data_model::ptr am(new tlate::data_model);
94                am->insert("foo", sv);
95                BOOST_CHECK_EQUAL("xyzzy",tester("$foo.baz$",am));
96        }
97
98        BOOST_AUTO_TEST_CASE(seq_var)
99        {
100                tlate::list_value::ptr sev(new tlate::list_value);
101                tlate::string_value::ptr av1(new tlate::string_value("abc"));
102                tlate::string_value::ptr av2(new tlate::string_value("def"));
103                sev->push_back(av1);
104                sev->push_back(av2);
105                tlate::data_model::ptr am(new tlate::data_model);
106                am->insert("foo", sev);
107                BOOST_CHECK_EQUAL("abcdef",tester("$foo$",am));
108        }
109
110        BOOST_AUTO_TEST_CASE(seq_var_access)
111        {
112                tlate::list_value::ptr sev(new tlate::list_value);
113                tlate::string_value::ptr av1(new tlate::string_value("abc"));
114                tlate::string_value::ptr av2(new tlate::string_value("def"));
115                sev->push_back(av1);
116                sev->push_back(av2);
117                tlate::data_model::ptr am(new tlate::data_model);
118                am->insert("foo", sev);
119                BOOST_CHECK_EQUAL("abc def ",
120                                  tester("$for cursor in foo${$cursor$ }",am));
121        }
122
123        BOOST_AUTO_TEST_CASE(iftrue)
124        {
125                tlate::data_model::ptr am(new tlate::data_model);
126                am->insert("foo","");
127                BOOST_CHECK_EQUAL("!",tester("$if foo${!}",am));
128        }
129
130        BOOST_AUTO_TEST_CASE(iffalse)
131        {
132                tlate::data_model::ptr am(new tlate::data_model);
133                BOOST_CHECK_EQUAL("",tester("$if foo${!}",am));
134        }
135
136
137        BOOST_AUTO_TEST_CASE(iftrueelse)
138        {
139                tlate::data_model::ptr am(new tlate::data_model);
140                am->insert("foo","");
141                BOOST_CHECK_EQUAL("!",tester("$if foo${!}$else${?}",am));
142        }
143
144        BOOST_AUTO_TEST_CASE(iffalseelse)
145        {
146                tlate::data_model::ptr am(new tlate::data_model);
147                BOOST_CHECK_EQUAL("?",tester("$if foo${!}$else${?}",am));
148        }
149
150        BOOST_AUTO_TEST_CASE(def)
151        {
152                tlate::data_model::ptr am(new tlate::data_model);
153                BOOST_CHECK_EQUAL("?",tester("$def foo()${?}$foo()$",am));
154        }
155
156        BOOST_AUTO_TEST_CASE(def_parm)
157        {
158                tlate::data_model::ptr am(new tlate::data_model);
159                am->insert("bar","baz");
160                BOOST_CHECK_EQUAL("baz",
161                                  tester("$def foo(x)${$x$}$foo(bar)$",am));
162        }
163
164        BOOST_AUTO_TEST_CASE(comment)
165        {
166                tlate::data_model::ptr am(new tlate::data_model);
167                BOOST_CHECK_EQUAL("foo", tester("#bar\nfoo",am));
168        }
169
170        BOOST_AUTO_TEST_CASE(comment2)
171        {
172                tlate::data_model::ptr am(new tlate::data_model);
173                BOOST_CHECK_EQUAL("foo", tester("#bar\n#bar\nfoo",am));
174        }
175
176        BOOST_AUTO_TEST_CASE(comment3)
177        {
178                tlate::data_model::ptr am(new tlate::data_model);
179                BOOST_CHECK_EQUAL("", tester("#\n",am));
180        }
181
182        BOOST_AUTO_TEST_CASE(eol)
183        {
184                tlate::data_model::ptr am(new tlate::data_model);
185                BOOST_CHECK_EQUAL("\n", tester("\n",am));
186        }
187
188        BOOST_AUTO_TEST_CASE(std_hash)
189        {
190                tlate::data_model::ptr am(new tlate::data_model);
191                BOOST_CHECK_EQUAL("#", tester("$_.hash$",am));
192        }
193
194        BOOST_AUTO_TEST_CASE(std_dollar)
195        {
196                tlate::data_model::ptr am(new tlate::data_model);
197                BOOST_CHECK_EQUAL("$", tester("$_.dollar$",am));
198        }
199
200        BOOST_AUTO_TEST_CASE(std_obrace)
201        {
202                tlate::data_model::ptr am(new tlate::data_model);
203                BOOST_CHECK_EQUAL("{", tester("$_.obrace$",am));
204        }
205        BOOST_AUTO_TEST_CASE(std_cbrace)
206        {
207                tlate::data_model::ptr am(new tlate::data_model);
208                BOOST_CHECK_EQUAL("}", tester("$_.cbrace$",am));
209        }
210}
Note: See TracBrowser for help on using the browser.