LedgerTiming.cpp

#include <xrpl/ledger/LedgerTiming.h>
 
#include <xrpl/basics/chrono.h>
 
#include <gtest/gtest.h>
 
#include <chrono>
#include <cstdint>
#include <utility>
 
namespace xrpl::test {
 
TEST(LedgerTimingTest, get_next_ledger_time_resolution)
{
    // helper to iteratively call into getNextLedgerTimeResolution
    struct TestRes
    {
        std::uint32_t decrease = 0;
        std::uint32_t equal = 0;
        std::uint32_t increase = 0;
 
        static TestRes
        run(bool previousAgree, std::uint32_t rounds)
        {
            TestRes res;
            auto closeResolution = kLedgerDefaultTimeResolution;
            auto nextCloseResolution = closeResolution;
            std::uint32_t round = 0;
            do
            {
                nextCloseResolution =
                    getNextLedgerTimeResolution(closeResolution, previousAgree, ++round);
                if (nextCloseResolution < closeResolution)
                {
                    ++res.decrease;
                }
                else if (nextCloseResolution > closeResolution)
                {
                    ++res.increase;
                }
                else
                {
                    ++res.equal;
                }
                std::swap(nextCloseResolution, closeResolution);
            } while (round < rounds);
            return res;
        }
    };
 
    // If we never agree on close time, only can increase resolution
    // until hit the max
    auto decreases = TestRes::run(false, 10);
    EXPECT_TRUE(decreases.increase == 3);
    EXPECT_TRUE(decreases.decrease == 0);
    EXPECT_TRUE(decreases.equal == 7);
 
    // If we always agree on close time, only can decrease resolution
    // until hit the min
    auto increases = TestRes::run(false, 100);
    EXPECT_TRUE(increases.increase == 3);
    EXPECT_TRUE(increases.decrease == 0);
    EXPECT_TRUE(increases.equal == 97);
}
 
TEST(LedgerTimingTest, round_close_time)
{
    using namespace std::chrono_literals;
    // A closeTime equal to the epoch is not modified
    using Tp = NetClock::time_point;
    Tp const def;
    EXPECT_TRUE(def == roundCloseTime(def, 30s));
 
    // Otherwise, the closeTime is rounded to the nearest
    // rounding up on ties
    EXPECT_TRUE(Tp{0s} == roundCloseTime(Tp{29s}, 60s));
    EXPECT_TRUE(Tp{30s} == roundCloseTime(Tp{30s}, 1s));
    EXPECT_TRUE(Tp{60s} == roundCloseTime(Tp{31s}, 60s));
    EXPECT_TRUE(Tp{60s} == roundCloseTime(Tp{30s}, 60s));
    EXPECT_TRUE(Tp{60s} == roundCloseTime(Tp{59s}, 60s));
    EXPECT_TRUE(Tp{60s} == roundCloseTime(Tp{60s}, 60s));
    EXPECT_TRUE(Tp{60s} == roundCloseTime(Tp{61s}, 60s));
}
 
TEST(LedgerTimingTest, eff_close_time)
{
    using namespace std::chrono_literals;
    using Tp = NetClock::time_point;
    Tp close = effCloseTime(Tp{10s}, 30s, Tp{0s});
    EXPECT_TRUE(close == Tp{1s});
 
    close = effCloseTime(Tp{16s}, 30s, Tp{0s});
    EXPECT_TRUE(close == Tp{30s});
 
    close = effCloseTime(Tp{16s}, 30s, Tp{30s});
    EXPECT_TRUE(close == Tp{31s});
 
    close = effCloseTime(Tp{16s}, 30s, Tp{60s});
    EXPECT_TRUE(close == Tp{61s});
 
    close = effCloseTime(Tp{31s}, 30s, Tp{0s});
    EXPECT_TRUE(close == Tp{30s});
}
 
}  // namespace xrpl::test