pw_stream/memory_stream_test.cc

// Copyright 2020 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.

#include "pw_stream/memory_stream.h"

#include "gtest/gtest.h"
#include "pw_preprocessor/compiler.h"

namespace pw::stream {
namespace {

// Size of the in-memory buffer to use for this test.
constexpr size_t kSinkBufferSize = 1013;

struct TestStruct {
  uint8_t day;
  uint8_t month;
  uint16_t year;
};

constexpr TestStruct kExpectedStruct = {.day = 18, .month = 5, .year = 2020};

std::array<std::byte, kSinkBufferSize> memory_buffer;

TEST(MemoryWriter, BytesWritten) {
  MemoryWriter memory_writer(memory_buffer);
  EXPECT_EQ(memory_writer.bytes_written(), 0u);
  Status status =
      memory_writer.Write(&kExpectedStruct, sizeof(kExpectedStruct));
  EXPECT_TRUE(status.ok());
  EXPECT_EQ(memory_writer.bytes_written(), sizeof(kExpectedStruct));
}

TEST(MemoryWriter, ValidateContents) {
  MemoryWriter memory_writer(memory_buffer);
  EXPECT_TRUE(
      memory_writer.Write(&kExpectedStruct, sizeof(kExpectedStruct)).ok());

  std::span<const std::byte> written_data = memory_writer.WrittenData();
  EXPECT_EQ(written_data.size_bytes(), sizeof(kExpectedStruct));
  TestStruct temp;
  std::memcpy(&temp, written_data.data(), written_data.size_bytes());
  EXPECT_EQ(memcmp(&temp, &kExpectedStruct, sizeof(kExpectedStruct)), 0);
}

TEST(MemoryWriter, MultipleWrites) {
  constexpr size_t kTempBufferSize = 72;
  std::byte buffer[kTempBufferSize] = {};
  size_t counter = 0;

  MemoryWriter memory_writer(memory_buffer);

  do {
    for (size_t i = 0; i < sizeof(buffer); ++i) {
      buffer[i] = std::byte(counter++);
    }
  } while (memory_writer.Write(std::span(buffer)) !=
           Status::RESOURCE_EXHAUSTED);

  // Ensure that we counted up to at least the sink buffer size. This can be
  // more since we write to the sink via in intermediate buffer.
  EXPECT_GE(counter, kSinkBufferSize);

  EXPECT_EQ(memory_writer.bytes_written(), kSinkBufferSize);

  counter = 0;
  for (const std::byte& value : memory_writer.WrittenData()) {
    EXPECT_EQ(value, std::byte(counter++));
  }
}

TEST(MemoryWriter, EmptyData) {
  std::byte buffer[5] = {};

  MemoryWriter memory_writer(memory_buffer);
  EXPECT_TRUE(memory_writer.Write(buffer, 0).ok());
  EXPECT_EQ(memory_writer.bytes_written(), 0u);
}

#if CHECK_TEST_CRASHES

// TODO(amontanez): Ensure that this test triggers an assert.
TEST(MemoryWriter, NullPointer) {
  MemoryWriter memory_writer(memory_buffer);
  memory_writer.Write(nullptr, 21);
}

#endif  // CHECK_TEST_CRASHES

}  // namespace
}  // namespace pw::stream