| // 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 <assert.h> |
| #include <lib/fzl/fifo.h> |
| #include <lib/fzl/time.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <zircon/syscalls.h> |
| |
| #include <algorithm> |
| #include <utility> |
| |
| #include <fbl/algorithm.h> |
| #include <zxtest/zxtest.h> |
| |
| namespace { |
| |
| template <typename T> |
| void AlmostEqual(T t0, T t1, T e) { |
| ASSERT_TRUE(std::min(t0, t1) + e >= std::max(t0, t1), "%zu != %zu (within error of %zu)", t0, t1, |
| e); |
| } |
| |
| void TickConverter(zx::ticks ticks, zx::ticks err) { |
| ASSERT_NO_FATAL_FAILURE( |
| AlmostEqual(ticks.get(), fzl::NsToTicks(fzl::TicksToNs(ticks)).get(), err.get())); |
| ASSERT_NO_FATAL_FAILURE( |
| AlmostEqual(ticks.get(), ns_to_ticks(ticks_to_ns(ticks.get())), err.get())); |
| } |
| |
| void NsConverter(zx::duration ns, zx::duration err) { |
| ASSERT_NO_FATAL_FAILURE( |
| AlmostEqual(ns.get(), fzl::TicksToNs(fzl::NsToTicks(ns)).get(), err.get())); |
| ASSERT_NO_FATAL_FAILURE(AlmostEqual(ns.get(), ticks_to_ns(ns_to_ticks(ns.get())), err.get())); |
| } |
| |
| TEST(LibfzlTests, TimeTest) { |
| zx::ticks tps = zx::ticks::per_second(); |
| zx::duration nps = zx::sec(1); |
| |
| // The following tests check converting from: |
| // - ticks --> nanoseconds --> ticks |
| // - nanoseconds --> ticks --> nanoseconds |
| // |
| // This conversion is inherently lossy if the number of ticks/ns (or |
| // ns/tick) is not an exact integer -- which is almost always the case. |
| // |
| // To convert N nanoseconds to ticks, we'd logically multiply by |
| // "ticks/sec" / "ns/second". However, by converting N into the ticks |
| // equivalent T, we may be losing the fractional component of this number: N |
| // may actually be represented by T +/- a partial tick. |
| // |
| // In most situations, where ticks are higher precision than nanoseconds, |
| // there will actually be even more loss in the other direction: when |
| // converting from ticks to nanoseconds, we may potentially lose as many as |
| // "ticks/second / ns/second" ticks. |
| // |
| // To ensure our error margins account for this loss, where we lose |
| // minimally a "partial unit" and maximally an integer ratio of the units, |
| // we calculate acceptable loss as: |
| // |
| // loss = max(1 + ratio, 1) |
| // |
| // Where we add one to the ratio to "round up to the nearest integer ratio" while |
| // doing the conversion. |
| zx::ticks tick_loss = std::max(zx::ticks(1 + (tps.get() / nps.get())), zx::ticks(1)); |
| zx::duration duration_loss = std::max(zx::duration(1 + (nps.get() / tps.get())), zx::duration(1)); |
| |
| ASSERT_NO_FATAL_FAILURE(TickConverter(zx::ticks(0), zx::ticks(0))); |
| ASSERT_NO_FATAL_FAILURE(TickConverter(zx::ticks(50), tick_loss)); |
| ASSERT_NO_FATAL_FAILURE(TickConverter(zx::ticks(100), tick_loss)); |
| ASSERT_NO_FATAL_FAILURE(TickConverter(zx::ticks(100000), tick_loss)); |
| ASSERT_NO_FATAL_FAILURE(TickConverter(zx::ticks(1000000000), tick_loss)); |
| ASSERT_NO_FATAL_FAILURE(TickConverter(zx::ticks(10000000000000), tick_loss)); |
| |
| ASSERT_NO_FATAL_FAILURE(NsConverter(zx::duration(0), zx::duration(0))); |
| ASSERT_NO_FATAL_FAILURE(NsConverter(zx::duration(50), duration_loss)); |
| ASSERT_NO_FATAL_FAILURE(NsConverter(zx::duration(100), duration_loss)); |
| ASSERT_NO_FATAL_FAILURE(NsConverter(zx::duration(100000), duration_loss)); |
| ASSERT_NO_FATAL_FAILURE(NsConverter(zx::duration(1000000000), duration_loss)); |
| ASSERT_NO_FATAL_FAILURE(NsConverter(zx::duration(10000000000000), duration_loss)); |
| } |
| |
| TEST(LibfzlTests, FifoTest) { |
| // Default constructor |
| { |
| fzl::fifo<int> invalid; |
| ASSERT_EQ(invalid.get_handle(), ZX_HANDLE_INVALID); |
| } |
| |
| // Move constructors, reset() and release() |
| { |
| zx::fifo zx_fifo_0, zx_fifo_1; |
| zx_status_t status = zx::fifo::create(4, 4, 0, &zx_fifo_0, &zx_fifo_1); |
| ASSERT_EQ(status, ZX_OK); |
| zx_handle_t handle_0 = zx_fifo_0.get(); |
| ASSERT_NE(handle_0, ZX_HANDLE_INVALID); |
| |
| fzl::fifo<int> moved_fifo(std::move(zx_fifo_0)); |
| ASSERT_EQ(moved_fifo.get_handle(), handle_0); |
| ASSERT_EQ(zx_fifo_0.get(), ZX_HANDLE_INVALID); |
| |
| fzl::fifo<int> moved_again(std::move(moved_fifo)); |
| ASSERT_EQ(moved_again.get_handle(), handle_0); |
| ASSERT_EQ(moved_fifo.get_handle(), ZX_HANDLE_INVALID); |
| |
| zx::handle opaque_handle(moved_again.release()); |
| fzl::fifo<int> from_opaque(std::move(opaque_handle)); |
| ASSERT_EQ(from_opaque.get_handle(), handle_0); |
| ASSERT_EQ(opaque_handle.get(), ZX_HANDLE_INVALID); |
| |
| from_opaque.reset(); |
| ASSERT_EQ(from_opaque.get_handle(), ZX_HANDLE_INVALID); |
| } |
| |
| // Create, read, write |
| |
| fzl::fifo<int64_t, char[8]> fifo_0; |
| fzl::fifo<char[8], int64_t> fifo_1; |
| |
| { |
| zx_status_t status = fzl::create_fifo(4, 0, &fifo_0, &fifo_1); |
| ASSERT_EQ(status, ZX_OK); |
| } |
| |
| { |
| const int64_t numbers[2] = {10, -20}; |
| size_t actual = 0; |
| zx_status_t status = fifo_0.write(numbers, 2, &actual); |
| ASSERT_EQ(status, ZX_OK); |
| ASSERT_EQ(actual, 2); |
| } |
| |
| { |
| int64_t numbers[3] = {0, 0, 0}; |
| size_t actual = 0; |
| zx_status_t status = fifo_1.read(numbers, 3, &actual); |
| ASSERT_EQ(status, ZX_OK); |
| ASSERT_EQ(actual, 2); |
| ASSERT_EQ(numbers[0], 10); |
| ASSERT_EQ(numbers[1], -20); |
| } |
| |
| { |
| char str[8] = "hi fifo"; |
| zx_status_t status = fifo_1.write_one(str); |
| ASSERT_EQ(status, ZX_OK); |
| } |
| |
| { |
| char str[8] = "......."; |
| zx_status_t status = fifo_0.read_one(&str); |
| ASSERT_EQ(status, ZX_OK); |
| ASSERT_STREQ("hi fifo", str); |
| } |
| |
| // Signal & wait_one |
| { |
| fifo_0.signal(0, ZX_USER_SIGNAL_0); |
| zx_signals_t pending = 0; |
| fifo_0.wait_one(ZX_USER_SIGNAL_0, zx::deadline_after(zx::sec(1)), &pending); |
| ASSERT_TRUE(pending & ZX_USER_SIGNAL_0); |
| } |
| |
| // Replace |
| { |
| fzl::fifo<int64_t, char[8]> replaced; |
| fifo_0.replace(0, &replaced); |
| ASSERT_EQ(fifo_0.get_handle(), ZX_HANDLE_INVALID); |
| ASSERT_NE(replaced.get_handle(), ZX_HANDLE_INVALID); |
| } |
| } |
| |
| } // namespace |