[deliverable/titan.core.git] / regression_test / predefFunction / length_of_SW.ttcn

/******************************************************************************
 * Copyright (c) 2000-2015 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 ******************************************************************************/
module length_of_SW {	//^In TTCN-3 module `length_of_SW'://

type component PDTestComponent {};

/*--- LENGTH OF BITSTRING --------------------------------------------------*/

const bitstring lofb := '1110001100'B
const bitstring lofb1 := ''B

const integer lofbi := lengthof(lofb & lofb)
const integer lofbi1 := lengthof(substr(lofb,0,lengthof(lofb)))
const integer lofbi2 := lengthof(substr(lofb,0,lengthof(lofb)/2))
const integer lofbi3 := lengthof(lofb & lofb1)
const integer lofbi4 := lengthof(lofb1 & lofb1)
const integer lofbi5 := lengthof(substr(lofb1,0,lengthof(lofb1)))

testcase lengthof_bitstr() runs on PDTestComponent{ //In testcase definition//

	if ((lofbi == 2*lengthof(lofb))
	and (lofbi == lengthof(lofb & lofb)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofbi1 == lengthof(lofb))
	and (lofbi1 == lengthof(substr(lofb,0,lengthof(lofb)))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofbi2 == 5)
	and (lofbi2 == lengthof(substr(lofb,0,lengthof(lofb)/2))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofbi3 == 10)
	and (lofbi3 == lengthof(lofb & lofb1)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofbi4 == 0)
	and (lofbi4 == lengthof(lofb1 & lofb1)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofbi5 == 0)
	and (lofbi5 == lengthof(substr(lofb1,0,lengthof(lofb1)))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
}

/*--- LENGTH OF HEXSTRING --------------------------------------------------*/

const hexstring lofh := '1110001100'H
const hexstring lofh1 := ''H

const integer lofhi := lengthof(lofh & lofh)
const integer lofhi1 := lengthof(substr(lofh,0,lengthof(lofh)))
const integer lofhi2 := lengthof(substr(lofh,0,lengthof(lofh)/2))
const integer lofhi3 := lengthof(lofh & lofh1)
const integer lofhi4 := lengthof(lofh1 & lofh1)
const integer lofhi5 := lengthof(substr(lofh1,0,lengthof(lofh1)))

testcase lengthof_hexstr() runs on PDTestComponent{ //In testcase definition//

	if ((lofhi == 2*lengthof(lofh))
	and (lofhi == lengthof(lofh & lofh)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofhi1 == lengthof(lofh))
	and (lofhi1 == lengthof(substr(lofh,0,lengthof(lofh)))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofhi2 == 5)
	and (lofhi2 == lengthof(substr(lofh,0,lengthof(lofh)/2))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofhi3 == 10)
	and (lofhi3 == lengthof(lofh & lofh1)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofhi4 == 0)
	and (lofhi4 == lengthof(lofh1 & lofh1)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofhi5 == 0)
	and (lofhi5 == lengthof(substr(lofh1,0,lengthof(lofh1)))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
}

/*--- LENGTH OF OCTETSTRING --------------------------------------------------*/

const octetstring lofo := '11111100000011110000'O
const octetstring lofo1 := ''O

const integer lofoi := lengthof(lofo & lofo)
const integer lofoi1 := lengthof(substr(lofo,0,lengthof(lofo)))
const integer lofoi2 := lengthof(substr(lofo,0,lengthof(lofo)/2))
const integer lofoi3 := lengthof(lofo & lofo1)
const integer lofoi4 := lengthof(lofo1 & lofo1)
const integer lofoi5 := lengthof(substr(lofo1,0,lengthof(lofo1)))

testcase lengthof_octetstr() runs on PDTestComponent{ //In testcase definition//

	if ((lofoi == 2*lengthof(lofo))
	and (lofoi == lengthof(lofo & lofo)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofoi1 == lengthof(lofo))
	and (lofoi1 == lengthof(substr(lofo,0,lengthof(lofo)))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofoi2 == 5)
	and (lofoi2 == lengthof(substr(lofo,0,lengthof(lofo)/2))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofoi3 == 10)
	and (lofoi3 == lengthof(lofo & lofo1)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofoi4 == 0)
	and (lofoi4 == lengthof(lofo1 & lofo1)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofoi5 == 0)
	and (lofoi5 == lengthof(substr(lofo1,0,lengthof(lofo1)))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
}


/*--- LENGTH OF CHARSTRING --------------------------------------------------*/

const charstring lofc := "1110001100"
const charstring lofc1 := ""

const integer lofci := lengthof(lofc & lofc)
const integer lofci1 := lengthof(substr(lofc,0,lengthof(lofc)))
const integer lofci2 := lengthof(substr(lofc,0,lengthof(lofc)/2))
const integer lofci3 := lengthof(lofc & lofc1)
const integer lofci4 := lengthof(lofc1 & lofc1)
const integer lofci5 := lengthof(substr(lofc1,0,lengthof(lofc1)))

testcase lengthof_charstr() runs on PDTestComponent{ //In testcase definition//

	if ((lofci == 2*lengthof(lofc))
	and (lofci == lengthof(lofc & lofc)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofci1 == lengthof(lofc))
	and (lofci1 == lengthof(substr(lofc,0,lengthof(lofc)))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofci2 == 5)
	and (lofci2 == lengthof(substr(lofc,0,lengthof(lofc)/2))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofci3 == 10)
	and (lofci3 == lengthof(lofc & lofc1)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofci4 == 0)
	and (lofci4 == lengthof(lofc1 & lofc1)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofci5 == 0)
	and (lofci5 == lengthof(substr(lofc1,0,lengthof(lofc1)))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
}


/*--- LENGTH OF UNIVERSAL CHARSTRING --------------------------------------------------*/

const universal charstring lofuc := "1111" & char(0,0,0,65) & "0000" & char(0,0,0,66)
const universal charstring lofuc1 := ""

const integer lofuci := lengthof(lofuc & lofuc)
const integer lofuci1 := lengthof(substr(lofuc,0,lengthof(lofuc)))
const integer lofuci2 := lengthof(substr(lofuc,0,lengthof(lofuc)/2))
const integer lofuci3 := lengthof(lofuc & lofuc1)
const integer lofuci4 := lengthof(lofuc1 & lofuc1)
const integer lofuci5 := lengthof(substr(lofuc1,0,lengthof(lofuc1)))

testcase lengthof_ucharstr() runs on PDTestComponent{ //In testcase definition//

	if ((lofuci == 2*lengthof(lofuc))
	and (lofuci == lengthof(lofuc & lofuc)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofuci1 == lengthof(lofuc))
	and (lofuci1 == lengthof(substr(lofuc,0,lengthof(lofuc)))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofuci2 == 5)
	and (lofuci2 == lengthof(substr(lofuc,0,lengthof(lofuc)/2))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofuci3 == 10)
	and (lofuci3 == lengthof(lofuc & lofuc1)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofuci4 == 0)
	and (lofuci4 == lengthof(lofuc1 & lofuc1)))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
	if ((lofuci5 == 0)
	and (lofuci5 == lengthof(substr(lofuc1,0,lengthof(lofuc1)))))
	     {setverdict(pass);}
	else {setverdict(fail);} //^In else statement// \
                             //^warning\: Control never reaches this code because of previous effective condition\(s\)//
}

control {
	execute (lengthof_bitstr());
	execute (lengthof_hexstr());
	execute (lengthof_octetstr());
	execute (lengthof_charstr());
	execute (lengthof_ucharstr());
}

}
Commit	Line	Data
970ed795	1	/******************************************************************************
3abe9331	2	* Copyright (c) 2000-2015 Ericsson Telecom AB
970ed795 EL	3	* All rights reserved. This program and the accompanying materials
	4	* are made available under the terms of the Eclipse Public License v1.0
	5	* which accompanies this distribution, and is available at
	6	* http://www.eclipse.org/legal/epl-v10.html
	7	******************************************************************************/
	8	module length_of_SW { //^In TTCN-3 module `length_of_SW'://
	9
	10	type component PDTestComponent {};
	11
	12	/--- LENGTH OF BITSTRING --------------------------------------------------/
	13
	14	const bitstring lofb := '1110001100'B
	15	const bitstring lofb1 := ''B
	16
	17	const integer lofbi := lengthof(lofb & lofb)
	18	const integer lofbi1 := lengthof(substr(lofb,0,lengthof(lofb)))
	19	const integer lofbi2 := lengthof(substr(lofb,0,lengthof(lofb)/2))
	20	const integer lofbi3 := lengthof(lofb & lofb1)
	21	const integer lofbi4 := lengthof(lofb1 & lofb1)
	22	const integer lofbi5 := lengthof(substr(lofb1,0,lengthof(lofb1)))
	23
	24	testcase lengthof_bitstr() runs on PDTestComponent{ //In testcase definition//
	25
	26	if ((lofbi == 2*lengthof(lofb))
	27	and (lofbi == lengthof(lofb & lofb)))
	28	{setverdict(pass);}
	29	else {setverdict(fail);} //^In else statement// \
	30	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
	31	if ((lofbi1 == lengthof(lofb))
	32	and (lofbi1 == lengthof(substr(lofb,0,lengthof(lofb)))))
	33	{setverdict(pass);}
	34	else {setverdict(fail);} //^In else statement// \
	35	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
	36	if ((lofbi2 == 5)
	37	and (lofbi2 == lengthof(substr(lofb,0,lengthof(lofb)/2))))
	38	{setverdict(pass);}
	39	else {setverdict(fail);} //^In else statement// \
	40	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
	41	if ((lofbi3 == 10)
	42	and (lofbi3 == lengthof(lofb & lofb1)))
	43	{setverdict(pass);}
	44	else {setverdict(fail);} //^In else statement// \
	45	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
	46	if ((lofbi4 == 0)
	47	and (lofbi4 == lengthof(lofb1 & lofb1)))
	48	{setverdict(pass);}
	49	else {setverdict(fail);} //^In else statement// \
	50	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
	51	if ((lofbi5 == 0)
	52	and (lofbi5 == lengthof(substr(lofb1,0,lengthof(lofb1)))))
	53	{setverdict(pass);}
	54	else {setverdict(fail);} //^In else statement// \
	55	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
	56	}
	57
	58	/--- LENGTH OF HEXSTRING --------------------------------------------------/
	59
	60	const hexstring lofh := '1110001100'H
	61	const hexstring lofh1 := ''H
	62
	63	const integer lofhi := lengthof(lofh & lofh)
	64	const integer lofhi1 := lengthof(substr(lofh,0,lengthof(lofh)))
	65	const integer lofhi2 := lengthof(substr(lofh,0,lengthof(lofh)/2))
	66	const integer lofhi3 := lengthof(lofh & lofh1)
67	const integer lofhi4 := lengthof(lofh1 & lofh1)
68	const integer lofhi5 := lengthof(substr(lofh1,0,lengthof(lofh1)))
69
70	testcase lengthof_hexstr() runs on PDTestComponent{ //In testcase definition//
71
72	if ((lofhi == 2*lengthof(lofh))
73	and (lofhi == lengthof(lofh & lofh)))
74	{setverdict(pass);}
75	else {setverdict(fail);} //^In else statement// \
76	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
77	if ((lofhi1 == lengthof(lofh))
78	and (lofhi1 == lengthof(substr(lofh,0,lengthof(lofh)))))
79	{setverdict(pass);}
80	else {setverdict(fail);} //^In else statement// \
81	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
82	if ((lofhi2 == 5)
83	and (lofhi2 == lengthof(substr(lofh,0,lengthof(lofh)/2))))
84	{setverdict(pass);}
85	else {setverdict(fail);} //^In else statement// \
86	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
87	if ((lofhi3 == 10)
88	and (lofhi3 == lengthof(lofh & lofh1)))
89	{setverdict(pass);}
90	else {setverdict(fail);} //^In else statement// \
91	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
92	if ((lofhi4 == 0)
93	and (lofhi4 == lengthof(lofh1 & lofh1)))
94	{setverdict(pass);}
95	else {setverdict(fail);} //^In else statement// \
96	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
97	if ((lofhi5 == 0)
98	and (lofhi5 == lengthof(substr(lofh1,0,lengthof(lofh1)))))
99	{setverdict(pass);}
100	else {setverdict(fail);} //^In else statement// \
101	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
102	}
103
104	/--- LENGTH OF OCTETSTRING --------------------------------------------------/
105
106	const octetstring lofo := '11111100000011110000'O
107	const octetstring lofo1 := ''O
108
109	const integer lofoi := lengthof(lofo & lofo)
110	const integer lofoi1 := lengthof(substr(lofo,0,lengthof(lofo)))
111	const integer lofoi2 := lengthof(substr(lofo,0,lengthof(lofo)/2))
112	const integer lofoi3 := lengthof(lofo & lofo1)
113	const integer lofoi4 := lengthof(lofo1 & lofo1)
114	const integer lofoi5 := lengthof(substr(lofo1,0,lengthof(lofo1)))
115
116	testcase lengthof_octetstr() runs on PDTestComponent{ //In testcase definition//
117
118	if ((lofoi == 2*lengthof(lofo))
119	and (lofoi == lengthof(lofo & lofo)))
120	{setverdict(pass);}
121	else {setverdict(fail);} //^In else statement// \
122	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
123	if ((lofoi1 == lengthof(lofo))
124	and (lofoi1 == lengthof(substr(lofo,0,lengthof(lofo)))))
125	{setverdict(pass);}
126	else {setverdict(fail);} //^In else statement// \
127	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
128	if ((lofoi2 == 5)
129	and (lofoi2 == lengthof(substr(lofo,0,lengthof(lofo)/2))))
130	{setverdict(pass);}
131	else {setverdict(fail);} //^In else statement// \
132	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
133	if ((lofoi3 == 10)
134	and (lofoi3 == lengthof(lofo & lofo1)))
135	{setverdict(pass);}
136	else {setverdict(fail);} //^In else statement// \
137	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
138	if ((lofoi4 == 0)
139	and (lofoi4 == lengthof(lofo1 & lofo1)))
140	{setverdict(pass);}
141	else {setverdict(fail);} //^In else statement// \
142	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
143	if ((lofoi5 == 0)
144	and (lofoi5 == lengthof(substr(lofo1,0,lengthof(lofo1)))))
145	{setverdict(pass);}
146	else {setverdict(fail);} //^In else statement// \
147	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
148	}
149
150
151	/--- LENGTH OF CHARSTRING --------------------------------------------------/
152
153	const charstring lofc := "1110001100"
154	const charstring lofc1 := ""
155
156	const integer lofci := lengthof(lofc & lofc)
157	const integer lofci1 := lengthof(substr(lofc,0,lengthof(lofc)))
158	const integer lofci2 := lengthof(substr(lofc,0,lengthof(lofc)/2))
159	const integer lofci3 := lengthof(lofc & lofc1)
160	const integer lofci4 := lengthof(lofc1 & lofc1)
161	const integer lofci5 := lengthof(substr(lofc1,0,lengthof(lofc1)))
162
163	testcase lengthof_charstr() runs on PDTestComponent{ //In testcase definition//
164
165	if ((lofci == 2*lengthof(lofc))
166	and (lofci == lengthof(lofc & lofc)))
167	{setverdict(pass);}
168	else {setverdict(fail);} //^In else statement// \
169	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
170	if ((lofci1 == lengthof(lofc))
171	and (lofci1 == lengthof(substr(lofc,0,lengthof(lofc)))))
172	{setverdict(pass);}
173	else {setverdict(fail);} //^In else statement// \
174	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
175	if ((lofci2 == 5)
176	and (lofci2 == lengthof(substr(lofc,0,lengthof(lofc)/2))))
177	{setverdict(pass);}
178	else {setverdict(fail);} //^In else statement// \
179	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
180	if ((lofci3 == 10)
181	and (lofci3 == lengthof(lofc & lofc1)))
182	{setverdict(pass);}
183	else {setverdict(fail);} //^In else statement// \
184	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
185	if ((lofci4 == 0)
186	and (lofci4 == lengthof(lofc1 & lofc1)))
187	{setverdict(pass);}
188	else {setverdict(fail);} //^In else statement// \
189	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
190	if ((lofci5 == 0)
191	and (lofci5 == lengthof(substr(lofc1,0,lengthof(lofc1)))))
192	{setverdict(pass);}
193	else {setverdict(fail);} //^In else statement// \
194	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
195	}
196
197
198	/--- LENGTH OF UNIVERSAL CHARSTRING --------------------------------------------------/
199
200	const universal charstring lofuc := "1111" & char(0,0,0,65) & "0000" & char(0,0,0,66)
201	const universal charstring lofuc1 := ""
202
203	const integer lofuci := lengthof(lofuc & lofuc)
204	const integer lofuci1 := lengthof(substr(lofuc,0,lengthof(lofuc)))
205	const integer lofuci2 := lengthof(substr(lofuc,0,lengthof(lofuc)/2))
206	const integer lofuci3 := lengthof(lofuc & lofuc1)
207	const integer lofuci4 := lengthof(lofuc1 & lofuc1)
208	const integer lofuci5 := lengthof(substr(lofuc1,0,lengthof(lofuc1)))
209
210	testcase lengthof_ucharstr() runs on PDTestComponent{ //In testcase definition//
211
212	if ((lofuci == 2*lengthof(lofuc))
213	and (lofuci == lengthof(lofuc & lofuc)))
214	{setverdict(pass);}
215	else {setverdict(fail);} //^In else statement// \
216	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
217	if ((lofuci1 == lengthof(lofuc))
218	and (lofuci1 == lengthof(substr(lofuc,0,lengthof(lofuc)))))
219	{setverdict(pass);}
220	else {setverdict(fail);} //^In else statement// \
221	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
222	if ((lofuci2 == 5)
223	and (lofuci2 == lengthof(substr(lofuc,0,lengthof(lofuc)/2))))
224	{setverdict(pass);}
225	else {setverdict(fail);} //^In else statement// \
226	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
227	if ((lofuci3 == 10)
228	and (lofuci3 == lengthof(lofuc & lofuc1)))
229	{setverdict(pass);}
230	else {setverdict(fail);} //^In else statement// \
231	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
232	if ((lofuci4 == 0)
233	and (lofuci4 == lengthof(lofuc1 & lofuc1)))
234	{setverdict(pass);}
235	else {setverdict(fail);} //^In else statement// \
236	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
237	if ((lofuci5 == 0)
238	and (lofuci5 == lengthof(substr(lofuc1,0,lengthof(lofuc1)))))
239	{setverdict(pass);}
240	else {setverdict(fail);} //^In else statement// \
241	//^warning\: Control never reaches this code because of previous effective condition\(s\)//
242	}
243
244	control {
245	execute (lengthof_bitstr());
246	execute (lengthof_hexstr());
247	execute (lengthof_octetstr());
248	execute (lengthof_charstr());
249	execute (lengthof_ucharstr());
250	}
251
252	}