lib/wlan/mlme/tests/span_unittest.cpp

// Copyright 2018 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.

#include <array>
#include <vector>
#include <wlan/common/span.h>
#include <gtest/gtest.h>

namespace wlan {

Span<const int> FuncThatTakesConstSpan(Span<const int> span) {
    return span;
}

Span<int> FuncThatTakesSpan(Span<int> span) {
    return span;
}

TEST(Span, DefaultConstructor) {
    Span<int> s;
    EXPECT_EQ(0u, s.size());
    EXPECT_TRUE(s.empty());
}

TEST(Span, CopyConstructor) {
    int x;
    Span<int> input(&x, 1);
    Span<int> output = FuncThatTakesSpan(input);
    EXPECT_EQ(&x, output.data());
    EXPECT_EQ(1u, output.size());
}

TEST(Span, ConstructFromTwoPointers) {
    int arr[3] = {};
    Span<int> s(arr, arr + 3);
    EXPECT_EQ(arr, s.data());
    EXPECT_EQ(3u, s.size());
}

TEST(Span, ImplicitConversionFromNonConstSpan) {
    int x;
    Span<int> input(&x, 1);
    Span<const int> output = FuncThatTakesConstSpan(input);
    EXPECT_EQ(&x, output.data());
    EXPECT_EQ(1u, output.size());
}

TEST(Span, ImplicitConversionFromArray) {
    int arr[3] = { 10, 20, 30 };
    {
        auto s = FuncThatTakesConstSpan(arr);
        EXPECT_EQ(arr, s.data());
        EXPECT_EQ(3u, s.size());
    }
    {
        auto s = FuncThatTakesSpan(arr);
        EXPECT_EQ(arr, s.data());
        EXPECT_EQ(3u, s.size());
    }

    const int const_arr[3] = { 10, 20, 30 };
    {
        auto s = FuncThatTakesConstSpan(const_arr);
        EXPECT_EQ(const_arr, s.data());
        EXPECT_EQ(3u, s.size());
    }
}

TEST(Span, ImplicitConversionFromStdArray) {
    std::array<int, 3> arr = { 10, 20, 30 };
    {
        auto s = FuncThatTakesConstSpan(arr);
        EXPECT_EQ(arr.data(), s.data());
        EXPECT_EQ(3u, s.size());
    }
    {
        auto s = FuncThatTakesSpan(arr);
        EXPECT_EQ(arr.data(), s.data());
        EXPECT_EQ(3u, s.size());
    }

    const std::array<int, 3> const_arr = { 10, 20, 30 };
    {
        auto s = FuncThatTakesConstSpan(const_arr);
        EXPECT_EQ(const_arr.data(), s.data());
        EXPECT_EQ(3u, s.size());
    }
}

TEST(Span, ImplicitConversionFromVector) {
    std::vector<int> vec = { 10, 20, 30 };
    {
        auto s = FuncThatTakesConstSpan(vec);
        EXPECT_EQ(vec.data(), s.data());
        EXPECT_EQ(3u, s.size());
    }
    {
        auto s = FuncThatTakesSpan(vec);
        EXPECT_EQ(vec.data(), s.data());
        EXPECT_EQ(3u, s.size());
    }

    const std::vector<int> const_vec = { 10, 20, 30 };
    {
        auto s = FuncThatTakesConstSpan(const_vec);
        EXPECT_EQ(const_vec.data(), s.data());
        EXPECT_EQ(3u, s.size());
    }
}

TEST(Span, SizeInBytes) {
    int32_t arr[2];
    Span<int32_t> s(arr, arr + 2);
    EXPECT_EQ(2u, s.size());
    EXPECT_EQ(8u, s.size_bytes());
}

TEST(Span, IndexOperator) {
    int arr[3] = {};
    Span<int> s(arr);
    EXPECT_EQ(&s[1], &arr[1]);
}

TEST(Span, RangeBasedFor) {
    const std::vector<int> input = { 10, 20, 30 };
    Span<const int> s(input);

    std::vector<int> output;
    for (int x : s) {
        output.push_back(x);
    }
    EXPECT_EQ(input, output);
}

TEST(Span, Subspan) {
    int arr[10] = {};
    Span<int> s(arr);
    Span<int> ss = s.subspan(3);
    EXPECT_EQ(arr + 3, ss.data());
    EXPECT_EQ(7u, ss.size());
}

TEST(Span, SubspanWithLength) {
    int arr[10] = {};
    Span<int> s(arr);
    Span<int> ss = s.subspan(3, 5);
    EXPECT_EQ(arr + 3, ss.data());
    EXPECT_EQ(5u, ss.size());
}

TEST(Span, AsBytes) {
    int32_t arr[3] = {};
    Span<int32_t> s(arr);
    Span<const std::byte> b = as_bytes(s);
    EXPECT_EQ(static_cast<void*>(arr), b.data());
    EXPECT_EQ(12u, b.size());
}

TEST(Span, AsWritableBytes) {
    int32_t arr[3] = {};
    Span<int32_t> s(arr);
    Span<std::byte> b = as_writable_bytes(s);
    EXPECT_EQ(static_cast<void*>(arr), b.data());
    EXPECT_EQ(12u, b.size());
}

} // namespace wlan