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

/******************************************************************************
 * Copyright (c) 2000-2016 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
 *
 * Contributors:
 *   Balasko, Jeno
 *   Raduly, Csaba
 *
 ******************************************************************************/
module bit_to_OK {

type component PDTestComponent {};

/*--- BIT2HEX --------------------------------------------------*/

modulepar hexstring b2hpar := bit2hex(''B)
modulepar hexstring b2hpar1 := bit2hex('000000000000'B & ''B & '111111111111'B)
modulepar hexstring b2hpar2 := bit2hex(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12))
modulepar hexstring b2hpar3 := bit2hex(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13))
modulepar hexstring b2hpar4 := bit2hex((not4b '111111111111'B) & '111111111111'B)
modulepar hexstring b2hpar5 := bit2hex('000000000000111111111111'B and4b '000000000000111111111111'B)
modulepar hexstring b2hpar6 := bit2hex('000000000000000000000000'B or4b  '000000000000111111111111'B)
modulepar hexstring b2hpar7 := bit2hex('000000000000000000000000'B xor4b '000000000000111111111111'B)
modulepar hexstring b2hpar8 := bit2hex('10011'B)
modulepar hexstring b2hpar9 := bit2hex('11'B)

modulepar hexstring b2hparh := '000FFF'H

testcase bit_to_hex() runs on PDTestComponent{

	if ((b2hpar == bit2hex(''B))
	and (b2hpar == ''H))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2hpar1 == bit2hex('000000000000'B & ''B & '111111111111'B))
	and (b2hpar1 == b2hparh))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2hpar2 == bit2hex(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12)))
	and (b2hpar2 == b2hparh))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2hpar3 == bit2hex(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13)))
	and (b2hpar3 == b2hparh))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2hpar4 == bit2hex((not4b '111111111111'B) & '111111111111'B))
	and (b2hpar4 == b2hparh))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2hpar5 == bit2hex('000000000000111111111111'B and4b '000000000000111111111111'B))
	and (b2hpar5 == b2hparh))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2hpar6 == bit2hex('000000000000000000000000'B or4b  '000000000000111111111111'B))
	and (b2hpar6 == b2hparh))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2hpar7 == bit2hex('000000000000000000000000'B xor4b '000000000000111111111111'B))
	and (b2hpar7 == b2hparh))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2hpar8 == bit2hex('10011'B))
	and (b2hpar8 == '13'H))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2hpar9 == bit2hex('11'B))
	and (b2hpar9 == '3'H))
	     {setverdict(pass);}
	else {setverdict(fail);}


}

/*--- BIT2INT --------------------------------------------------*/

modulepar integer b2ipar := bit2int(''B)
modulepar integer b2ipar1 := bit2int('111111'B & '111111'B)
modulepar integer b2ipar2 := bit2int((not4b '111111'B) & '111111'B)
modulepar integer b2ipar3 := bit2int(('111111'B and4b '000000'B) & '111111'B)
modulepar integer b2ipar4 := bit2int(('000000'B or4b '000000'B) & '111111'B)
modulepar integer b2ipar5 := bit2int(('000011'B xor4b '000011'B) & '111111'B)
modulepar integer b2i1_16 := 12345678910111213141516;

testcase bit_to_int() runs on PDTestComponent{
	var integer i1 := 12345678910111213141516;
	var bitstring bs1 := '00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B;
	var integer b;

	if ((b2ipar == bit2int(''B))
	and (b2ipar == 0))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2ipar1 == bit2int('111111'B & '111111'B))
	and (b2ipar1 == 4095))
	     {setverdict(pass);}
	else {setverdict(fail);}

	b := bit2int((not4b '111111'B) & '111111'B)
	if ((b2ipar2 == b)
	and (b2ipar2 == 63))
	     {setverdict(pass);}
	else {setverdict(fail);}

	b := bit2int(('111111'B and4b '000000'B) & '111111'B)
	if ((b2ipar3 == b)
	and (b2ipar3 == 63))
	     {setverdict(pass);}
	else {setverdict(fail);}

	b := bit2int(('000000'B or4b '000000'B) & '111111'B)
	if ((b2ipar4 == b)
	and (b2ipar4 == 63))
	     {setverdict(pass);}
	else {setverdict(fail);}

	b := bit2int(('000011'B xor4b '000011'B) & '111111'B)
	if ((b2ipar5 == b)
	and (b2ipar5 == 63))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if (bit2int(bs1) == 12345678910111213141516)
	     {setverdict(pass);}
	else {setverdict(fail);}
	if (bit2int('00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B) == b2i1_16)
	     {setverdict(pass);}
	else {setverdict(fail);}
	if (bit2int(bs1) == 12345678910111213141516)
	     {setverdict(pass);}
	else {setverdict(fail);}
	if (bit2int(int2bit(bit2int('010100111010100001010110110010101101000100100110010100010111011111000001100'B), 75)) == b2i1_16)
	     {setverdict(pass);}
	else {setverdict(fail);}

	var integer j
	for (j:=0; j<1024; j:=j+1) {
	if (bit2int(int2bit(j,10)) == j)
	     {setverdict(pass);}
	else {setverdict(fail);}
	}

}

/*--- BIT2OCT --------------------------------------------------*/

modulepar octetstring b2opar := bit2oct(''B)
modulepar octetstring b2opar1 := bit2oct('000000000000'B & ''B & '111111111111'B)
modulepar octetstring b2opar2 := bit2oct(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12))
modulepar octetstring b2opar3 := bit2oct(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13))
modulepar octetstring b2opar4 := bit2oct((not4b '111111111111'B) & '111111111111'B)
modulepar octetstring b2opar5 := bit2oct('000000000000111111111111'B and4b '000000000000111111111111'B)
modulepar octetstring b2opar6 := bit2oct('000000000000000000000000'B or4b  '000000000000111111111111'B)
modulepar octetstring b2opar7 := bit2oct('000000000000000000000000'B xor4b '000000000000111111111111'B)
modulepar octetstring b2opar8 := bit2oct('10011'B)
modulepar octetstring b2opar9 := bit2oct('11'B)

modulepar octetstring b2oparo := '000FFF'O

testcase bit_to_oct() runs on PDTestComponent{

	if ((b2opar == bit2oct(''B))
	and (b2opar == ''O))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2opar1 == bit2oct('000000000000'B & ''B & '111111111111'B))
	and (b2opar1 == b2oparo))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2opar2 == bit2oct(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12)))
	and (b2opar2 == b2oparo))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2opar3 == bit2oct(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13)))
	and (b2opar3 == b2oparo))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2opar4 == bit2oct((not4b '111111111111'B) & '111111111111'B))
	and (b2opar4 == b2oparo))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2opar5 == bit2oct('000000000000111111111111'B and4b '000000000000111111111111'B))
	and (b2opar5 == b2oparo))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2opar6 == bit2oct('000000000000000000000000'B or4b  '000000000000111111111111'B))
	and (b2opar6 == b2oparo))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2opar7 == bit2oct('000000000000000000000000'B xor4b '000000000000111111111111'B))
	and (b2opar7 == b2oparo))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2opar8 == bit2oct('10011'B))
	and (b2opar8 == '13'O))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2opar9 == bit2oct('11'B))
	and (b2opar9 == '03'O))
	     {setverdict(pass);}
	else {setverdict(fail);}
}

/*--- BIT2STR --------------------------------------------------*/

modulepar charstring b2spar := bit2str(''B)
modulepar charstring b2spar1 := bit2str('000000'B & ''B & '111111'B)
modulepar charstring b2spar2 := bit2str(substr('000000111111'B,0,6) & ''B & substr('000000111111'B,6,6))
modulepar charstring b2spar3 := bit2str(('000000'B <@ 3) & ''B & ('111111'B @> 3))
modulepar charstring b2spar4 := bit2str((not4b '111111'B) & '111111'B)
modulepar charstring b2spar5 := bit2str('000000111111'B and4b '000000111111'B)
modulepar charstring b2spar6 := bit2str('000000000000'B or4b  '000000111111'B)
modulepar charstring b2spar7 := bit2str('000000000000'B xor4b '000000111111'B)

modulepar charstring b2spars := "000000111111"

testcase bit_to_str() runs on PDTestComponent{

	if ((b2spar == bit2str(''B))
	and (b2spar == ""))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2spar1 == bit2str('000000'B & ''B & '111111'B))
	and (b2spar1 == b2spars))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2spar2 == bit2str(substr('000000111111'B,0,6) & ''B & substr('000000111111'B,6,6)))
	and (b2spar2 == b2spars))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2spar3 == bit2str(('000000'B <@ 3) & ''B & ('111111'B @> 3)))
	and (b2spar3 == b2spars))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2spar4 == bit2str((not4b '111111'B) & '111111'B))
	and (b2spar4 == b2spars))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2spar5 == bit2str('000000111111'B and4b '000000111111'B))
	and (b2spar5 == b2spars))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2spar6 == bit2str('000000000000'B or4b  '000000111111'B))
	and (b2spar6 == b2spars))
	     {setverdict(pass);}
	else {setverdict(fail);}

	if ((b2spar7 == bit2str('000000000000'B xor4b '000000111111'B))
	and (b2spar7 == b2spars))
	     {setverdict(pass);}
	else {setverdict(fail);}
}

control {
	execute (bit_to_hex());
	execute (bit_to_int());
	execute (bit_to_oct());
	execute (bit_to_str());
}

}
Commit	Line	Data
970ed795	1	/******************************************************************************
d44e3c4f	2	* Copyright (c) 2000-2016 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
d44e3c4f	7	*
	8	* Contributors:
	9	* Balasko, Jeno
	10	* Raduly, Csaba
	11	*
970ed795 EL	12	******************************************************************************/
	13	module bit_to_OK {
	14
	15	type component PDTestComponent {};
	16
	17	/--- BIT2HEX --------------------------------------------------/
	18
	19	modulepar hexstring b2hpar := bit2hex(''B)
	20	modulepar hexstring b2hpar1 := bit2hex('000000000000'B & ''B & '111111111111'B)
	21	modulepar hexstring b2hpar2 := bit2hex(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12))
	22	modulepar hexstring b2hpar3 := bit2hex(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13))
	23	modulepar hexstring b2hpar4 := bit2hex((not4b '111111111111'B) & '111111111111'B)
	24	modulepar hexstring b2hpar5 := bit2hex('000000000000111111111111'B and4b '000000000000111111111111'B)
	25	modulepar hexstring b2hpar6 := bit2hex('000000000000000000000000'B or4b '000000000000111111111111'B)
	26	modulepar hexstring b2hpar7 := bit2hex('000000000000000000000000'B xor4b '000000000000111111111111'B)
	27	modulepar hexstring b2hpar8 := bit2hex('10011'B)
	28	modulepar hexstring b2hpar9 := bit2hex('11'B)
	29
	30	modulepar hexstring b2hparh := '000FFF'H
	31
	32	testcase bit_to_hex() runs on PDTestComponent{
	33
	34	if ((b2hpar == bit2hex(''B))
	35	and (b2hpar == ''H))
	36	{setverdict(pass);}
	37	else {setverdict(fail);}
	38
	39	if ((b2hpar1 == bit2hex('000000000000'B & ''B & '111111111111'B))
	40	and (b2hpar1 == b2hparh))
	41	{setverdict(pass);}
	42	else {setverdict(fail);}
	43
	44	if ((b2hpar2 == bit2hex(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12)))
	45	and (b2hpar2 == b2hparh))
	46	{setverdict(pass);}
	47	else {setverdict(fail);}
	48
	49	if ((b2hpar3 == bit2hex(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13)))
	50	and (b2hpar3 == b2hparh))
	51	{setverdict(pass);}
	52	else {setverdict(fail);}
	53
	54	if ((b2hpar4 == bit2hex((not4b '111111111111'B) & '111111111111'B))
	55	and (b2hpar4 == b2hparh))
	56	{setverdict(pass);}
	57	else {setverdict(fail);}
	58
	59	if ((b2hpar5 == bit2hex('000000000000111111111111'B and4b '000000000000111111111111'B))
	60	and (b2hpar5 == b2hparh))
	61	{setverdict(pass);}
	62	else {setverdict(fail);}
	63
	64	if ((b2hpar6 == bit2hex('000000000000000000000000'B or4b '000000000000111111111111'B))
	65	and (b2hpar6 == b2hparh))
	66	{setverdict(pass);}
	67	else {setverdict(fail);}
	68
	69	if ((b2hpar7 == bit2hex('000000000000000000000000'B xor4b '000000000000111111111111'B))
	70	and (b2hpar7 == b2hparh))
	71	{setverdict(pass);}
	72	else {setverdict(fail);}
	73
	74	if ((b2hpar8 == bit2hex('10011'B))
	75	and (b2hpar8 == '13'H))
76	{setverdict(pass);}
77	else {setverdict(fail);}
78
79	if ((b2hpar9 == bit2hex('11'B))
80	and (b2hpar9 == '3'H))
81	{setverdict(pass);}
82	else {setverdict(fail);}
83
84
85	}
86
87	/--- BIT2INT --------------------------------------------------/
88
89	modulepar integer b2ipar := bit2int(''B)
90	modulepar integer b2ipar1 := bit2int('111111'B & '111111'B)
91	modulepar integer b2ipar2 := bit2int((not4b '111111'B) & '111111'B)
92	modulepar integer b2ipar3 := bit2int(('111111'B and4b '000000'B) & '111111'B)
93	modulepar integer b2ipar4 := bit2int(('000000'B or4b '000000'B) & '111111'B)
94	modulepar integer b2ipar5 := bit2int(('000011'B xor4b '000011'B) & '111111'B)
95	modulepar integer b2i1_16 := 12345678910111213141516;
96
97	testcase bit_to_int() runs on PDTestComponent{
98	var integer i1 := 12345678910111213141516;
99	var bitstring bs1 := '00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B;
100	var integer b;
101
102	if ((b2ipar == bit2int(''B))
103	and (b2ipar == 0))
104	{setverdict(pass);}
105	else {setverdict(fail);}
106
107	if ((b2ipar1 == bit2int('111111'B & '111111'B))
108	and (b2ipar1 == 4095))
109	{setverdict(pass);}
110	else {setverdict(fail);}
111
112	b := bit2int((not4b '111111'B) & '111111'B)
113	if ((b2ipar2 == b)
114	and (b2ipar2 == 63))
115	{setverdict(pass);}
116	else {setverdict(fail);}
117
118	b := bit2int(('111111'B and4b '000000'B) & '111111'B)
119	if ((b2ipar3 == b)
120	and (b2ipar3 == 63))
121	{setverdict(pass);}
122	else {setverdict(fail);}
123
124	b := bit2int(('000000'B or4b '000000'B) & '111111'B)
125	if ((b2ipar4 == b)
126	and (b2ipar4 == 63))
127	{setverdict(pass);}
128	else {setverdict(fail);}
129
130	b := bit2int(('000011'B xor4b '000011'B) & '111111'B)
131	if ((b2ipar5 == b)
132	and (b2ipar5 == 63))
133	{setverdict(pass);}
134	else {setverdict(fail);}
135
136	if (bit2int(bs1) == 12345678910111213141516)
137	{setverdict(pass);}
138	else {setverdict(fail);}
139	if (bit2int('00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B) == b2i1_16)
140	{setverdict(pass);}
141	else {setverdict(fail);}
142	if (bit2int(bs1) == 12345678910111213141516)
143	{setverdict(pass);}
144	else {setverdict(fail);}
145	if (bit2int(int2bit(bit2int('010100111010100001010110110010101101000100100110010100010111011111000001100'B), 75)) == b2i1_16)
146	{setverdict(pass);}
147	else {setverdict(fail);}
148
149	var integer j
150	for (j:=0; j<1024; j:=j+1) {
151	if (bit2int(int2bit(j,10)) == j)
152	{setverdict(pass);}
153	else {setverdict(fail);}
154	}
155
156	}
157
158	/--- BIT2OCT --------------------------------------------------/
159
160	modulepar octetstring b2opar := bit2oct(''B)
161	modulepar octetstring b2opar1 := bit2oct('000000000000'B & ''B & '111111111111'B)
162	modulepar octetstring b2opar2 := bit2oct(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12))
163	modulepar octetstring b2opar3 := bit2oct(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13))
164	modulepar octetstring b2opar4 := bit2oct((not4b '111111111111'B) & '111111111111'B)
165	modulepar octetstring b2opar5 := bit2oct('000000000000111111111111'B and4b '000000000000111111111111'B)
166	modulepar octetstring b2opar6 := bit2oct('000000000000000000000000'B or4b '000000000000111111111111'B)
167	modulepar octetstring b2opar7 := bit2oct('000000000000000000000000'B xor4b '000000000000111111111111'B)
168	modulepar octetstring b2opar8 := bit2oct('10011'B)
169	modulepar octetstring b2opar9 := bit2oct('11'B)
170
171	modulepar octetstring b2oparo := '000FFF'O
172
173	testcase bit_to_oct() runs on PDTestComponent{
174
175	if ((b2opar == bit2oct(''B))
176	and (b2opar == ''O))
177	{setverdict(pass);}
178	else {setverdict(fail);}
179
180	if ((b2opar1 == bit2oct('000000000000'B & ''B & '111111111111'B))
181	and (b2opar1 == b2oparo))
182	{setverdict(pass);}
183	else {setverdict(fail);}
184
185	if ((b2opar2 == bit2oct(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12)))
186	and (b2opar2 == b2oparo))
187	{setverdict(pass);}
188	else {setverdict(fail);}
189
190	if ((b2opar3 == bit2oct(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13)))
191	and (b2opar3 == b2oparo))
192	{setverdict(pass);}
193	else {setverdict(fail);}
194
195	if ((b2opar4 == bit2oct((not4b '111111111111'B) & '111111111111'B))
196	and (b2opar4 == b2oparo))
197	{setverdict(pass);}
198	else {setverdict(fail);}
199
200	if ((b2opar5 == bit2oct('000000000000111111111111'B and4b '000000000000111111111111'B))
201	and (b2opar5 == b2oparo))
202	{setverdict(pass);}
203	else {setverdict(fail);}
204
205	if ((b2opar6 == bit2oct('000000000000000000000000'B or4b '000000000000111111111111'B))
206	and (b2opar6 == b2oparo))
207	{setverdict(pass);}
208	else {setverdict(fail);}
209
210	if ((b2opar7 == bit2oct('000000000000000000000000'B xor4b '000000000000111111111111'B))
211	and (b2opar7 == b2oparo))
212	{setverdict(pass);}
213	else {setverdict(fail);}
214
215	if ((b2opar8 == bit2oct('10011'B))
216	and (b2opar8 == '13'O))
217	{setverdict(pass);}
218	else {setverdict(fail);}
219
220	if ((b2opar9 == bit2oct('11'B))
221	and (b2opar9 == '03'O))
222	{setverdict(pass);}
223	else {setverdict(fail);}
224	}
225
226	/--- BIT2STR --------------------------------------------------/
227
228	modulepar charstring b2spar := bit2str(''B)
229	modulepar charstring b2spar1 := bit2str('000000'B & ''B & '111111'B)
230	modulepar charstring b2spar2 := bit2str(substr('000000111111'B,0,6) & ''B & substr('000000111111'B,6,6))
231	modulepar charstring b2spar3 := bit2str(('000000'B <@ 3) & ''B & ('111111'B @> 3))
232	modulepar charstring b2spar4 := bit2str((not4b '111111'B) & '111111'B)
233	modulepar charstring b2spar5 := bit2str('000000111111'B and4b '000000111111'B)
234	modulepar charstring b2spar6 := bit2str('000000000000'B or4b '000000111111'B)
235	modulepar charstring b2spar7 := bit2str('000000000000'B xor4b '000000111111'B)
236
237	modulepar charstring b2spars := "000000111111"
238
239	testcase bit_to_str() runs on PDTestComponent{
240
241	if ((b2spar == bit2str(''B))
242	and (b2spar == ""))
243	{setverdict(pass);}
244	else {setverdict(fail);}
245
246	if ((b2spar1 == bit2str('000000'B & ''B & '111111'B))
247	and (b2spar1 == b2spars))
248	{setverdict(pass);}
249	else {setverdict(fail);}
250
251	if ((b2spar2 == bit2str(substr('000000111111'B,0,6) & ''B & substr('000000111111'B,6,6)))
252	and (b2spar2 == b2spars))
253	{setverdict(pass);}
254	else {setverdict(fail);}
255
256	if ((b2spar3 == bit2str(('000000'B <@ 3) & ''B & ('111111'B @> 3)))
257	and (b2spar3 == b2spars))
258	{setverdict(pass);}
259	else {setverdict(fail);}
260
261	if ((b2spar4 == bit2str((not4b '111111'B) & '111111'B))
262	and (b2spar4 == b2spars))
263	{setverdict(pass);}
264	else {setverdict(fail);}
265
266	if ((b2spar5 == bit2str('000000111111'B and4b '000000111111'B))
267	and (b2spar5 == b2spars))
268	{setverdict(pass);}
269	else {setverdict(fail);}
270
271	if ((b2spar6 == bit2str('000000000000'B or4b '000000111111'B))
272	and (b2spar6 == b2spars))
273	{setverdict(pass);}
274	else {setverdict(fail);}
275
276	if ((b2spar7 == bit2str('000000000000'B xor4b '000000111111'B))
277	and (b2spar7 == b2spars))
278	{setverdict(pass);}
279	else {setverdict(fail);}
280	}
281
282	control {
283	execute (bit_to_hex());
284	execute (bit_to_int());
285	execute (bit_to_oct());
286	execute (bit_to_str());
287	}
288
289	}