senf/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
  29 #include <senf/Utils/auto_unit_test.hh>
  30 #include <boost/test/test_tools.hpp>
  31
  32 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  33 /* test parser with a data frame */
  34 SENF_AUTO_UNIT_TEST(WLANPacket_dataFrame_packet)
  35 {
  36     unsigned char data[] = {
  37             0x88, 0x01, 0x00, 0x00, 0x00, 0x1a,             //header
  38             0x4d, 0x3e, 0xc7, 0x5c, 0x00, 0x0b, 0x6b, 0x57,
  39             0x06, 0xb0, 0x00, 0x18, 0x4d, 0x6e, 0x78, 0x48,
  40             0x30, 0x00, 0x01, 0x00,
  41             0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00,  //llc header
  42     };
  43
  44     senf::WLANPacket_DataFrame p (senf::WLANPacket_DataFrame::create(data));
  45
  46     BOOST_CHECK_EQUAL( p->version(),        0u    );
  47     BOOST_CHECK_EQUAL( p->type(),           2u    );
  48     BOOST_CHECK_EQUAL( p->subtype(),        8u    );
  49     BOOST_CHECK_EQUAL( p->toDS(),           true  );
  50     BOOST_CHECK_EQUAL( p->fromDS(),         false );
  51     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
  52     BOOST_CHECK_EQUAL( p->retry(),          false );
  53     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
  54     BOOST_CHECK_EQUAL( p->moreData(),       false );
  55     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
  56     BOOST_CHECK_EQUAL( p->order(),          false );
  57
  58     BOOST_CHECK_EQUAL( p->duration(),       0u    );
  59
  60     BOOST_CHECK_EQUAL( p->destinationAddress().value(),
  61             senf::MACAddress::from_string("00:18:4d:6e:78:48") );
  62     BOOST_CHECK_EQUAL( p->sourceAddress().value(),
  63                        senf::MACAddress::from_string("00:0b:6b:57:06:b0") );
  64     BOOST_CHECK_EQUAL (p->bssid().value(),
  65                        senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
  66
  67     BOOST_CHECK_EQUAL( p->bssid().value(),
  68                        p->receiverAddress().value() );
  69     BOOST_CHECK_EQUAL( p->transmitterAddress().value(),
  70                        p->sourceAddress().value() );
  71
  72     BOOST_CHECK_EQUAL( p->sequenceNumber(), 3u );
  73     BOOST_CHECK_EQUAL( p->fragmentNumber(), 0u );
  74
  75     std::ostringstream oss (std::ostringstream::out);
  76     SENF_CHECK_NO_THROW( p.dump(oss) );
  77
  78     BOOST_REQUIRE( p.next(senf::nothrow) );
  79     BOOST_CHECK( p.next().is<senf::LlcSnapPacket>() );
  80 }
  81
  82
  83 /* test parser with creating a data frame*/
  84 SENF_AUTO_UNIT_TEST(WLANPacket_dataFrame_create)
  85 {
  86     senf::WLANPacket_DataFrame p (senf::WLANPacket_DataFrame::create());
  87
  88     SENF_CHECK_NO_THROW( p->bssid() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
  89     SENF_CHECK_NO_THROW(p->sequenceNumber(4095u));
  90
  91     BOOST_CHECK_EQUAL( p->type(), 2u );
  92     BOOST_CHECK_EQUAL( p->sequenceNumber(), 4095u );
  93 }
  94
  95
  96 /* test parser with a beacon frame */
  97 SENF_AUTO_UNIT_TEST(WLANPacket_beaconFrame_packet)
  98 {
  99     unsigned char data[] = {
 100             0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 101             0xff, 0xff, 0x00, 0x1a, 0x4d, 0x3e, 0xc7, 0x5c,
 102             0x00, 0x1a, 0x4d, 0x3e, 0xc7, 0x5c, 0xe0, 0x12,
 103             0x38, 0xa0, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00,
 104             0x64, 0x00, 0x01, 0x05, 0x00, 0x05, 0x62, 0x6f,
 105             0x78, 0x43, 0x31, 0x01, 0x08, 0x8c, 0x12, 0x98,
 106             0x24, 0xb0, 0x48, 0x60, 0x6c, 0x03, 0x01, 0x40,
 107             0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x07, 0x2a,
 108             0x4e, 0x41, 0x49, 0x24, 0x01, 0x11, 0x28, 0x01,
 109             0x11, 0x2c, 0x01, 0x11, 0x30, 0x01, 0x11, 0x34,
 110             0x01, 0x17, 0x38, 0x01, 0x17, 0x3c, 0x01, 0x17,
 111             0x40, 0x01, 0x17, 0x95, 0x01, 0x1e, 0x99, 0x01,
 112             0x1e, 0x9d, 0x01, 0x1e, 0xa1, 0x01, 0x1e, 0xa5,
 113             0x01, 0x1e, 0x20, 0x01, 0x00, 0xdd, 0x18, 0x00,
 114             0x50, 0xf2, 0x02, 0x01, 0x01, 0x81, 0x00, 0x02,
 115             0xa3, 0x40, 0x00, 0x27, 0xa4, 0x00, 0x00, 0x42,
 116             0x43, 0x5e, 0x00, 0x62, 0x32, 0x2f, 0x00, 0xa0,
 117             0x00, 0xdd, 0x09, 0x00, 0x03, 0x7f, 0x01, 0x01,
 118             0x00, 0x24, 0xff, 0x7f,
 119     };
 120
 121     senf::WLANPacket_MgtFrame p (senf::WLANPacket_MgtFrame::create(data));
 122
 123     BOOST_CHECK_EQUAL( p->version(),        0u    );
 124     BOOST_CHECK_EQUAL( p->type(),           0u    );
 125     BOOST_CHECK_EQUAL( p->subtype(),        8u    );
 126     BOOST_CHECK_EQUAL( p->toDS(),           false );
 127     BOOST_CHECK_EQUAL( p->fromDS(),         false );
 128     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
 129     BOOST_CHECK_EQUAL( p->retry(),          false );
 130     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
 131     BOOST_CHECK_EQUAL( p->moreData(),       false );
 132     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
 133     BOOST_CHECK_EQUAL( p->order(),          false );
 134     BOOST_CHECK_EQUAL( p->duration(),       0u    );
 135
 136     BOOST_CHECK_EQUAL( p->destinationAddress().value(),
 137                        senf::MACAddress::from_string("ff:ff:ff:ff:ff:ff") );
 138     BOOST_CHECK_EQUAL( p->sourceAddress().value(),
 139                        senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
 140     BOOST_CHECK_EQUAL( p->bssid().value(),
 141                        senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
 142
 143     BOOST_CHECK_EQUAL( p->sequenceNumber(), 302u );
 144     BOOST_CHECK_EQUAL( p->fragmentNumber(), 0u   );
 145 }
 146
 147
 148 /* test parser with creating a beacon frame*/
 149 SENF_AUTO_UNIT_TEST(WLANPacket_mgtFrame_create)
 150 {
 151     senf::WLANPacket_MgtFrame p (senf::WLANPacket_MgtFrame::create());
 152
 153     SENF_CHECK_NO_THROW(
 154             p->destinationAddress() = senf::MACAddress::from_string("ff:ff:ff:ff:ff:ff")
 155     );
 156     SENF_CHECK_NO_THROW(
 157             p->sourceAddress() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c")
 158     );
 159     SENF_CHECK_NO_THROW(
 160             p->bssid() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c")
 161     );
 162     SENF_CHECK_NO_THROW(
 163             p->sequenceNumber(2);
 164             p->sequenceNumber(p->sequenceNumber()+1);
 165     );
 166
 167     BOOST_CHECK_EQUAL( p->type(), 0u );
 168     BOOST_CHECK_EQUAL( p->sequenceNumber(), 3u );
 169 }
 170
 171
 172 /* test parser with an ACK frame*/
 173 SENF_AUTO_UNIT_TEST(WLANPacket_ctrlFrame_packet)
 174 {
 175     unsigned char data[] = {
 176             0xd4, 0x00, 0x00, 0x00,
 177             0x00, 0x0b, 0x6b, 0x57, 0x06, 0xb0,
 178             0x4f, 0xda, // What is this ?
 179     };
 180
 181     senf::WLANPacket_CtrlFrame p (senf::WLANPacket_CtrlFrame::create(data));
 182
 183     BOOST_CHECK_EQUAL( p->version(),        0u    );
 184     BOOST_CHECK_EQUAL( p->type(),           1u    );
 185     BOOST_CHECK_EQUAL( p->subtype(),        13u   );
 186     BOOST_CHECK_EQUAL( p->toDS(),           false );
 187     BOOST_CHECK_EQUAL( p->fromDS(),         false );
 188     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
 189     BOOST_CHECK_EQUAL( p->retry(),          false );
 190     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
 191     BOOST_CHECK_EQUAL( p->moreData(),       false );
 192     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
 193     BOOST_CHECK_EQUAL( p->order(),          false );
 194
 195     BOOST_CHECK_EQUAL( p->duration(),       0u    );
 196
 197     BOOST_CHECK_EQUAL( p->receiverAddress().value(),
 198                        senf::MACAddress::from_string("00:0b:6b:57:06:b0") );
 199 }
 200
 201 /* test parser with creating an ACK frame*/
 202 SENF_AUTO_UNIT_TEST(WLANPacket_ctrlFrame_create)
 203 {
 204     senf::WLANPacket_CtrlFrame p (senf::WLANPacket_CtrlFrame::create()) ;
 205     p->receiverAddress() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c");
 206     p->set_ack();
 207
 208     BOOST_CHECK_EQUAL( p->type(), 1u);
 209     BOOST_CHECK_EQUAL( p->subtype(), 13u);
 210 }
 211
 212 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 213
 214 \f
 215 // Local Variables:
 216 // mode: c++
 217 // fill-column: 100
 218 // c-file-style: "senf"
 219 // indent-tabs-mode: nil
 220 // ispell-local-dictionary: "american"
 221 // compile-command: "scons -u test"
 222 // comment-column: 40
 223 // End: