[solanum.git] / tests / substitution1.c

/*
 *  substition.c: Test substitution under various conditions
 *  Copyright 2017 Simon Arlott
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
 *  USA
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include "tap/basic.h"

#include "stdinc.h"
#include "ircd_defs.h"
#include "client.h"
#include "substitution.h"

#define MSG "%s:%d (%s)", __FILE__, __LINE__, __FUNCTION__

struct Client me;
static const char text[] =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba"
"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba"
"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba"
"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba"
"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba"
"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
;

#define MKTEXT(n) &text[sizeof(text) - ((n) + 1)]

static rb_dlink_list varlist = { NULL, NULL, 0 };
static rb_dlink_list varlist2 = { NULL, NULL, 0 };

static void valid_variable1(void)
{
	is_string("TEST1", substitution_parse("${test1}", &varlist), MSG);
}

static void valid_variable2(void)
{
	is_string("TEST1TEST5", substitution_parse("${test1}${test5}", &varlist), MSG);
}

static void missing_variable1(void)
{
	is_string("", substitution_parse("${test6}", &varlist), MSG);
}

static void missing_variable2(void)
{
	is_string("", substitution_parse("${test6}${test7}", &varlist), MSG);
}

static void unterminated_variable1a(void)
{
	is_string("TEST2", substitution_parse("${test2", &varlist), MSG);
}

static void unterminated_variable1b(void)
{
	is_string("TEST2", substitution_parse("${test2\0${test8", &varlist), MSG);
}

static void unterminated_variable2a(void)
{
	is_string("TEST3TEST4", substitution_parse("${test3${test4", &varlist), MSG);
}

static void unterminated_variable2b(void)
{
	is_string("TEST3TEST4", substitution_parse("${test3${test4\0${test9", &varlist), MSG);
}

static void unterminated_missing_variable1(void)
{
	is_string("", substitution_parse("${test6", &varlist), MSG);
}

static void unterminated_missing_variable2(void)
{
	is_string("", substitution_parse("${test6${test7", &varlist), MSG);
}

static void empty_variable1(void)
{
	is_string("", substitution_parse("${}", &varlist), MSG);
}

static void empty_variable2(void)
{
	is_string("}", substitution_parse("${${}}", &varlist), MSG);
}

static void empty_unterminated_variable1(void)
{
	is_string("", substitution_parse("${", &varlist), MSG);
}

static void empty_unterminated_variable2(void)
{
	is_string("", substitution_parse("${${", &varlist), MSG);
}

static void long_variable1a(void) {
	is_int(512, BUFSIZE, MSG);
	is_string(MKTEXT(510), substitution_parse("${text510}", &varlist2), MSG);
}

static void long_variable1b(void) {
	is_int(512, BUFSIZE, MSG);
	is_string(MKTEXT(511), substitution_parse("${text511}", &varlist2), MSG);
}

static void too_long_variable1a(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(512));
	tmp2[511] = 0; /* text will be truncated to 511 chars */

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text512}", &varlist2), MSG);
}

static void too_long_variable1b(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(513));
	tmp2[511] = 0; /* text will be truncated to 511 chars */

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text513}", &varlist2), MSG);
}

static void too_long_variable1c(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(600));
	tmp2[511] = 0; /* text will be truncated to 511 chars */

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text600}", &varlist2), MSG);
}

static void long_variable2a(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(500));
	strcat(tmp2, MKTEXT(10));

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text500}${text10}", &varlist2), MSG);
}

static void long_variable2b(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(500));
	strcat(tmp2, MKTEXT(11));

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text500}${text11}", &varlist2), MSG);
}

static void too_long_variable2a(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(500));
	strcat(tmp2, MKTEXT(12));
	tmp2[511] = 0; /* text will be truncated to 511 chars */

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text500}${text12}", &varlist2), MSG);
}

static void too_long_variable2b(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(500));
	strcat(tmp2, MKTEXT(13));
	tmp2[511] = 0; /* text will be truncated to 511 chars */

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text500}${text13}", &varlist2), MSG);
}

static void too_long_variable2c(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(600));
	strcat(tmp2, MKTEXT(10));
	tmp2[511] = 0; /* text will be truncated to 511 chars */

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text600}${text10}", &varlist2), MSG);
}

static void long_variable3a(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(100));
	strcat(tmp2, MKTEXT(400));
	strcat(tmp2, MKTEXT(10));

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text100}${text400}${text10}", &varlist2), MSG);
}

static void long_variable3b(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(100));
	strcat(tmp2, MKTEXT(400));
	strcat(tmp2, MKTEXT(11));

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text100}${text400}${text11}", &varlist2), MSG);
}

static void too_long_variable3a(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(100));
	strcat(tmp2, MKTEXT(400));
	strcat(tmp2, MKTEXT(12));
	tmp2[511] = 0; /* text will be truncated to 511 chars */

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text100}${text400}${text12}", &varlist2), MSG);
}

static void too_long_variable3b(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(100));
	strcat(tmp2, MKTEXT(400));
	strcat(tmp2, MKTEXT(13));
	tmp2[511] = 0; /* text will be truncated to 511 chars */

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text100}${text400}${text13}", &varlist2), MSG);
}

static void too_long_variable3c(void) {
	char tmp2[2048];

	strcpy(tmp2, MKTEXT(200));
	strcat(tmp2, MKTEXT(400));
	strcat(tmp2, MKTEXT(100));
	tmp2[511] = 0; /* text will be truncated to 511 chars */

	is_int(512, BUFSIZE, MSG);
	is_string(tmp2, substitution_parse("${text200}${text400}${text100}", &varlist2), MSG);
}

static void long_variable_name1(void) {
	char input[2048];

	strcpy(input, "${");
	strcat(input, MKTEXT(1000));
	strcat(input, "}");

	is_string("test", substitution_parse(input, &varlist2), MSG);
}

int main(int argc, char *argv[])
{
	memset(&me, 0, sizeof(me));
	strcpy(me.name, "me.name.");

	rb_lib_init(NULL, NULL, NULL, 0, 1024, DNODE_HEAP_SIZE, FD_HEAP_SIZE);
	rb_linebuf_init(LINEBUF_HEAP_SIZE);

	substitution_append_var(&varlist, "testB", "TESTB");
	substitution_append_var(&varlist, "test1", "TEST1");
	substitution_append_var(&varlist, "test2", "TEST2");
	substitution_append_var(&varlist, "test3", "TEST3");
	substitution_append_var(&varlist, "test4", "TEST4");
	substitution_append_var(&varlist, "test5", "TEST5");
	substitution_append_var(&varlist, "test9", "TEST9");
	substitution_append_var(&varlist, "testE", "TESTE");

	substitution_append_var(&varlist2, "text10", MKTEXT(10));
	substitution_append_var(&varlist2, "text11", MKTEXT(11));
	substitution_append_var(&varlist2, "text12", MKTEXT(12));
	substitution_append_var(&varlist2, "text13", MKTEXT(13));
	substitution_append_var(&varlist2, "text14", MKTEXT(14));
	substitution_append_var(&varlist2, "text100", MKTEXT(100));
	substitution_append_var(&varlist2, "text200", MKTEXT(200));
	substitution_append_var(&varlist2, "text400", MKTEXT(400));
	substitution_append_var(&varlist2, "text500", MKTEXT(500));
	substitution_append_var(&varlist2, "text510", MKTEXT(510));
	substitution_append_var(&varlist2, "text511", MKTEXT(511));
	substitution_append_var(&varlist2, "text512", MKTEXT(512));
	substitution_append_var(&varlist2, "text513", MKTEXT(513));
	substitution_append_var(&varlist2, "text514", MKTEXT(514));
	substitution_append_var(&varlist2, "text600", MKTEXT(600));

	char temp[2048];
	strcpy(temp, MKTEXT(1000));
	temp[BUFSIZE - 1] = '\0';
	substitution_append_var(&varlist2, temp, "test");

	plan_lazy();

	valid_variable1();
	valid_variable2();
	missing_variable1();
	missing_variable2();
	unterminated_variable1a();
	unterminated_variable1b();
	unterminated_variable2a();
	unterminated_variable2b();
	unterminated_missing_variable1();
	unterminated_missing_variable2();
	empty_variable1();
	empty_variable2();
	empty_unterminated_variable1();
	empty_unterminated_variable2();

	long_variable1a();
	long_variable1b();
	long_variable2a();
	long_variable2b();
	long_variable3a();
	long_variable3b();
	too_long_variable1a();
	too_long_variable1b();
	too_long_variable1c();
	too_long_variable2a();
	too_long_variable2b();
	too_long_variable2c();
	too_long_variable3a();
	too_long_variable3b();
	too_long_variable3c();

	long_variable_name1();

	substitution_free(&varlist);
	substitution_free(&varlist2);

	return 0;
}
Commit	Line	Data
17ea8880 SA	1	/*
	2	* substition.c: Test substitution under various conditions
	3	* Copyright 2017 Simon Arlott
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
	18	* USA
	19	*/
	20	#include <stdio.h>
	21	#include <string.h>
	22	#include <stdlib.h>
	23	#include <unistd.h>
	24	#include "tap/basic.h"
	25
	26	#include "stdinc.h"
	27	#include "ircd_defs.h"
	28	#include "client.h"
	29	#include "substitution.h"
	30
	31	#define MSG "%s:%d (%s)", __FILE__, __LINE__, __FUNCTION__
	32
	33	struct Client me;
17ea8880 SA	34	static const char text[] =
	35	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba"
	36	"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	37	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba"
	38	"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	39	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba"
	40	"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	41	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba"
	42	"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	43	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba"
	44	"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	45	;
	46
	47	#define MKTEXT(n) &text[sizeof(text) - ((n) + 1)]
	48
	49	static rb_dlink_list varlist = { NULL, NULL, 0 };
	50	static rb_dlink_list varlist2 = { NULL, NULL, 0 };
	51
	52	static void valid_variable1(void)
	53	{
	54	is_string("TEST1", substitution_parse("${test1}", &varlist), MSG);
	55	}
	56
	57	static void valid_variable2(void)
	58	{
	59	is_string("TEST1TEST5", substitution_parse("${test1}${test5}", &varlist), MSG);
	60	}
	61
	62	static void missing_variable1(void)
	63	{
	64	is_string("", substitution_parse("${test6}", &varlist), MSG);
	65	}
	66
	67	static void missing_variable2(void)
	68	{
	69	is_string("", substitution_parse("${test6}${test7}", &varlist), MSG);
	70	}
	71
	72	static void unterminated_variable1a(void)
	73	{
	74	is_string("TEST2", substitution_parse("${test2", &varlist), MSG);
	75	}
	76
	77	static void unterminated_variable1b(void)
	78	{
	79	is_string("TEST2", substitution_parse("${test2\0${test8", &varlist), MSG);
	80	}
	81
	82	static void unterminated_variable2a(void)
	83	{
	84	is_string("TEST3TEST4", substitution_parse("${test3${test4", &varlist), MSG);
	85	}
	86
	87	static void unterminated_variable2b(void)
	88	{
	89	is_string("TEST3TEST4", substitution_parse("${test3${test4\0${test9", &varlist), MSG);
	90	}
	91
	92	static void unterminated_missing_variable1(void)
	93	{
	94	is_string("", substitution_parse("${test6", &varlist), MSG);
	95	}
	96
	97	static void unterminated_missing_variable2(void)
98	{
99	is_string("", substitution_parse("${test6${test7", &varlist), MSG);
100	}
101
102	static void empty_variable1(void)
103	{
104	is_string("", substitution_parse("${}", &varlist), MSG);
105	}
106
107	static void empty_variable2(void)
108	{
109	is_string("}", substitution_parse("${${}}", &varlist), MSG);
110	}
111
112	static void empty_unterminated_variable1(void)
113	{
114	is_string("", substitution_parse("${", &varlist), MSG);
115	}
116
117	static void empty_unterminated_variable2(void)
118	{
119	is_string("", substitution_parse("${${", &varlist), MSG);
120	}
121
122	static void long_variable1a(void) {
123	is_int(512, BUFSIZE, MSG);
124	is_string(MKTEXT(510), substitution_parse("${text510}", &varlist2), MSG);
125	}
126
127	static void long_variable1b(void) {
128	is_int(512, BUFSIZE, MSG);
129	is_string(MKTEXT(511), substitution_parse("${text511}", &varlist2), MSG);
130	}
131
132	static void too_long_variable1a(void) {
133	char tmp2[2048];
134
135	strcpy(tmp2, MKTEXT(512));
136	tmp2[511] = 0; /* text will be truncated to 511 chars */
137
138	is_int(512, BUFSIZE, MSG);
139	is_string(tmp2, substitution_parse("${text512}", &varlist2), MSG);
140	}
141
142	static void too_long_variable1b(void) {
143	char tmp2[2048];
144
145	strcpy(tmp2, MKTEXT(513));
146	tmp2[511] = 0; /* text will be truncated to 511 chars */
147
148	is_int(512, BUFSIZE, MSG);
149	is_string(tmp2, substitution_parse("${text513}", &varlist2), MSG);
150	}
151
152	static void too_long_variable1c(void) {
153	char tmp2[2048];
154
155	strcpy(tmp2, MKTEXT(600));
156	tmp2[511] = 0; /* text will be truncated to 511 chars */
157
158	is_int(512, BUFSIZE, MSG);
159	is_string(tmp2, substitution_parse("${text600}", &varlist2), MSG);
160	}
161
162	static void long_variable2a(void) {
163	char tmp2[2048];
164
165	strcpy(tmp2, MKTEXT(500));
166	strcat(tmp2, MKTEXT(10));
167
168	is_int(512, BUFSIZE, MSG);
169	is_string(tmp2, substitution_parse("${text500}${text10}", &varlist2), MSG);
170	}
171
172	static void long_variable2b(void) {
173	char tmp2[2048];
174
175	strcpy(tmp2, MKTEXT(500));
176	strcat(tmp2, MKTEXT(11));
177
178	is_int(512, BUFSIZE, MSG);
179	is_string(tmp2, substitution_parse("${text500}${text11}", &varlist2), MSG);
180	}
181
182	static void too_long_variable2a(void) {
183	char tmp2[2048];
184
185	strcpy(tmp2, MKTEXT(500));
186	strcat(tmp2, MKTEXT(12));
187	tmp2[511] = 0; /* text will be truncated to 511 chars */
188
189	is_int(512, BUFSIZE, MSG);
190	is_string(tmp2, substitution_parse("${text500}${text12}", &varlist2), MSG);
191	}
192
193	static void too_long_variable2b(void) {
194	char tmp2[2048];
195
196	strcpy(tmp2, MKTEXT(500));
197	strcat(tmp2, MKTEXT(13));
198	tmp2[511] = 0; /* text will be truncated to 511 chars */
199
200	is_int(512, BUFSIZE, MSG);
201	is_string(tmp2, substitution_parse("${text500}${text13}", &varlist2), MSG);
202	}
203
204	static void too_long_variable2c(void) {
205	char tmp2[2048];
206
207	strcpy(tmp2, MKTEXT(600));
208	strcat(tmp2, MKTEXT(10));
209	tmp2[511] = 0; /* text will be truncated to 511 chars */
210
211	is_int(512, BUFSIZE, MSG);
212	is_string(tmp2, substitution_parse("${text600}${text10}", &varlist2), MSG);
213	}
214
215	static void long_variable3a(void) {
216	char tmp2[2048];
217
218	strcpy(tmp2, MKTEXT(100));
219	strcat(tmp2, MKTEXT(400));
220	strcat(tmp2, MKTEXT(10));
221
222	is_int(512, BUFSIZE, MSG);
223	is_string(tmp2, substitution_parse("${text100}${text400}${text10}", &varlist2), MSG);
224	}
225
226	static void long_variable3b(void) {
227	char tmp2[2048];
228
229	strcpy(tmp2, MKTEXT(100));
230	strcat(tmp2, MKTEXT(400));
231	strcat(tmp2, MKTEXT(11));
232
233	is_int(512, BUFSIZE, MSG);
234	is_string(tmp2, substitution_parse("${text100}${text400}${text11}", &varlist2), MSG);
235	}
236
237	static void too_long_variable3a(void) {
238	char tmp2[2048];
239
240	strcpy(tmp2, MKTEXT(100));
241	strcat(tmp2, MKTEXT(400));
242	strcat(tmp2, MKTEXT(12));
243	tmp2[511] = 0; /* text will be truncated to 511 chars */
244
245	is_int(512, BUFSIZE, MSG);
246	is_string(tmp2, substitution_parse("${text100}${text400}${text12}", &varlist2), MSG);
247	}
248
249	static void too_long_variable3b(void) {
250	char tmp2[2048];
251
252	strcpy(tmp2, MKTEXT(100));
253	strcat(tmp2, MKTEXT(400));
254	strcat(tmp2, MKTEXT(13));
255	tmp2[511] = 0; /* text will be truncated to 511 chars */
256
257	is_int(512, BUFSIZE, MSG);
258	is_string(tmp2, substitution_parse("${text100}${text400}${text13}", &varlist2), MSG);
259	}
260
261	static void too_long_variable3c(void) {
262	char tmp2[2048];
263
264	strcpy(tmp2, MKTEXT(200));
265	strcat(tmp2, MKTEXT(400));
266	strcat(tmp2, MKTEXT(100));
267	tmp2[511] = 0; /* text will be truncated to 511 chars */
268
269	is_int(512, BUFSIZE, MSG);
270	is_string(tmp2, substitution_parse("${text200}${text400}${text100}", &varlist2), MSG);
271	}
272
42124941 SA	273	static void long_variable_name1(void) {
	274	char input[2048];
	275
	276	strcpy(input, "${");
	277	strcat(input, MKTEXT(1000));
	278	strcat(input, "}");
	279
	280	is_string("test", substitution_parse(input, &varlist2), MSG);
	281	}
	282
17ea8880 SA	283	int main(int argc, char *argv[])
	284	{
	285	memset(&me, 0, sizeof(me));
	286	strcpy(me.name, "me.name.");
	287
	288	rb_lib_init(NULL, NULL, NULL, 0, 1024, DNODE_HEAP_SIZE, FD_HEAP_SIZE);
	289	rb_linebuf_init(LINEBUF_HEAP_SIZE);
	290
	291	substitution_append_var(&varlist, "testB", "TESTB");
	292	substitution_append_var(&varlist, "test1", "TEST1");
	293	substitution_append_var(&varlist, "test2", "TEST2");
	294	substitution_append_var(&varlist, "test3", "TEST3");
	295	substitution_append_var(&varlist, "test4", "TEST4");
	296	substitution_append_var(&varlist, "test5", "TEST5");
	297	substitution_append_var(&varlist, "test9", "TEST9");
	298	substitution_append_var(&varlist, "testE", "TESTE");
	299
	300	substitution_append_var(&varlist2, "text10", MKTEXT(10));
	301	substitution_append_var(&varlist2, "text11", MKTEXT(11));
	302	substitution_append_var(&varlist2, "text12", MKTEXT(12));
	303	substitution_append_var(&varlist2, "text13", MKTEXT(13));
	304	substitution_append_var(&varlist2, "text14", MKTEXT(14));
	305	substitution_append_var(&varlist2, "text100", MKTEXT(100));
	306	substitution_append_var(&varlist2, "text200", MKTEXT(200));
	307	substitution_append_var(&varlist2, "text400", MKTEXT(400));
	308	substitution_append_var(&varlist2, "text500", MKTEXT(500));
	309	substitution_append_var(&varlist2, "text510", MKTEXT(510));
	310	substitution_append_var(&varlist2, "text511", MKTEXT(511));
	311	substitution_append_var(&varlist2, "text512", MKTEXT(512));
	312	substitution_append_var(&varlist2, "text513", MKTEXT(513));
	313	substitution_append_var(&varlist2, "text514", MKTEXT(514));
	314	substitution_append_var(&varlist2, "text600", MKTEXT(600));
	315
42124941 SA	316	char temp[2048];
	317	strcpy(temp, MKTEXT(1000));
	318	temp[BUFSIZE - 1] = '\0';
	319	substitution_append_var(&varlist2, temp, "test");
	320
17ea8880 SA	321	plan_lazy();
	322
	323	valid_variable1();
	324	valid_variable2();
	325	missing_variable1();
	326	missing_variable2();
	327	unterminated_variable1a();
	328	unterminated_variable1b();
	329	unterminated_variable2a();
	330	unterminated_variable2b();
	331	unterminated_missing_variable1();
	332	unterminated_missing_variable2();
	333	empty_variable1();
	334	empty_variable2();
	335	empty_unterminated_variable1();
	336	empty_unterminated_variable2();
	337
	338	long_variable1a();
	339	long_variable1b();
	340	long_variable2a();
	341	long_variable2b();
	342	long_variable3a();
	343	long_variable3b();
	344	too_long_variable1a();
	345	too_long_variable1b();
	346	too_long_variable1c();
	347	too_long_variable2a();
	348	too_long_variable2b();
	349	too_long_variable2c();
	350	too_long_variable3a();
	351	too_long_variable3b();
	352	too_long_variable3c();
	353
42124941 SA	354	long_variable_name1();
	355
	356	substitution_free(&varlist);
	357	substitution_free(&varlist2);
	358
17ea8880 SA	359	return 0;
17ea8880 SA	360	}