senf/Packets/80211Bundle/WLANPacket.test.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2008
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 //
   6 // The contents of this file are subject to the Fraunhofer FOKUS Public License
   7 // Version 1.0 (the "License"); you may not use this file except in compliance
   8 // with the License. You may obtain a copy of the License at
   9 // http://senf.berlios.de/license.html
  10 //
  11 // The Fraunhofer FOKUS Public License Version 1.0 is based on,
  12 // but modifies the Mozilla Public License Version 1.1.
  13 // See the full license text for the amendments.
  14 //
  15 // Software distributed under the License is distributed on an "AS IS" basis,
  16 // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  17 // for the specific language governing rights and limitations under the License.
  18 //
  19 // The Original Code is Fraunhofer FOKUS code.
  20 //
  21 // The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V.
  22 // (registered association), Hansastraße 27 c, 80686 Munich, Germany.
  23 // All Rights Reserved.
  24 //
  25 // Contributor(s):
  26 //   Christian Niephaus <cni@berlios.de>
  27
  28 /** \file
  29     \brief WLANPacket unit tests */
  30
  31 // Custom includes
  32 #include "WLANPacket.hh"
  33
  34 #include <senf/Utils/auto_unit_test.hh>
  35 #include <boost/test/test_tools.hpp>
  36
  37 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  38 /* test parser with a data frame */
  39 SENF_AUTO_UNIT_TEST(WLANPacket_dataFrame_packet)
  40 {
  41     unsigned char data[] = {
  42             0x88, 0x01, 0x00, 0x00, 0x00, 0x1a,             //header
  43             0x4d, 0x3e, 0xc7, 0x5c, 0x00, 0x0b, 0x6b, 0x57,
  44             0x06, 0xb0, 0x00, 0x18, 0x4d, 0x6e, 0x78, 0x48,
  45             0x30, 0x00, 0x01, 0x00,
  46             0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00,  //llc header
  47     };
  48
  49     senf::WLANPacket_DataFrame p (senf::WLANPacket_DataFrame::create(data));
  50
  51     BOOST_CHECK_EQUAL( p->version(),        0u    );
  52     BOOST_CHECK_EQUAL( p->type(),           2u    );
  53     BOOST_CHECK_EQUAL( p->subtype(),        8u    );
  54     BOOST_CHECK_EQUAL( p->toDS(),           true  );
  55     BOOST_CHECK_EQUAL( p->fromDS(),         false );
  56     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
  57     BOOST_CHECK_EQUAL( p->retry(),          false );
  58     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
  59     BOOST_CHECK_EQUAL( p->moreData(),       false );
  60     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
  61     BOOST_CHECK_EQUAL( p->order(),          false );
  62
  63     BOOST_CHECK_EQUAL( p->duration(),       0u    );
  64
  65     BOOST_CHECK_EQUAL( p->destinationAddress().value(),
  66             senf::MACAddress::from_string("00:18:4d:6e:78:48") );
  67     BOOST_CHECK_EQUAL( p->sourceAddress().value(),
  68                        senf::MACAddress::from_string("00:0b:6b:57:06:b0") );
  69     BOOST_CHECK_EQUAL (p->bssid().value(),
  70                        senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
  71
  72     BOOST_CHECK_EQUAL( p->bssid().value(),
  73                        p->receiverAddress().value() );
  74     BOOST_CHECK_EQUAL( p->transmitterAddress().value(),
  75                        p->sourceAddress().value() );
  76
  77     BOOST_CHECK_EQUAL( p->sequenceNumber(), 3u );
  78     BOOST_CHECK_EQUAL( p->fragmentNumber(), 0u );
  79
  80     std::ostringstream oss (std::ostringstream::out);
  81     SENF_CHECK_NO_THROW( p.dump(oss) );
  82
  83     BOOST_REQUIRE( p.next(senf::nothrow) );
  84     BOOST_CHECK( p.next().is<senf::LlcSnapPacket>() );
  85 }
  86
  87
  88 /* test parser with creating a data frame*/
  89 SENF_AUTO_UNIT_TEST(WLANPacket_dataFrame_create)
  90 {
  91     senf::WLANPacket_DataFrame p (senf::WLANPacket_DataFrame::create());
  92
  93     SENF_CHECK_NO_THROW( p->bssid() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
  94     SENF_CHECK_NO_THROW(p->sequenceNumber(4095u));
  95
  96     BOOST_CHECK_EQUAL( p->type(), 2u );
  97     BOOST_CHECK_EQUAL( p->sequenceNumber(), 4095u );
  98 }
  99
 100
 101 /* test parser with a beacon frame */
 102 SENF_AUTO_UNIT_TEST(WLANPacket_beaconFrame_packet)
 103 {
 104     unsigned char data[] = {
 105             0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 106             0xff, 0xff, 0x00, 0x1a, 0x4d, 0x3e, 0xc7, 0x5c,
 107             0x00, 0x1a, 0x4d, 0x3e, 0xc7, 0x5c, 0xe0, 0x12,
 108             0x38, 0xa0, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00,
 109             0x64, 0x00, 0x01, 0x05, 0x00, 0x05, 0x62, 0x6f,
 110             0x78, 0x43, 0x31, 0x01, 0x08, 0x8c, 0x12, 0x98,
 111             0x24, 0xb0, 0x48, 0x60, 0x6c, 0x03, 0x01, 0x40,
 112             0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x07, 0x2a,
 113             0x4e, 0x41, 0x49, 0x24, 0x01, 0x11, 0x28, 0x01,
 114             0x11, 0x2c, 0x01, 0x11, 0x30, 0x01, 0x11, 0x34,
 115             0x01, 0x17, 0x38, 0x01, 0x17, 0x3c, 0x01, 0x17,
 116             0x40, 0x01, 0x17, 0x95, 0x01, 0x1e, 0x99, 0x01,
 117             0x1e, 0x9d, 0x01, 0x1e, 0xa1, 0x01, 0x1e, 0xa5,
 118             0x01, 0x1e, 0x20, 0x01, 0x00, 0xdd, 0x18, 0x00,
 119             0x50, 0xf2, 0x02, 0x01, 0x01, 0x81, 0x00, 0x02,
 120             0xa3, 0x40, 0x00, 0x27, 0xa4, 0x00, 0x00, 0x42,
 121             0x43, 0x5e, 0x00, 0x62, 0x32, 0x2f, 0x00, 0xa0,
 122             0x00, 0xdd, 0x09, 0x00, 0x03, 0x7f, 0x01, 0x01,
 123             0x00, 0x24, 0xff, 0x7f,
 124     };
 125
 126     senf::WLANPacket_MgtFrame p (senf::WLANPacket_MgtFrame::create(data));
 127
 128     BOOST_CHECK_EQUAL( p->version(),        0u    );
 129     BOOST_CHECK_EQUAL( p->type(),           0u    );
 130     BOOST_CHECK_EQUAL( p->subtype(),        8u    );
 131     BOOST_CHECK_EQUAL( p->toDS(),           false );
 132     BOOST_CHECK_EQUAL( p->fromDS(),         false );
 133     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
 134     BOOST_CHECK_EQUAL( p->retry(),          false );
 135     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
 136     BOOST_CHECK_EQUAL( p->moreData(),       false );
 137     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
 138     BOOST_CHECK_EQUAL( p->order(),          false );
 139     BOOST_CHECK_EQUAL( p->duration(),       0u    );
 140
 141     BOOST_CHECK_EQUAL( p->destinationAddress().value(),
 142                        senf::MACAddress::from_string("ff:ff:ff:ff:ff:ff") );
 143     BOOST_CHECK_EQUAL( p->sourceAddress().value(),
 144                        senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
 145     BOOST_CHECK_EQUAL( p->bssid().value(),
 146                        senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
 147
 148     BOOST_CHECK_EQUAL( p->sequenceNumber(), 302u );
 149     BOOST_CHECK_EQUAL( p->fragmentNumber(), 0u   );
 150 }
 151
 152
 153 /* test parser with creating a beacon frame*/
 154 SENF_AUTO_UNIT_TEST(WLANPacket_mgtFrame_create)
 155 {
 156     senf::WLANPacket_MgtFrame p (senf::WLANPacket_MgtFrame::create());
 157
 158     SENF_CHECK_NO_THROW(
 159             p->destinationAddress() = senf::MACAddress::from_string("ff:ff:ff:ff:ff:ff")
 160     );
 161     SENF_CHECK_NO_THROW(
 162             p->sourceAddress() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c")
 163     );
 164     SENF_CHECK_NO_THROW(
 165             p->bssid() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c")
 166     );
 167     SENF_CHECK_NO_THROW(
 168             p->sequenceNumber(2);
 169             p->sequenceNumber(p->sequenceNumber()+1);
 170     );
 171
 172     BOOST_CHECK_EQUAL( p->type(), 0u );
 173     BOOST_CHECK_EQUAL( p->sequenceNumber(), 3u );
 174 }
 175
 176
 177 /* test parser with an ACK frame*/
 178 SENF_AUTO_UNIT_TEST(WLANPacket_ctrlFrame_packet)
 179 {
 180     unsigned char data[] = {
 181             0xd4, 0x00, 0x00, 0x00,
 182             0x00, 0x0b, 0x6b, 0x57, 0x06, 0xb0,
 183             0x4f, 0xda, // What is this ?
 184     };
 185
 186     senf::WLANPacket_CtrlFrame p (senf::WLANPacket_CtrlFrame::create(data));
 187
 188     BOOST_CHECK_EQUAL( p->version(),        0u    );
 189     BOOST_CHECK_EQUAL( p->type(),           1u    );
 190     BOOST_CHECK_EQUAL( p->subtype(),        13u   );
 191     BOOST_CHECK_EQUAL( p->toDS(),           false );
 192     BOOST_CHECK_EQUAL( p->fromDS(),         false );
 193     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
 194     BOOST_CHECK_EQUAL( p->retry(),          false );
 195     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
 196     BOOST_CHECK_EQUAL( p->moreData(),       false );
 197     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
 198     BOOST_CHECK_EQUAL( p->order(),          false );
 199
 200     BOOST_CHECK_EQUAL( p->duration(),       0u    );
 201
 202     BOOST_CHECK_EQUAL( p->receiverAddress().value(),
 203                        senf::MACAddress::from_string("00:0b:6b:57:06:b0") );
 204 }
 205
 206 /* test parser with creating an ACK frame*/
 207 SENF_AUTO_UNIT_TEST(WLANPacket_ctrlFrame_create)
 208 {
 209     senf::WLANPacket_CtrlFrame p (senf::WLANPacket_CtrlFrame::create()) ;
 210     p->receiverAddress() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c");
 211     p->set_ack();
 212
 213     BOOST_CHECK_EQUAL( p->type(), 1u);
 214     BOOST_CHECK_EQUAL( p->subtype(), 13u);
 215 }
 216
 217 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 218
 219 \f
 220 // Local Variables:
 221 // mode: c++
 222 // fill-column: 100
 223 // c-file-style: "senf"
 224 // indent-tabs-mode: nil
 225 // ispell-local-dictionary: "american"
 226 // compile-command: "scons -u test"
 227 // comment-column: 40
 228 // End: