| // 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 "third_party/iwlwifi/test/test.h" |
| #include "third_party/iwlwifi/platform/compiler.h" |
| #include "third_party/iwlwifi/platform/debug.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_BYTES_EQ(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, HexDumpErrorHandling) { |
| char buf[HEX_DUMP_BUF_SIZE - 1]; |
| uint8_t data[] = {}; |
| |
| // buffer underrun case |
| ASSERT_EQ(nullptr, hex_dump_str(buf, sizeof(buf), data, sizeof(data))); |
| |
| // attempt to dump too many bytes |
| ASSERT_EQ(nullptr, hex_dump_str(buf, sizeof(buf), data, 17)); |
| } |
| |
| TEST_F(PlatformTest, HexDumpExactly16Bytes) { |
| char buf[HEX_DUMP_BUF_SIZE]; |
| uint8_t data[] = { |
| 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, |
| 0xde, 0xad, 0xbe, 0xef, 0x55, 0x66, 0x01, 0x83, |
| }; |
| |
| ASSERT_EQ(buf, hex_dump_str(buf, sizeof(buf), data, sizeof(data))); |
| |
| // Hex value part |
| EXPECT_EQ('0', buf[0]); // the first byte: 0x01 |
| EXPECT_EQ('1', buf[1]); |
| EXPECT_EQ(':', buf[2]); |
| EXPECT_EQ('8', buf[15 * 3 + 0]); // the last byte: 0x83 |
| EXPECT_EQ('3', buf[15 * 3 + 1]); |
| EXPECT_EQ(':', buf[15 * 3 + 2]); |
| |
| // ASCII part |
| EXPECT_EQ(kNP, buf[50]); // non-printable |
| EXPECT_EQ('E', buf[52]); // printable |
| EXPECT_EQ(kNP, buf[54]); // non-printable |
| EXPECT_EQ(kNP, buf[55]); // the last byte: non-printable |
| EXPECT_EQ('\0', buf[HEX_DUMP_BUF_SIZE - 1]); // null-terminator |
| } |
| |
| TEST_F(PlatformTest, HexDumpLessThan16Bytes) { |
| char buf[HEX_DUMP_BUF_SIZE]; |
| uint8_t data[] = { |
| 0x61, |
| }; |
| |
| ASSERT_EQ(buf, hex_dump_str(buf, sizeof(buf), data, sizeof(data))); |
| |
| // Hex value part |
| EXPECT_EQ('6', buf[0]); // the first byte: 0x61 |
| EXPECT_EQ('1', buf[1]); |
| EXPECT_EQ(':', buf[2]); |
| EXPECT_EQ(' ', buf[3]); // the second byte: not dumped. |
| EXPECT_EQ(' ', buf[4]); |
| EXPECT_EQ(' ', buf[5]); |
| |
| // ASCII part |
| EXPECT_EQ('a', buf[50]); // printable |
| EXPECT_EQ(' ', buf[52]); // the second byte: not dumped. |
| EXPECT_EQ('\0', buf[HEX_DUMP_BUF_SIZE - 1]); // null-terminator |
| } |
| |
| TEST_F(PlatformTest, HexDumpZeroByte) { |
| char buf[HEX_DUMP_BUF_SIZE]; |
| uint8_t data[] = {}; |
| |
| ASSERT_EQ(buf, hex_dump_str(buf, sizeof(buf), data, sizeof(data))); |
| |
| // Hex value part |
| EXPECT_EQ(' ', buf[0]); // nothing dumped |
| EXPECT_EQ(' ', buf[1]); |
| EXPECT_EQ(' ', buf[2]); |
| |
| // ASCII part |
| EXPECT_EQ(' ', buf[50]); // nothing dumped |
| EXPECT_EQ('\0', buf[HEX_DUMP_BUF_SIZE - 1]); // null-terminator |
| } |
| } // namespace |