Packets/80211Bundle/WLANPacket.test.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2008
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Christian Niephaus <cni@berlios.de>
   7 //
   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.
  12 //
  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.
  17 //
  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.
  22
  23 /** \file
  24     \brief WLANPacket unit tests */
  25
  26 // Custom includes
  27 #include "WLANPacket.hh"
  28 #include "../../Packets/Packets.hh"
  29
  30 #include "../../Utils/auto_unit_test.hh"
  31 #include <boost/test/test_tools.hpp>
  32
  33 ///////////////////////////////cc.p////////////////////////////////////////
  34 /* test parser with a data frame */
  35 BOOST_AUTO_UNIT_TEST(WLANPacket_dataFrame_packet)
  36 {
  37     unsigned char data[] = {
  38             0x88, 0x01, 0x00, 0x00, 0x00, 0x1a,             //header
  39             0x4d, 0x3e, 0xc7, 0x5c, 0x00, 0x0b, 0x6b, 0x57,
  40             0x06, 0xb0, 0x00, 0x18, 0x4d, 0x6e, 0x78, 0x48,
  41             0x30, 0x00, 0x01, 0x00,
  42             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //dummy data
  43             0x38, 0x39, 0x30, 0x31                          //trailer
  44     };
  45
  46     senf::WLANPacket p (senf::WLANPacket::create(data));
  47
  48     BOOST_CHECK_EQUAL( p->version(),        0u    );
  49     BOOST_CHECK_EQUAL( p->type(),           2u    );
  50     BOOST_CHECK_EQUAL( p->subtype(),        8u    );
  51     BOOST_CHECK_EQUAL( p->toDS(),           true  );
  52     BOOST_CHECK_EQUAL( p->fromDS(),         false );
  53     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
  54     BOOST_CHECK_EQUAL( p->retry(),          false );
  55     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
  56     BOOST_CHECK_EQUAL( p->moreData(),       false );
  57     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
  58     BOOST_CHECK_EQUAL( p->order(),          false );
  59
  60     BOOST_CHECK_EQUAL( p->duration(),       0u    );
  61
  62     BOOST_CHECK_EQUAL(
  63             p->dataFrame().destinationAddress().value(),
  64             senf::MACAddress::from_string("00:18:4d:6e:78:48") );
  65     BOOST_CHECK_EQUAL(
  66             p->dataFrame().sourceAddress().value(),
  67             senf::MACAddress::from_string("00:0b:6b:57:06:b0") );
  68     BOOST_CHECK_EQUAL(
  69             p->dataFrame().bssid().value(),
  70             senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
  71
  72     BOOST_CHECK_EQUAL(
  73             p->dataFrame().bssid().value(),
  74             p->dataFrame().receiverAddress().value() );
  75     BOOST_CHECK_EQUAL(
  76             p->dataFrame().transmitterAddress().value(),
  77             p->dataFrame().sourceAddress().value() );
  78
  79     BOOST_CHECK_EQUAL( p->dataFrame().sequenceNumber(), 3u );
  80     BOOST_CHECK_EQUAL( p->dataFrame().fragmentNumber(), 0u );
  81
  82     std::ostringstream oss (std::ostringstream::out);
  83     SENF_CHECK_NO_THROW( p.dump( oss));
  84 }
  85
  86
  87 /* test parser with creating a data frame*/
  88 BOOST_AUTO_UNIT_TEST(WLANPacket_dataFrame_create)
  89 {
  90     senf::WLANPacket p (senf::WLANPacket::create());
  91
  92     SENF_CHECK_NO_THROW( p->init_dataFrame() );
  93     SENF_CHECK_NO_THROW( p->dataFrame().bssid() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
  94     BOOST_CHECK_EQUAL( p->type(), 2u );
  95 }
  96
  97
  98 /* test parser with a beacon frame */
  99 BOOST_AUTO_UNIT_TEST(WLANPacket_beaconFrame_packet)
 100 {
 101     unsigned char data[] = {
 102             0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 103             0xff, 0xff, 0x00, 0x1a, 0x4d, 0x3e, 0xc7, 0x5c,
 104             0x00, 0x1a, 0x4d, 0x3e, 0xc7, 0x5c, 0xe0, 0x12,
 105             0x38, 0xa0, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00,
 106             0x64, 0x00, 0x01, 0x05, 0x00, 0x05, 0x62, 0x6f,
 107             0x78, 0x43, 0x31, 0x01, 0x08, 0x8c, 0x12, 0x98,
 108             0x24, 0xb0, 0x48, 0x60, 0x6c, 0x03, 0x01, 0x40,
 109             0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x07, 0x2a,
 110             0x4e, 0x41, 0x49, 0x24, 0x01, 0x11, 0x28, 0x01,
 111             0x11, 0x2c, 0x01, 0x11, 0x30, 0x01, 0x11, 0x34,
 112             0x01, 0x17, 0x38, 0x01, 0x17, 0x3c, 0x01, 0x17,
 113             0x40, 0x01, 0x17, 0x95, 0x01, 0x1e, 0x99, 0x01,
 114             0x1e, 0x9d, 0x01, 0x1e, 0xa1, 0x01, 0x1e, 0xa5,
 115             0x01, 0x1e, 0x20, 0x01, 0x00, 0xdd, 0x18, 0x00,
 116             0x50, 0xf2, 0x02, 0x01, 0x01, 0x81, 0x00, 0x02,
 117             0xa3, 0x40, 0x00, 0x27, 0xa4, 0x00, 0x00, 0x42,
 118             0x43, 0x5e, 0x00, 0x62, 0x32, 0x2f, 0x00, 0xa0,
 119             0x00, 0xdd, 0x09, 0x00, 0x03, 0x7f, 0x01, 0x01,
 120             0x00, 0x24, 0xff, 0x7f, 0x87, 0x07, 0x1f, 0xf5,
 121     };
 122
 123     senf::WLANPacket p (senf::WLANPacket::create(data));
 124
 125     BOOST_CHECK_EQUAL( p->version(),        0u    );
 126     BOOST_CHECK_EQUAL( p->type(),           0u    );
 127     BOOST_CHECK_EQUAL( p->subtype(),        8u    );
 128     BOOST_CHECK_EQUAL( p->toDS(),           false );
 129     BOOST_CHECK_EQUAL( p->fromDS(),         false );
 130     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
 131     BOOST_CHECK_EQUAL( p->retry(),          false );
 132     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
 133     BOOST_CHECK_EQUAL( p->moreData(),       false );
 134     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
 135     BOOST_CHECK_EQUAL( p->order(),          false );
 136     BOOST_CHECK_EQUAL( p->duration(),       0u    );
 137
 138     BOOST_CHECK_EQUAL( p->is_mgtFrame(),    true  );
 139
 140     BOOST_CHECK_EQUAL(
 141             p->mgtFrame().destinationAddress().value(),
 142             senf::MACAddress::from_string("ff:ff:ff:ff:ff:ff") );
 143     BOOST_CHECK_EQUAL(
 144             p->mgtFrame().sourceAddress().value(),
 145             senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
 146     BOOST_CHECK_EQUAL(
 147             p->mgtFrame().bssid().value(),
 148             senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
 149
 150     BOOST_CHECK_EQUAL( p->mgtFrame().sequenceNumber(), 302u );
 151     BOOST_CHECK_EQUAL( p->mgtFrame().fragmentNumber(), 0u   );
 152
 153     BOOST_CHECK_EQUAL( p->fcs(), 0x87071ff5 );
 154 }
 155
 156
 157 /* test parser with creating a beacon frame*/
 158 BOOST_AUTO_UNIT_TEST(WLANPacket_mgtFrame_create)
 159 {
 160     senf::WLANPacket p (senf::WLANPacket::create());
 161
 162     SENF_CHECK_NO_THROW( p->init_mgtFrame() );
 163     SENF_CHECK_NO_THROW(
 164             p->mgtFrame().destinationAddress() = senf::MACAddress::from_string("ff:ff:ff:ff:ff:ff")
 165     );
 166     SENF_CHECK_NO_THROW(
 167             p->mgtFrame().sourceAddress() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c")
 168     );
 169     SENF_CHECK_NO_THROW(
 170             p->mgtFrame().bssid() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c")
 171     );
 172
 173     BOOST_CHECK_EQUAL( p->type(), 0u );
 174 }
 175
 176
 177 /* test parser with an ACK frame*/
 178 BOOST_AUTO_UNIT_TEST(WLANPacket_ctrlFrame_packet)
 179 {
 180     unsigned char data[] = {
 181             0xd4, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x6b, 0x57,
 182             0x06, 0xb0, 0x4f, 0xda
 183     };
 184
 185     senf::WLANPacket p (senf::WLANPacket::create(data));
 186
 187     BOOST_CHECK_EQUAL( p->version(),        0u    );
 188     BOOST_CHECK_EQUAL( p->type(),           1u    );
 189     BOOST_CHECK_EQUAL( p->subtype(),        13u   );
 190     BOOST_CHECK_EQUAL( p->toDS(),           false );
 191     BOOST_CHECK_EQUAL( p->fromDS(),         false );
 192     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
 193     BOOST_CHECK_EQUAL( p->retry(),          false );
 194     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
 195     BOOST_CHECK_EQUAL( p->moreData(),       false );
 196     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
 197     BOOST_CHECK_EQUAL( p->order(),          false );
 198
 199     BOOST_CHECK_EQUAL( p->duration(),       0u    );
 200
 201     BOOST_CHECK_EQUAL(
 202             p->ctrlFrame().receiverAddress().value(),
 203             senf::MACAddress::from_string("00:0b:6b:57:06:b0") );
 204 }
 205
 206
 207 /* test parser with creating an ACK frame*/
 208 BOOST_AUTO_UNIT_TEST(WLANPacket_ctrlFrame_create)
 209 {
 210     senf::WLANPacket p (senf::WLANPacket::create()) ;
 211 //    std::cout << unsigned( senf::init_bytes<senf::WLANPacketParser_CtrlFrameParser>::value ) << "\n";
 212     SENF_CHECK_NO_THROW(p->init_ctrlFrame());
 213 //    std::cout << unsigned( senf::init_bytes<senf::WLANPacketParser_CtrlFrameParser>::value ) << "\n";
 214     p->ctrlFrame().receiverAddress() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c");
 215     p->ctrlFrame().set_ack();
 216     BOOST_CHECK_EQUAL( p->type(), 1u);
 217     BOOST_CHECK_EQUAL( p->subtype(), 13u);
 218 }
 219