4 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
5 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
6 // Stefan Bund <stefan.bund@fokus.fraunhofer.de>
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 2 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the
20 // Free Software Foundation, Inc.,
21 // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 //#include "ParseInt.test.hh"
26 //#include "ParseInt.test.ih"
29 #include "ParseInt.hh"
32 #include <boost/test/auto_unit_test.hpp>
33 #include <boost/test/test_tools.hpp>
36 ///////////////////////////////cc.p////////////////////////////////////////
40 BOOST_AUTO_UNIT_TEST(parseInt_fixedSizes)
42 unsigned char data[] = { 0x8e, 0x2f, 0x57, 0x12, 0xd1 };
43 typedef unsigned char * iterator;
45 BOOST_CHECK_EQUAL(Parse_Int8<iterator>(data).value(), -114);
46 BOOST_CHECK_EQUAL(Parse_Int8<iterator>(data+1).value(), 47);
47 BOOST_CHECK_EQUAL(Parse_UInt8<iterator>(data).value(), 142u);
49 BOOST_CHECK_EQUAL(Parse_Int16<iterator>(data).value(), -29137);
50 BOOST_CHECK_EQUAL(Parse_Int16<iterator>(data+1).value(), 12119);
51 BOOST_CHECK_EQUAL(Parse_UInt16<iterator>(data).value(), 36399u);
53 BOOST_CHECK_EQUAL(Parse_Int24<iterator>(data).value(), -7458985);
54 BOOST_CHECK_EQUAL(Parse_Int24<iterator>(data+1).value(), 3102482);
55 BOOST_CHECK_EQUAL(Parse_UInt24<iterator>(data).value(), 9318231u);
57 BOOST_CHECK_EQUAL(Parse_Int32<iterator>(data).value(), -1909500142);
58 BOOST_CHECK_EQUAL(Parse_Int32<iterator>(data+1).value(), 794235601);
59 BOOST_CHECK_EQUAL(Parse_UInt32<iterator>(data).value(), 2385467154u);
62 BOOST_AUTO_UNIT_TEST(parseInt_bits)
65 // 012345678901234567890123456789012345678901234567
66 // -------- -------- --------
67 // 011000111101011101011010001100011010010001000110
68 unsigned char data[] = { 0x63, 0xd7, 0x5a, 0x31, 0xa4, 0x46 };
69 typedef unsigned char * iterator;
72 BOOST_CHECK_EQUAL((Parse_UIntField<2,7,iterator>(data).value()), 17u);
73 BOOST_CHECK_EQUAL((Parse_IntField<2,7,iterator>(data).value()), -15);
74 BOOST_CHECK_EQUAL((Parse_UIntField<3,7,iterator>(data).value()), 1u);
75 BOOST_CHECK_EQUAL((Parse_IntField<3,7,iterator>(data).value()), 1);
76 BOOST_CHECK_EQUAL((Parse_UIntField<0,8,iterator>(data).value()), 99u);
79 BOOST_CHECK_EQUAL((Parse_UIntField<5,12,iterator>(data).value()), 61u);
80 BOOST_CHECK_EQUAL((Parse_UIntField<0,12,iterator>(data).value()), 1597u);
81 BOOST_CHECK_EQUAL((Parse_UIntField<8,13,iterator>(data).value()), 26u);
82 BOOST_CHECK_EQUAL((Parse_UIntField<8,16,iterator>(data).value()), 215u);
83 BOOST_CHECK_EQUAL((Parse_UIntField<0,16,iterator>(data).value()), 25559u);
86 BOOST_CHECK_EQUAL((Parse_UIntField<6,20,iterator>(data).value()), 15733u);
87 BOOST_CHECK_EQUAL((Parse_IntField<6,20,iterator>(data).value()), -651);
88 BOOST_CHECK_EQUAL((Parse_UIntField<13,22,iterator>(data).value()), 470u);
91 BOOST_CHECK_EQUAL((Parse_UIntField<3,28,iterator>(data).value()), 4027811u);
92 BOOST_CHECK_EQUAL((Parse_UIntField<13,38,iterator>(data).value()), 30837865u);
93 BOOST_CHECK_EQUAL((Parse_UIntField<8,40,iterator>(data).value()), 3613012388u);
94 BOOST_CHECK_EQUAL((Parse_IntField<8,40,iterator>(data).value()), -681954908);
97 BOOST_CHECK_EQUAL((Parse_UIntField<3,34,iterator>(data).value()), 257779910u);
98 BOOST_CHECK_EQUAL((Parse_IntField<13,41,iterator>(data).value()), -21732536);
101 BOOST_CHECK_EQUAL((Parse_Flag<32,iterator>(data).value()), true);
102 BOOST_CHECK_EQUAL((Parse_Flag<12,iterator>(data).value()), false);
105 BOOST_AUTO_UNIT_TEST(parseInt_assign)
107 unsigned char data[] = { 0x00, 0x00, 0x00, 0x00, 0x00 };
108 typedef unsigned char * iterator;
110 Parse_Int8<iterator>(data).value(0x2f);
111 BOOST_CHECK_EQUAL( data[0], 0x2f );
113 Parse_Int16<iterator>(data).value(0xa341);
114 BOOST_CHECK_EQUAL( data[0], 0xa3 );
115 BOOST_CHECK_EQUAL( data[1], 0x41 );
117 Parse_Int24<iterator>(data).value(0x234567);
118 BOOST_CHECK_EQUAL( data[0], 0x23 );
119 BOOST_CHECK_EQUAL( data[1], 0x45 );
120 BOOST_CHECK_EQUAL( data[2], 0x67 );
122 Parse_Int32<iterator>(data).value(0xfedcba98);
123 BOOST_CHECK_EQUAL( data[0], 0xfe );
124 BOOST_CHECK_EQUAL( data[1], 0xdc );
125 BOOST_CHECK_EQUAL( data[2], 0xba );
126 BOOST_CHECK_EQUAL( data[3], 0x98 );
128 Parse_IntField<2,6,iterator>(data).value(0x3);
129 BOOST_CHECK_EQUAL( data[0], 0xce );
130 BOOST_CHECK_EQUAL( data[1], 0xdc );
132 Parse_IntField<6,9,iterator>(data).value(0x2);
133 BOOST_CHECK_EQUAL( data[0], 0xcd );
134 BOOST_CHECK_EQUAL( data[1], 0x5c );
135 BOOST_CHECK_EQUAL( data[2], 0xba );
137 Parse_IntField<2,21,iterator>(data).value(0x13d75);
138 BOOST_CHECK_EQUAL( data[0], 0xc9 );
139 BOOST_CHECK_EQUAL( data[1], 0xeb );
140 BOOST_CHECK_EQUAL( data[2], 0xaa );
141 BOOST_CHECK_EQUAL( data[3], 0x98 );
143 Parse_UIntField<4,34,iterator>(data).value(0x268ad497u);
144 BOOST_CHECK_EQUAL( (Parse_UIntField<4,34,iterator>(data).value()), 0x268ad497u );
147 BOOST_AUTO_UNIT_TEST(parseInt_operators)
149 unsigned char data[] = { 0x63, 0xd7, 0x5a, 0x31, 0xa4, 0x46 };
151 Parse_UInt24<unsigned char *> p1(data);
152 Parse_UInt16<unsigned char *> p2(data+3);
154 BOOST_CHECK_EQUAL( ~p1, 4288424101u );
155 BOOST_CHECK ( !!p1 );
156 BOOST_CHECK_EQUAL( -p1, -6543194u );
159 BOOST_CHECK_EQUAL( p1, 6543210u );
161 BOOST_CHECK_EQUAL( p1, 6543194u );
164 BOOST_CHECK_EQUAL( p1, 6555902u );
166 // Here some idiotic automatic promotion from unsigned short ->
167 // int happens in the second macro parameter ... hrmpf ...
168 BOOST_CHECK_EQUAL( p2, 15010 );
171 BOOST_CHECK_EQUAL( data[0], 0x12 );
172 BOOST_CHECK_EQUAL( data[1], 0x34 );
173 BOOST_CHECK_EQUAL( data[2], 0x56 );
174 BOOST_CHECK_EQUAL( data[3], 0x3a );
176 // I stop here ... this is absolutely identical for all other
177 // operators and all other integer types. If really some error pops
178 // up, I'll add a check here ...
185 : public Packet, public P::template rebind< Packet::iterator,TestPacket<P> >::parser
188 typedef typename P::template rebind<Packet::iterator,TestPacket>::parser parser;
189 typedef typename ptr_t<TestPacket>::ptr ptr;
191 static bool check(iterator b, iterator e) { return true; }
195 TestPacket(Arg const & arg)
198 virtual void v_nextInterpreter() const {}
199 virtual void v_finalize() {}
200 virtual void v_dump(std::ostream &) const {}
206 typename P::value_type packetCheck()
208 unsigned char data[] = { 0x8e, 0x2f, 0x57, 0x12, 0xd1 };
209 typename TestPacket<P>::ptr p (Packet::create< TestPacket<P> >(data, data+sizeof(data)));
215 BOOST_AUTO_UNIT_TEST(parseInt_inherited)
217 BOOST_CHECK_EQUAL(packetCheck< Parse_Int8<> >(), -114);
218 BOOST_CHECK_EQUAL(packetCheck< Parse_UInt8<> >(), 142u);
220 BOOST_CHECK_EQUAL(packetCheck< Parse_Int16<> >(), -29137);
221 BOOST_CHECK_EQUAL(packetCheck< Parse_UInt16<> >(), 36399u);
223 BOOST_CHECK_EQUAL(packetCheck< Parse_Int24<> >(), -7458985);
224 BOOST_CHECK_EQUAL(packetCheck< Parse_UInt24<> >(), 9318231u);
226 BOOST_CHECK_EQUAL(packetCheck< Parse_Int32<> >(), -1909500142);
227 BOOST_CHECK_EQUAL(packetCheck< Parse_UInt32<> >(), 2385467154u);
229 BOOST_CHECK_EQUAL((packetCheck< Parse_IntField<3,28> >()), 14873969);
230 BOOST_CHECK_EQUAL((packetCheck< Parse_UIntField<3,28> >()), 14873969u);
231 BOOST_CHECK_EQUAL((packetCheck< Parse_Flag<11> >()), false);
234 ///////////////////////////////cc.e////////////////////////////////////////
241 // c-file-style: "senf"
242 // indent-tabs-mode: nil
243 // ispell-local-dictionary: "american"