• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17import {TimestampConverterUtils} from 'test/unit/timestamp_converter_utils';
18import {TimeRange} from './time';
19import {TIME_UNIT_TO_NANO} from './time_units';
20
21describe('Timestamp', () => {
22  describe('arithmetic', () => {
23    const REAL_TIMESTAMP_10 = TimestampConverterUtils.makeRealTimestamp(10n);
24    const REAL_TIMESTAMP_20 = TimestampConverterUtils.makeRealTimestamp(20n);
25    const ELAPSED_TIMESTAMP_10 =
26      TimestampConverterUtils.makeElapsedTimestamp(10n);
27    const ELAPSED_TIMESTAMP_20 =
28      TimestampConverterUtils.makeElapsedTimestamp(20n);
29
30    it('can add', () => {
31      let timestamp = REAL_TIMESTAMP_10.add(REAL_TIMESTAMP_20.getValueNs());
32      expect(timestamp.getValueNs()).toBe(30n);
33
34      timestamp = ELAPSED_TIMESTAMP_10.add(ELAPSED_TIMESTAMP_20.getValueNs());
35      expect(timestamp.getValueNs()).toBe(30n);
36    });
37
38    it('can subtract', () => {
39      let timestamp = REAL_TIMESTAMP_20.minus(REAL_TIMESTAMP_10.getValueNs());
40      expect(timestamp.getValueNs()).toBe(10n);
41
42      timestamp = ELAPSED_TIMESTAMP_20.minus(ELAPSED_TIMESTAMP_10.getValueNs());
43      expect(timestamp.getValueNs()).toBe(10n);
44    });
45
46    it('can divide', () => {
47      let timestamp = TimestampConverterUtils.makeRealTimestamp(10n).div(2n);
48      expect(timestamp.getValueNs()).toBe(5n);
49
50      timestamp = ELAPSED_TIMESTAMP_10.div(2n);
51      expect(timestamp.getValueNs()).toBe(5n);
52    });
53  });
54
55  describe('formatting', () => {
56    const MILLISECOND = BigInt(TIME_UNIT_TO_NANO.ms);
57    const SECOND = BigInt(TIME_UNIT_TO_NANO.s);
58    const MINUTE = BigInt(TIME_UNIT_TO_NANO.m);
59    const HOUR = BigInt(TIME_UNIT_TO_NANO.h);
60    const DAY = BigInt(TIME_UNIT_TO_NANO.d);
61
62    it('elapsed timestamps', () => {
63      expect(TimestampConverterUtils.makeElapsedTimestamp(0n).format()).toEqual(
64        '0ns',
65      );
66      expect(
67        TimestampConverterUtils.makeElapsedTimestamp(1000n).format(),
68      ).toEqual('1000ns');
69      expect(
70        TimestampConverterUtils.makeElapsedTimestamp(
71          10n * MILLISECOND,
72        ).format(),
73      ).toEqual('10ms0ns');
74
75      expect(
76        TimestampConverterUtils.makeElapsedTimestamp(SECOND - 1n).format(),
77      ).toEqual('999ms999999ns');
78      expect(
79        TimestampConverterUtils.makeElapsedTimestamp(SECOND).format(),
80      ).toEqual('1s0ms0ns');
81      expect(
82        TimestampConverterUtils.makeElapsedTimestamp(
83          SECOND + MILLISECOND,
84        ).format(),
85      ).toEqual('1s1ms0ns');
86
87      expect(
88        TimestampConverterUtils.makeElapsedTimestamp(MINUTE - 1n).format(),
89      ).toEqual('59s999ms999999ns');
90      expect(
91        TimestampConverterUtils.makeElapsedTimestamp(MINUTE).format(),
92      ).toEqual('1m0s0ms0ns');
93      expect(
94        TimestampConverterUtils.makeElapsedTimestamp(
95          MINUTE + SECOND + MILLISECOND,
96        ).format(),
97      ).toEqual('1m1s1ms0ns');
98      expect(
99        TimestampConverterUtils.makeElapsedTimestamp(
100          MINUTE + SECOND + MILLISECOND + 1n,
101        ).format(),
102      ).toEqual('1m1s1ms1ns');
103
104      expect(
105        TimestampConverterUtils.makeElapsedTimestamp(HOUR - 1n).format(),
106      ).toEqual('59m59s999ms999999ns');
107      expect(
108        TimestampConverterUtils.makeElapsedTimestamp(HOUR).format(),
109      ).toEqual('1h0m0s0ms0ns');
110      expect(
111        TimestampConverterUtils.makeElapsedTimestamp(
112          HOUR + MINUTE + SECOND + MILLISECOND,
113        ).format(),
114      ).toEqual('1h1m1s1ms0ns');
115
116      expect(
117        TimestampConverterUtils.makeElapsedTimestamp(DAY - 1n).format(),
118      ).toEqual('23h59m59s999ms999999ns');
119      expect(
120        TimestampConverterUtils.makeElapsedTimestamp(DAY).format(),
121      ).toEqual('1d0h0m0s0ms0ns');
122      expect(
123        TimestampConverterUtils.makeElapsedTimestamp(
124          DAY + HOUR + MINUTE + SECOND + MILLISECOND,
125        ).format(),
126      ).toEqual('1d1h1m1s1ms0ns');
127    });
128
129    it('real timestamps without timezone info', () => {
130      const NOV_10_2022 = 1668038400000n * MILLISECOND;
131      expect(TimestampConverterUtils.makeRealTimestamp(0n).format()).toEqual(
132        '1970-01-01, 00:00:00.000',
133      );
134      expect(
135        TimestampConverterUtils.makeRealTimestamp(
136          NOV_10_2022 +
137            22n * HOUR +
138            4n * MINUTE +
139            54n * SECOND +
140            186n * MILLISECOND +
141            123212n,
142        ).format(),
143      ).toEqual('2022-11-10, 22:04:54.186');
144      expect(
145        TimestampConverterUtils.makeRealTimestamp(NOV_10_2022).format(),
146      ).toEqual('2022-11-10, 00:00:00.000');
147      expect(
148        TimestampConverterUtils.makeRealTimestamp(NOV_10_2022 + 1n).format(),
149      ).toEqual('2022-11-10, 00:00:00.000');
150
151      expect(TimestampConverterUtils.makeRealTimestamp(0n).format()).toEqual(
152        '1970-01-01, 00:00:00.000',
153      );
154      expect(
155        TimestampConverterUtils.makeRealTimestamp(
156          NOV_10_2022 +
157            22n * HOUR +
158            4n * MINUTE +
159            54n * SECOND +
160            186n * MILLISECOND +
161            123212n,
162        ).format(),
163      ).toEqual('2022-11-10, 22:04:54.186');
164      expect(
165        TimestampConverterUtils.makeRealTimestamp(NOV_10_2022).format(),
166      ).toEqual('2022-11-10, 00:00:00.000');
167      expect(
168        TimestampConverterUtils.makeRealTimestamp(NOV_10_2022 + 1n).format(),
169      ).toEqual('2022-11-10, 00:00:00.000');
170    });
171
172    it('real timestamps with timezone info', () => {
173      const NOV_10_2022 = 1668038400000n * MILLISECOND;
174      expect(
175        TimestampConverterUtils.TIMESTAMP_CONVERTER_WITH_UTC_OFFSET.makeTimestampFromRealNs(
176          0n,
177        ).format(),
178      ).toEqual('1970-01-01, 05:30:00.000');
179      expect(
180        TimestampConverterUtils.TIMESTAMP_CONVERTER_WITH_UTC_OFFSET.makeTimestampFromRealNs(
181          NOV_10_2022 +
182            22n * HOUR +
183            4n * MINUTE +
184            54n * SECOND +
185            186n * MILLISECOND +
186            123212n,
187        ).format(),
188      ).toEqual('2022-11-11, 03:34:54.186');
189      expect(
190        TimestampConverterUtils.TIMESTAMP_CONVERTER_WITH_UTC_OFFSET.makeTimestampFromRealNs(
191          NOV_10_2022,
192        ).format(),
193      ).toEqual('2022-11-10, 05:30:00.000');
194      expect(
195        TimestampConverterUtils.TIMESTAMP_CONVERTER_WITH_UTC_OFFSET.makeTimestampFromRealNs(
196          NOV_10_2022 + 1n,
197        ).format(),
198      ).toEqual('2022-11-10, 05:30:00.000');
199
200      expect(
201        TimestampConverterUtils.TIMESTAMP_CONVERTER_WITH_UTC_OFFSET.makeTimestampFromRealNs(
202          0n,
203        ).format(),
204      ).toEqual('1970-01-01, 05:30:00.000');
205      expect(
206        TimestampConverterUtils.TIMESTAMP_CONVERTER_WITH_UTC_OFFSET.makeTimestampFromRealNs(
207          NOV_10_2022 +
208            22n * HOUR +
209            4n * MINUTE +
210            54n * SECOND +
211            186n * MILLISECOND +
212            123212n,
213        ).format(),
214      ).toEqual('2022-11-11, 03:34:54.186');
215      expect(
216        TimestampConverterUtils.TIMESTAMP_CONVERTER_WITH_UTC_OFFSET.makeTimestampFromRealNs(
217          NOV_10_2022,
218        ).format(),
219      ).toEqual('2022-11-10, 05:30:00.000');
220      expect(
221        TimestampConverterUtils.TIMESTAMP_CONVERTER_WITH_UTC_OFFSET.makeTimestampFromRealNs(
222          NOV_10_2022 + 1n,
223        ).format(),
224      ).toEqual('2022-11-10, 05:30:00.000');
225    });
226  });
227});
228
229describe('TimeRange', () => {
230  describe('containsTimestamp', () => {
231    const range = new TimeRange(
232      TimestampConverterUtils.TIMESTAMP_CONVERTER.makeTimestampFromNs(10n),
233      TimestampConverterUtils.TIMESTAMP_CONVERTER.makeTimestampFromNs(600n),
234    );
235
236    it('returns true for range containing timestamp', () => {
237      expect(
238        range.containsTimestamp(
239          TimestampConverterUtils.TIMESTAMP_CONVERTER.makeTimestampFromNs(10n),
240        ),
241      ).toBeTrue();
242
243      expect(
244        range.containsTimestamp(
245          TimestampConverterUtils.TIMESTAMP_CONVERTER.makeTimestampFromNs(600n),
246        ),
247      ).toBeTrue();
248
249      expect(
250        range.containsTimestamp(
251          TimestampConverterUtils.TIMESTAMP_CONVERTER.makeTimestampFromNs(300n),
252        ),
253      ).toBeTrue();
254    });
255
256    it('returns false for range not containing timestamp', () => {
257      expect(
258        range.containsTimestamp(
259          TimestampConverterUtils.TIMESTAMP_CONVERTER.makeTimestampFromNs(0n),
260        ),
261      ).toBeFalse();
262
263      expect(
264        range.containsTimestamp(
265          TimestampConverterUtils.TIMESTAMP_CONVERTER.makeTimestampFromNs(601n),
266        ),
267      ).toBeFalse();
268    });
269  });
270});
271