tests/scan_settings_unittest.cpp

   1 /*
   2  * Copyright (C) 2016, The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <vector>
  18
  19 #include <gtest/gtest.h>
  20
  21 #include "wificond/scanning/channel_settings.h"
  22 #include "wificond/scanning/hidden_network.h"
  23 #include "wificond/scanning/pno_network.h"
  24 #include "wificond/scanning/pno_settings.h"
  25 #include "wificond/scanning/single_scan_settings.h"
  26
  27 using ::com::android::server::wifi::wificond::ChannelSettings;
  28 using ::com::android::server::wifi::wificond::HiddenNetwork;
  29 using ::com::android::server::wifi::wificond::PnoNetwork;
  30 using ::com::android::server::wifi::wificond::PnoSettings;
  31 using ::com::android::server::wifi::wificond::SingleScanSettings;
  32 using std::vector;
  33
  34 namespace android {
  35 namespace wificond {
  36
  37 namespace {
  38
  39 const uint8_t kFakeSsid[] =
  40     {'G', 'o', 'o', 'g', 'l', 'e', 'G', 'u', 'e', 's', 't'};
  41 const uint8_t kFakeSsid1[] =
  42     {'A', 'n', 'd', 'r', 'o', 'i', 'd', 'A', 'P', 'T', 'e', 's', 't'};
  43
  44 constexpr int32_t kFakePnoIntervalMs = 20000;
  45 constexpr int32_t kFakePnoMin2gRssi = -80;
  46 constexpr int32_t kFakePnoMin5gRssi = -85;
  47
  48 constexpr uint32_t kFakeFrequency = 5260;
  49 constexpr uint32_t kFakeFrequency1 = 2460;
  50 constexpr uint32_t kFakeFrequency2 = 2500;
  51
  52 }  // namespace
  53
  54 class ScanSettingsTest : public ::testing::Test {
  55 };
  56
  57 TEST_F(ScanSettingsTest, ChannelSettingsParcelableTest) {
  58   ChannelSettings channel_settings;
  59   channel_settings.frequency_ = kFakeFrequency;
  60
  61   Parcel parcel;
  62   EXPECT_EQ(::android::OK, channel_settings.writeToParcel(&parcel));
  63
  64   ChannelSettings channel_settings_copy;
  65   parcel.setDataPosition(0);
  66   EXPECT_EQ(::android::OK, channel_settings_copy.readFromParcel(&parcel));
  67
  68   EXPECT_EQ(channel_settings, channel_settings_copy);
  69 }
  70
  71 TEST_F(ScanSettingsTest, HiddenNetworkParcelableTest) {
  72   HiddenNetwork hidden_network;
  73   hidden_network.ssid_ =
  74       vector<uint8_t>(kFakeSsid, kFakeSsid + sizeof(kFakeSsid));
  75
  76   Parcel parcel;
  77   EXPECT_EQ(::android::OK, hidden_network.writeToParcel(&parcel));
  78
  79   HiddenNetwork hidden_network_copy;
  80   parcel.setDataPosition(0);
  81   EXPECT_EQ(::android::OK, hidden_network_copy.readFromParcel(&parcel));
  82
  83   EXPECT_EQ(hidden_network, hidden_network_copy);
  84 }
  85
  86 TEST_F(ScanSettingsTest, SingleScanSettingsParcelableTest) {
  87   SingleScanSettings scan_settings;
  88
  89   ChannelSettings channel, channel1, channel2;
  90   channel.frequency_ = kFakeFrequency;
  91   channel1.frequency_ = kFakeFrequency1;
  92   channel2.frequency_ = kFakeFrequency2;
  93
  94   HiddenNetwork network;
  95   network.ssid_ =
  96       vector<uint8_t>(kFakeSsid, kFakeSsid + sizeof(kFakeSsid));
  97
  98   scan_settings.channel_settings_ = {channel, channel1, channel2};
  99   scan_settings.hidden_networks_ = {network};
 100
 101   Parcel parcel;
 102   EXPECT_EQ(::android::OK, scan_settings.writeToParcel(&parcel));
 103
 104   SingleScanSettings scan_settings_copy;
 105   parcel.setDataPosition(0);
 106   EXPECT_EQ(::android::OK, scan_settings_copy.readFromParcel(&parcel));
 107
 108   EXPECT_EQ(scan_settings, scan_settings_copy);
 109 }
 110
 111 TEST_F(ScanSettingsTest, PnoNetworkParcelableTest) {
 112   PnoNetwork pno_network;
 113   pno_network.ssid_ =
 114       vector<uint8_t>(kFakeSsid, kFakeSsid + sizeof(kFakeSsid));
 115   pno_network.is_hidden_ = true;
 116
 117   Parcel parcel;
 118   EXPECT_EQ(::android::OK, pno_network.writeToParcel(&parcel));
 119
 120   PnoNetwork pno_network_copy;
 121   parcel.setDataPosition(0);
 122   EXPECT_EQ(::android::OK, pno_network_copy.readFromParcel(&parcel));
 123
 124   EXPECT_EQ(pno_network, pno_network_copy);
 125 }
 126
 127 TEST_F(ScanSettingsTest, PnoSettingsParcelableTest) {
 128   PnoSettings pno_settings;
 129
 130   PnoNetwork network, network1;
 131   network.ssid_ =
 132       vector<uint8_t>(kFakeSsid, kFakeSsid + sizeof(kFakeSsid));
 133   network.is_hidden_ = true;
 134   network1.ssid_ =
 135       vector<uint8_t>(kFakeSsid1, kFakeSsid1 + sizeof(kFakeSsid1));
 136   network1.is_hidden_ = false;
 137
 138   pno_settings.interval_ms_ = kFakePnoIntervalMs;
 139   pno_settings.min_2g_rssi_ = kFakePnoMin2gRssi;
 140   pno_settings.min_5g_rssi_ = kFakePnoMin5gRssi;
 141
 142   pno_settings.pno_networks_ = {network, network1};
 143
 144   Parcel parcel;
 145   EXPECT_EQ(::android::OK, pno_settings.writeToParcel(&parcel));
 146
 147   PnoSettings pno_settings_copy;
 148   parcel.setDataPosition(0);
 149   EXPECT_EQ(::android::OK, pno_settings_copy.readFromParcel(&parcel));
 150
 151   EXPECT_EQ(pno_settings, pno_settings_copy);
 152 }
 153
 154
 155
 156 }  // namespace wificond
 157 }  // namespace android