ntp_time_util_unittest.cc (5929B)
1 /* 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 #include "modules/rtp_rtcp/source/ntp_time_util.h" 11 12 #include <cstdint> 13 #include <limits> 14 15 #include "api/units/time_delta.h" 16 #include "system_wrappers/include/ntp_time.h" 17 #include "test/gtest.h" 18 19 namespace webrtc { 20 21 TEST(NtpTimeUtilTest, CompactNtp) { 22 const uint32_t kNtpSec = 0x12345678; 23 const uint32_t kNtpFrac = 0x23456789; 24 const NtpTime kNtp(kNtpSec, kNtpFrac); 25 const uint32_t kNtpMid = 0x56782345; 26 EXPECT_EQ(kNtpMid, CompactNtp(kNtp)); 27 } 28 29 TEST(NtpTimeUtilTest, CompactNtpIntervalToTimeDelta) { 30 const NtpTime ntp1(0x12345, 0x23456); 31 const NtpTime ntp2(0x12654, 0x64335); 32 int64_t ms_diff = ntp2.ToMs() - ntp1.ToMs(); 33 uint32_t ntp_diff = CompactNtp(ntp2) - CompactNtp(ntp1); 34 35 EXPECT_NEAR(CompactNtpIntervalToTimeDelta(ntp_diff).ms(), ms_diff, 1); 36 } 37 38 TEST(NtpTimeUtilTest, CompactNtpIntervalToTimeDeltaWithWrap) { 39 const NtpTime ntp1(0x1ffff, 0x23456); 40 const NtpTime ntp2(0x20000, 0x64335); 41 int64_t ms_diff = ntp2.ToMs() - ntp1.ToMs(); 42 43 // While ntp2 > ntp1, there compact ntp presentation happen to be opposite. 44 // That shouldn't be a problem as long as unsigned arithmetic is used. 45 ASSERT_GT(ntp2.ToMs(), ntp1.ToMs()); 46 ASSERT_LT(CompactNtp(ntp2), CompactNtp(ntp1)); 47 48 uint32_t ntp_diff = CompactNtp(ntp2) - CompactNtp(ntp1); 49 EXPECT_NEAR(CompactNtpIntervalToTimeDelta(ntp_diff).ms(), ms_diff, 1); 50 } 51 52 TEST(NtpTimeUtilTest, CompactNtpIntervalToTimeDeltaLarge) { 53 const NtpTime ntp1(0x10000, 0x00006); 54 const NtpTime ntp2(0x17fff, 0xffff5); 55 int64_t ms_diff = ntp2.ToMs() - ntp1.ToMs(); 56 // Ntp difference close to 2^15 seconds should convert correctly too. 57 ASSERT_NEAR(ms_diff, ((1 << 15) - 1) * 1000, 1); 58 uint32_t ntp_diff = CompactNtp(ntp2) - CompactNtp(ntp1); 59 EXPECT_NEAR(CompactNtpRttToTimeDelta(ntp_diff).ms(), ms_diff, 1); 60 } 61 62 TEST(NtpTimeUtilTest, CompactNtpIntervalToTimeDeltaNegative) { 63 const NtpTime ntp1(0x20000, 0x23456); 64 const NtpTime ntp2(0x1ffff, 0x64335); 65 int64_t ms_diff = ntp2.ToMs() - ntp1.ToMs(); 66 ASSERT_LT(ms_diff, 0); 67 // Ntp difference close to 2^16 seconds should be treated as negative. 68 uint32_t ntp_diff = CompactNtp(ntp2) - CompactNtp(ntp1); 69 EXPECT_NEAR(CompactNtpIntervalToTimeDelta(ntp_diff).ms(), ms_diff, 1); 70 } 71 72 TEST(NtpTimeUtilTest, CompactNtpIntervalToTimeDeltaBorderToNegative) { 73 // Both +0x8000 and -x0x8000 seconds can be valid result when converting value 74 // exactly in the middle. 75 EXPECT_EQ(CompactNtpIntervalToTimeDelta(0x8000'0000).Abs(), 76 TimeDelta::Seconds(0x8000)); 77 } 78 79 TEST(NtpTimeUtilTest, CompactNtpRttToTimeDeltaNegative) { 80 const NtpTime ntp1(0x20000, 0x23456); 81 const NtpTime ntp2(0x1ffff, 0x64335); 82 int64_t ms_diff = ntp2.ToMs() - ntp1.ToMs(); 83 ASSERT_LT(ms_diff, 0); 84 // Ntp difference close to 2^16 seconds should be treated as negative. 85 uint32_t ntp_diff = CompactNtp(ntp2) - CompactNtp(ntp1); 86 EXPECT_EQ(CompactNtpRttToTimeDelta(ntp_diff), TimeDelta::Millis(1)); 87 } 88 89 TEST(NtpTimeUtilTest, SaturatedToCompactNtp) { 90 // Converts negative to zero. 91 EXPECT_EQ(SaturatedToCompactNtp(TimeDelta::Micros(-1)), 0u); 92 EXPECT_EQ(SaturatedToCompactNtp(TimeDelta::Zero()), 0u); 93 // Converts values just above and just below max uint32_t. 94 EXPECT_EQ(SaturatedToCompactNtp(TimeDelta::Micros(65536000000)), 0xffffffff); 95 EXPECT_EQ(SaturatedToCompactNtp(TimeDelta::Micros(65535999985)), 0xffffffff); 96 EXPECT_EQ(SaturatedToCompactNtp(TimeDelta::Micros(65535999970)), 0xfffffffe); 97 // Converts half-seconds. 98 EXPECT_EQ(SaturatedToCompactNtp(TimeDelta::Millis(500)), 0x8000u); 99 EXPECT_EQ(SaturatedToCompactNtp(TimeDelta::Seconds(1)), 0x10000u); 100 EXPECT_EQ(SaturatedToCompactNtp(TimeDelta::Millis(1'500)), 0x18000u); 101 // Convert us -> compact_ntp -> TimeDelta. Compact ntp precision is ~15us. 102 EXPECT_NEAR( 103 CompactNtpRttToTimeDelta(SaturatedToCompactNtp(TimeDelta::Micros(1'516))) 104 .us(), 105 1'516, 16); 106 EXPECT_NEAR( 107 CompactNtpRttToTimeDelta(SaturatedToCompactNtp(TimeDelta::Millis(15))) 108 .us(), 109 15'000, 16); 110 EXPECT_NEAR( 111 CompactNtpRttToTimeDelta(SaturatedToCompactNtp(TimeDelta::Micros(5'485))) 112 .us(), 113 5'485, 16); 114 EXPECT_NEAR( 115 CompactNtpRttToTimeDelta(SaturatedToCompactNtp(TimeDelta::Micros(5'515))) 116 .us(), 117 5'515, 16); 118 } 119 120 TEST(NtpTimeUtilTest, ToNtpUnits) { 121 EXPECT_EQ(ToNtpUnits(TimeDelta::Zero()), 0); 122 EXPECT_EQ(ToNtpUnits(TimeDelta::Seconds(1)), int64_t{1} << 32); 123 EXPECT_EQ(ToNtpUnits(TimeDelta::Seconds(-1)), -(int64_t{1} << 32)); 124 125 EXPECT_EQ(ToNtpUnits(TimeDelta::Millis(500)), int64_t{1} << 31); 126 EXPECT_EQ(ToNtpUnits(TimeDelta::Millis(-1'500)), -(int64_t{3} << 31)); 127 128 // Smallest TimeDelta that can be converted without precision loss. 129 EXPECT_EQ(ToNtpUnits(TimeDelta::Micros(15'625)), int64_t{1} << 26); 130 131 // 1 us ~= 4'294.97 NTP units. ToNtpUnits makes no rounding promises. 132 EXPECT_GE(ToNtpUnits(TimeDelta::Micros(1)), 4'294); 133 EXPECT_LE(ToNtpUnits(TimeDelta::Micros(1)), 4'295); 134 135 // Test near maximum and minimum supported values. 136 static constexpr int64_t k35MinutesInNtpUnits = int64_t{35 * 60} << 32; 137 EXPECT_EQ(ToNtpUnits(TimeDelta::Seconds(35 * 60)), k35MinutesInNtpUnits); 138 EXPECT_EQ(ToNtpUnits(TimeDelta::Seconds(-35 * 60)), -k35MinutesInNtpUnits); 139 140 // The result for too large or too small values is unspecified, but 141 // shouldn't cause integer overflow or other undefined behavior. 142 ToNtpUnits(TimeDelta::Micros(std::numeric_limits<int64_t>::max() - 1)); 143 ToNtpUnits(TimeDelta::Micros(std::numeric_limits<int64_t>::min() + 1)); 144 } 145 146 } // namespace webrtc