| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. |
| // |
| // Unittest code for the platform-support code in platform/. |
| |
| #include <gtest/gtest.h> |
| |
| #include "third_party/iwlwifi/platform/align.h" |
| #include "third_party/iwlwifi/platform/compiler.h" |
| #include "third_party/iwlwifi/platform/debug.h" |
| #include "third_party/iwlwifi/platform/ieee80211.h" |
| #include "third_party/iwlwifi/platform/kernel.h" |
| |
| namespace { |
| |
| class PlatformTest : public testing::Test { |
| public: |
| PlatformTest() {} |
| ~PlatformTest() {} |
| }; |
| |
| TEST_F(PlatformTest, __set_bit) { |
| unsigned long masks[] = {0, 0}; |
| |
| // Test LSB at first addr. |
| __set_bit(0, masks); |
| EXPECT_EQ(masks[0], 0x0000000000000001); |
| EXPECT_EQ(masks[1], 0x0000000000000000); |
| |
| // Test MSB at first addr. |
| __set_bit(63, masks); |
| EXPECT_EQ(masks[0], 0x8000000000000001); |
| EXPECT_EQ(masks[1], 0x0000000000000000); |
| |
| // Test LSB at 2nd addr. |
| __set_bit(64, masks); |
| EXPECT_EQ(masks[0], 0x8000000000000001); |
| EXPECT_EQ(masks[1], 0x0000000000000001); |
| } |
| |
| TEST_F(PlatformTest, set_bit) { |
| unsigned long masks[] = {0, 0}; |
| |
| // Test LSB at first addr. |
| set_bit(0, masks); |
| EXPECT_EQ(masks[0], 0x0000000000000001); |
| EXPECT_EQ(masks[1], 0x0000000000000000); |
| |
| // Test MSB at first addr. |
| set_bit(63, masks); |
| EXPECT_EQ(masks[0], 0x8000000000000001); |
| EXPECT_EQ(masks[1], 0x0000000000000000); |
| |
| // Test LSB at 2nd addr. |
| set_bit(64, masks); |
| EXPECT_EQ(masks[0], 0x8000000000000001); |
| EXPECT_EQ(masks[1], 0x0000000000000001); |
| } |
| |
| TEST_F(PlatformTest, clear_bit) { |
| unsigned long masks[] = {0xffffffffffffffff, 0xffffffffffffffff}; |
| |
| // Test LSB at first addr. |
| clear_bit(0, masks); |
| EXPECT_EQ(masks[0], 0xfffffffffffffffe); |
| EXPECT_EQ(masks[1], 0xffffffffffffffff); |
| |
| // Test MSB at first addr. |
| clear_bit(63, masks); |
| EXPECT_EQ(masks[0], 0x7ffffffffffffffe); |
| EXPECT_EQ(masks[1], 0xffffffffffffffff); |
| |
| // Test LSB at 2nd addr. |
| clear_bit(64, masks); |
| EXPECT_EQ(masks[0], 0x7ffffffffffffffe); |
| EXPECT_EQ(masks[1], 0xfffffffffffffffe); |
| } |
| |
| TEST_F(PlatformTest, bits_to_ints) { |
| EXPECT_EQ(0, BITS_TO_INTS(0)); |
| EXPECT_EQ(1, BITS_TO_INTS(1)); |
| EXPECT_EQ(1, BITS_TO_INTS(BITS_PER_INT - 1)); |
| EXPECT_EQ(1, BITS_TO_INTS(BITS_PER_INT)); |
| EXPECT_EQ(2, BITS_TO_INTS(BITS_PER_INT + 1)); |
| } |
| |
| TEST_F(PlatformTest, bits_to_longs) { |
| EXPECT_EQ(0, BITS_TO_LONGS(0)); |
| EXPECT_EQ(1, BITS_TO_LONGS(1)); |
| EXPECT_EQ(1, BITS_TO_LONGS(BITS_PER_LONG - 1)); |
| EXPECT_EQ(1, BITS_TO_LONGS(BITS_PER_LONG)); |
| EXPECT_EQ(2, BITS_TO_LONGS(BITS_PER_LONG + 1)); |
| } |
| |
| TEST_F(PlatformTest, eth_broadcast_addr) { |
| uint8_t mac[] = {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde}; |
| eth_broadcast_addr(mac); |
| |
| uint8_t expected[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde}; |
| EXPECT_EQ(0, std::memcmp(expected, mac, sizeof(expected))); |
| } |
| |
| TEST_F(PlatformTest, find_first_bit) { |
| unsigned test0[] = { |
| 0x00000000, |
| 0x00000000, |
| }; |
| EXPECT_EQ(1, find_first_bit(test0, 1)); // Not found |
| EXPECT_EQ(31, find_first_bit(test0, 31)); // Not found |
| EXPECT_EQ(32, find_first_bit(test0, 32)); // Not found |
| EXPECT_EQ(64, find_first_bit(test0, 64)); // Not found |
| |
| unsigned test1[] = { |
| 0x80000000, |
| 0xdead0001, |
| }; |
| ASSERT_EQ(sizeof(*test1), 4); |
| EXPECT_EQ(1, find_first_bit(test1, 1)); // Not found |
| EXPECT_EQ(31, find_first_bit(test1, 31)); // Not found |
| EXPECT_EQ(31, find_first_bit(test1, 32)); |
| EXPECT_EQ(31, find_first_bit(test1, 33)); |
| EXPECT_EQ(31, find_first_bit(test1, 64)); |
| |
| unsigned test2[] = { |
| 0x00000000, |
| 0xdead0001, |
| }; |
| EXPECT_EQ(31, find_first_bit(test2, 31)); // Not found |
| EXPECT_EQ(32, find_first_bit(test2, 32)); // Not found |
| EXPECT_EQ(32, find_first_bit(test2, 33)); |
| EXPECT_EQ(32, find_first_bit(test2, 64)); |
| } |
| |
| TEST_F(PlatformTest, find_last_bit) { |
| unsigned test0[] = { |
| 0x00000000, |
| 0x00000000, |
| }; |
| EXPECT_EQ(1, find_last_bit(test0, 1)); // Not found |
| EXPECT_EQ(31, find_last_bit(test0, 31)); // Not found |
| EXPECT_EQ(32, find_last_bit(test0, 32)); // Not found |
| EXPECT_EQ(64, find_last_bit(test0, 64)); // Not found |
| |
| unsigned test1[] = { |
| 0x40000000, |
| 0x00010001, |
| }; |
| ASSERT_EQ(sizeof(*test1), 4); |
| EXPECT_EQ(1, find_last_bit(test1, 1)); // Not found |
| EXPECT_EQ(30, find_last_bit(test1, 31)); |
| EXPECT_EQ(30, find_last_bit(test1, 32)); |
| EXPECT_EQ(32, find_last_bit(test1, 33)); |
| EXPECT_EQ(32, find_last_bit(test1, 48)); |
| EXPECT_EQ(48, find_last_bit(test1, 64)); |
| |
| unsigned test2[] = { |
| 0x00000000, |
| 0x80000000, |
| }; |
| EXPECT_EQ(31, find_last_bit(test2, 31)); // Not found |
| EXPECT_EQ(32, find_last_bit(test2, 32)); // Not found |
| EXPECT_EQ(33, find_last_bit(test2, 33)); // Not found |
| EXPECT_EQ(63, find_last_bit(test2, 64)); |
| } |
| |
| TEST_F(PlatformTest, find_next_bit) { |
| unsigned test[] = { |
| 0x00001000, |
| 0x00000000, |
| }; |
| |
| EXPECT_EQ(32, find_next_bit(test, 32, 16)); // Not found |
| EXPECT_EQ(12, find_next_bit(test, 32, 0)); |
| EXPECT_EQ(12, find_next_bit(test, 64, 0)); |
| } |
| |
| TEST_F(PlatformTest, ieee80211_sn_less) { |
| EXPECT_FALSE(ieee80211_sn_less(0x0000, 0x0000)); |
| EXPECT_FALSE(ieee80211_sn_less(0x0040, 0x0040)); |
| EXPECT_TRUE(ieee80211_sn_less(0x0000, 0x0001)); |
| EXPECT_FALSE(ieee80211_sn_less(0x0001, 0x0000)); |
| |
| EXPECT_TRUE(ieee80211_sn_less(0x0000, 0x07ff)); |
| EXPECT_FALSE(ieee80211_sn_less(0x07ff, 0x0000)); |
| |
| EXPECT_FALSE(ieee80211_sn_less(0x0000, 0x0800)); |
| EXPECT_FALSE(ieee80211_sn_less(0x0800, 0x0000)); |
| EXPECT_TRUE(ieee80211_sn_less(0x0801, 0x0000)); |
| |
| EXPECT_TRUE(ieee80211_sn_less(0x0003, 0x0800)); |
| |
| EXPECT_TRUE(ieee80211_sn_less(0x0f00, 0x0000)); |
| |
| EXPECT_FALSE(ieee80211_sn_less(0x0fff, 0x07ff)); |
| EXPECT_FALSE(ieee80211_sn_less(0x07ff, 0x0fff)); |
| |
| EXPECT_TRUE(ieee80211_sn_less(0x0fff, 0x07fe)); |
| EXPECT_TRUE(ieee80211_sn_less(0x0800, 0x0fff)); |
| } |
| |
| TEST_F(PlatformTest, u32_encode_bits) { |
| // normal cases |
| EXPECT_EQ(0x00000066, u32_encode_bits(0x5566, 0x000000ff)); |
| EXPECT_EQ(0x00556600, u32_encode_bits(0x5566, 0x00ffff00)); |
| EXPECT_EQ(0x55660000, u32_encode_bits(0x5566, 0xffff0000)); |
| EXPECT_EQ(0x05566180, u32_encode_bits(0x556618, 0x0ffffff0)); |
| |
| // overflow cases |
| EXPECT_EQ(0x00000001, u32_encode_bits(0xffff, 0x00000001)); |
| EXPECT_EQ(0x00018300, u32_encode_bits(0x55660183, 0x00ffff00)); |
| EXPECT_EQ(0x66018300, u32_encode_bits(0x55660183, 0xffffff00)); |
| |
| // unusual masks |
| EXPECT_EQ(0x00001001, u32_encode_bits(0xffff, 0xf0f01001)); // shift 0 |
| } |
| |
| TEST_F(PlatformTest, is_power_of_2) { |
| EXPECT_TRUE(is_power_of_2(0)); |
| EXPECT_TRUE(is_power_of_2(1)); |
| EXPECT_TRUE(is_power_of_2(2)); |
| EXPECT_FALSE(is_power_of_2(3)); |
| EXPECT_TRUE(is_power_of_2(0x10000000)); |
| EXPECT_FALSE(is_power_of_2(0xf0000000)); |
| } |
| |
| TEST_F(PlatformTest, ALIGN) { |
| EXPECT_EQ(8, ALIGN(5, 4)); |
| EXPECT_EQ(14, ALIGN(11, 7)); |
| } |
| |
| TEST_F(PlatformTest, lower_upper) { |
| EXPECT_EQ(0x34567890, lower_32_bits(0x1234567890)); |
| EXPECT_EQ(0x12, upper_32_bits(0x1234567890)); |
| } |
| |
| TEST_F(PlatformTest, ilog2) { |
| EXPECT_EQ(31, ilog2(0x80000000)); |
| EXPECT_EQ(31, ilog2(0xffffffff)); |
| EXPECT_EQ(1, ilog2(0x00000003)); |
| EXPECT_EQ(0, ilog2(0x00000001)); |
| EXPECT_EQ(-1, ilog2(0)); |
| } |
| |
| } // namespace |