Skip to content

Commit a683736

Browse files
jacobsacopybara-github
jacobsa
authored and
copybara-github
committed
absl/time: format code with clang-format.
PiperOrigin-RevId: 815558214 Change-Id: I6cd0c73d929a0f17bddb1b014d132eab845c3da1
1 parent 0c01ee1 commit a683736

File tree

8 files changed

+109
-157
lines changed

8 files changed

+109
-157
lines changed

‎absl/time/civil_time_benchmark.cc‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -12,14 +12,13 @@
1212
// See the License for the specific language governing permissions and
1313
// limitations under the License.
1414

15-
#include "absl/time/civil_time.h"
16-
1715
#include <cstddef>
1816
#include <numeric>
1917
#include <string>
2018
#include <vector>
2119

2220
#include "absl/hash/hash.h"
21+
#include "absl/time/civil_time.h"
2322
#include "benchmark/benchmark.h"
2423

2524
namespace {

‎absl/time/civil_time_test.cc‎

Lines changed: 58 additions & 103 deletions
Original file line numberDiff line numberDiff line change
@@ -78,8 +78,7 @@ TEST(CivilTime, FieldsConstruction) {
7878
absl::FormatCivilTime(absl::CivilMinute(2015, 1, 2)));
7979
EXPECT_EQ("2015-01-01T00:00",
8080
absl::FormatCivilTime(absl::CivilMinute(2015, 1)));
81-
EXPECT_EQ("2015-01-01T00:00",
82-
absl::FormatCivilTime(absl::CivilMinute(2015)));
81+
EXPECT_EQ("2015-01-01T00:00", absl::FormatCivilTime(absl::CivilMinute(2015)));
8382

8483
EXPECT_EQ("2015-01-02T03",
8584
absl::FormatCivilTime(absl::CivilHour(2015, 1, 2, 3, 4, 5)));
@@ -89,82 +88,63 @@ TEST(CivilTime, FieldsConstruction) {
8988
absl::FormatCivilTime(absl::CivilHour(2015, 1, 2, 3)));
9089
EXPECT_EQ("2015-01-02T00",
9190
absl::FormatCivilTime(absl::CivilHour(2015, 1, 2)));
92-
EXPECT_EQ("2015-01-01T00",
93-
absl::FormatCivilTime(absl::CivilHour(2015, 1)));
94-
EXPECT_EQ("2015-01-01T00",
95-
absl::FormatCivilTime(absl::CivilHour(2015)));
91+
EXPECT_EQ("2015-01-01T00", absl::FormatCivilTime(absl::CivilHour(2015, 1)));
92+
EXPECT_EQ("2015-01-01T00", absl::FormatCivilTime(absl::CivilHour(2015)));
9693

9794
EXPECT_EQ("2015-01-02",
9895
absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3, 4, 5)));
9996
EXPECT_EQ("2015-01-02",
10097
absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3, 4)));
101-
EXPECT_EQ("2015-01-02",
102-
absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3)));
103-
EXPECT_EQ("2015-01-02",
104-
absl::FormatCivilTime(absl::CivilDay(2015, 1, 2)));
105-
EXPECT_EQ("2015-01-01",
106-
absl::FormatCivilTime(absl::CivilDay(2015, 1)));
107-
EXPECT_EQ("2015-01-01",
108-
absl::FormatCivilTime(absl::CivilDay(2015)));
98+
EXPECT_EQ("2015-01-02", absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3)));
99+
EXPECT_EQ("2015-01-02", absl::FormatCivilTime(absl::CivilDay(2015, 1, 2)));
100+
EXPECT_EQ("2015-01-01", absl::FormatCivilTime(absl::CivilDay(2015, 1)));
101+
EXPECT_EQ("2015-01-01", absl::FormatCivilTime(absl::CivilDay(2015)));
109102

110103
EXPECT_EQ("2015-01",
111104
absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3, 4, 5)));
112105
EXPECT_EQ("2015-01",
113106
absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3, 4)));
114-
EXPECT_EQ("2015-01",
115-
absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3)));
116-
EXPECT_EQ("2015-01",
117-
absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2)));
118-
EXPECT_EQ("2015-01",
119-
absl::FormatCivilTime(absl::CivilMonth(2015, 1)));
120-
EXPECT_EQ("2015-01",
121-
absl::FormatCivilTime(absl::CivilMonth(2015)));
107+
EXPECT_EQ("2015-01", absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3)));
108+
EXPECT_EQ("2015-01", absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2)));
109+
EXPECT_EQ("2015-01", absl::FormatCivilTime(absl::CivilMonth(2015, 1)));
110+
EXPECT_EQ("2015-01", absl::FormatCivilTime(absl::CivilMonth(2015)));
122111

123112
EXPECT_EQ("2015",
124113
absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3, 4, 5)));
125-
EXPECT_EQ("2015",
126-
absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3, 4)));
127-
EXPECT_EQ("2015",
128-
absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3)));
129-
EXPECT_EQ("2015",
130-
absl::FormatCivilTime(absl::CivilYear(2015, 1, 2)));
131-
EXPECT_EQ("2015",
132-
absl::FormatCivilTime(absl::CivilYear(2015, 1)));
133-
EXPECT_EQ("2015",
134-
absl::FormatCivilTime(absl::CivilYear(2015)));
114+
EXPECT_EQ("2015", absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3, 4)));
115+
EXPECT_EQ("2015", absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3)));
116+
EXPECT_EQ("2015", absl::FormatCivilTime(absl::CivilYear(2015, 1, 2)));
117+
EXPECT_EQ("2015", absl::FormatCivilTime(absl::CivilYear(2015, 1)));
118+
EXPECT_EQ("2015", absl::FormatCivilTime(absl::CivilYear(2015)));
135119
}
136120

137121
TEST(CivilTime, FieldsConstructionLimits) {
138122
const int kIntMax = std::numeric_limits<int>::max();
139-
EXPECT_EQ("2038-01-19T03:14:07",
140-
absl::FormatCivilTime(absl::CivilSecond(
141-
1970, 1, 1, 0, 0, kIntMax)));
142-
EXPECT_EQ("6121-02-11T05:21:07",
143-
absl::FormatCivilTime(absl::CivilSecond(
144-
1970, 1, 1, 0, kIntMax, kIntMax)));
123+
EXPECT_EQ("2038-01-19T03:14:07", absl::FormatCivilTime(absl::CivilSecond(
124+
1970, 1, 1, 0, 0, kIntMax)));
125+
EXPECT_EQ("6121-02-11T05:21:07", absl::FormatCivilTime(absl::CivilSecond(
126+
1970, 1, 1, 0, kIntMax, kIntMax)));
145127
EXPECT_EQ("251104-11-20T12:21:07",
146-
absl::FormatCivilTime(absl::CivilSecond(
147-
1970, 1, 1, kIntMax, kIntMax, kIntMax)));
128+
absl::FormatCivilTime(
129+
absl::CivilSecond(1970, 1, 1, kIntMax, kIntMax, kIntMax)));
148130
EXPECT_EQ("6130715-05-30T12:21:07",
149-
absl::FormatCivilTime(absl::CivilSecond(
150-
1970, 1, kIntMax, kIntMax, kIntMax, kIntMax)));
131+
absl::FormatCivilTime(absl::CivilSecond(1970, 1, kIntMax, kIntMax,
132+
kIntMax, kIntMax)));
151133
EXPECT_EQ("185087685-11-26T12:21:07",
152134
absl::FormatCivilTime(absl::CivilSecond(
153135
1970, kIntMax, kIntMax, kIntMax, kIntMax, kIntMax)));
154136

155137
const int kIntMin = std::numeric_limits<int>::min();
156-
EXPECT_EQ("1901-12-13T20:45:52",
157-
absl::FormatCivilTime(absl::CivilSecond(
158-
1970, 1, 1, 0, 0, kIntMin)));
159-
EXPECT_EQ("-2182-11-20T18:37:52",
160-
absl::FormatCivilTime(absl::CivilSecond(
161-
1970, 1, 1, 0, kIntMin, kIntMin)));
138+
EXPECT_EQ("1901-12-13T20:45:52", absl::FormatCivilTime(absl::CivilSecond(
139+
1970, 1, 1, 0, 0, kIntMin)));
140+
EXPECT_EQ("-2182-11-20T18:37:52", absl::FormatCivilTime(absl::CivilSecond(
141+
1970, 1, 1, 0, kIntMin, kIntMin)));
162142
EXPECT_EQ("-247165-02-11T10:37:52",
163-
absl::FormatCivilTime(absl::CivilSecond(
164-
1970, 1, 1, kIntMin, kIntMin, kIntMin)));
143+
absl::FormatCivilTime(
144+
absl::CivilSecond(1970, 1, 1, kIntMin, kIntMin, kIntMin)));
165145
EXPECT_EQ("-6126776-08-01T10:37:52",
166-
absl::FormatCivilTime(absl::CivilSecond(
167-
1970, 1, kIntMin, kIntMin, kIntMin, kIntMin)));
146+
absl::FormatCivilTime(absl::CivilSecond(1970, 1, kIntMin, kIntMin,
147+
kIntMin, kIntMin)));
168148
EXPECT_EQ("-185083747-10-31T10:37:52",
169149
absl::FormatCivilTime(absl::CivilSecond(
170150
1970, kIntMin, kIntMin, kIntMin, kIntMin, kIntMin)));
@@ -173,31 +153,22 @@ TEST(CivilTime, FieldsConstructionLimits) {
173153
TEST(CivilTime, RangeLimits) {
174154
const absl::civil_year_t kYearMax =
175155
std::numeric_limits<absl::civil_year_t>::max();
176-
EXPECT_EQ(absl::CivilYear(kYearMax),
177-
absl::CivilYear::max());
178-
EXPECT_EQ(absl::CivilMonth(kYearMax, 12),
179-
absl::CivilMonth::max());
180-
EXPECT_EQ(absl::CivilDay(kYearMax, 12, 31),
181-
absl::CivilDay::max());
182-
EXPECT_EQ(absl::CivilHour(kYearMax, 12, 31, 23),
183-
absl::CivilHour::max());
156+
EXPECT_EQ(absl::CivilYear(kYearMax), absl::CivilYear::max());
157+
EXPECT_EQ(absl::CivilMonth(kYearMax, 12), absl::CivilMonth::max());
158+
EXPECT_EQ(absl::CivilDay(kYearMax, 12, 31), absl::CivilDay::max());
159+
EXPECT_EQ(absl::CivilHour(kYearMax, 12, 31, 23), absl::CivilHour::max());
184160
EXPECT_EQ(absl::CivilMinute(kYearMax, 12, 31, 23, 59),
185161
absl::CivilMinute::max());
186162
EXPECT_EQ(absl::CivilSecond(kYearMax, 12, 31, 23, 59, 59),
187163
absl::CivilSecond::max());
188164

189165
const absl::civil_year_t kYearMin =
190166
std::numeric_limits<absl::civil_year_t>::min();
191-
EXPECT_EQ(absl::CivilYear(kYearMin),
192-
absl::CivilYear::min());
193-
EXPECT_EQ(absl::CivilMonth(kYearMin, 1),
194-
absl::CivilMonth::min());
195-
EXPECT_EQ(absl::CivilDay(kYearMin, 1, 1),
196-
absl::CivilDay::min());
197-
EXPECT_EQ(absl::CivilHour(kYearMin, 1, 1, 0),
198-
absl::CivilHour::min());
199-
EXPECT_EQ(absl::CivilMinute(kYearMin, 1, 1, 0, 0),
200-
absl::CivilMinute::min());
167+
EXPECT_EQ(absl::CivilYear(kYearMin), absl::CivilYear::min());
168+
EXPECT_EQ(absl::CivilMonth(kYearMin, 1), absl::CivilMonth::min());
169+
EXPECT_EQ(absl::CivilDay(kYearMin, 1, 1), absl::CivilDay::min());
170+
EXPECT_EQ(absl::CivilHour(kYearMin, 1, 1, 0), absl::CivilHour::min());
171+
EXPECT_EQ(absl::CivilMinute(kYearMin, 1, 1, 0, 0), absl::CivilMinute::min());
201172
EXPECT_EQ(absl::CivilSecond(kYearMin, 1, 1, 0, 0, 0),
202173
absl::CivilSecond::min());
203174
}
@@ -250,36 +221,28 @@ TEST(CivilTime, ImplicitCrossAlignment) {
250221
(std::is_convertible<absl::CivilSecond, absl::CivilMinute>::value));
251222
EXPECT_FALSE(
252223
(std::is_convertible<absl::CivilSecond, absl::CivilHour>::value));
253-
EXPECT_FALSE(
254-
(std::is_convertible<absl::CivilSecond, absl::CivilDay>::value));
224+
EXPECT_FALSE((std::is_convertible<absl::CivilSecond, absl::CivilDay>::value));
255225
EXPECT_FALSE(
256226
(std::is_convertible<absl::CivilSecond, absl::CivilMonth>::value));
257227
EXPECT_FALSE(
258228
(std::is_convertible<absl::CivilSecond, absl::CivilYear>::value));
259229

260230
EXPECT_FALSE(
261231
(std::is_convertible<absl::CivilMinute, absl::CivilHour>::value));
262-
EXPECT_FALSE(
263-
(std::is_convertible<absl::CivilMinute, absl::CivilDay>::value));
232+
EXPECT_FALSE((std::is_convertible<absl::CivilMinute, absl::CivilDay>::value));
264233
EXPECT_FALSE(
265234
(std::is_convertible<absl::CivilMinute, absl::CivilMonth>::value));
266235
EXPECT_FALSE(
267236
(std::is_convertible<absl::CivilMinute, absl::CivilYear>::value));
268237

269-
EXPECT_FALSE(
270-
(std::is_convertible<absl::CivilHour, absl::CivilDay>::value));
271-
EXPECT_FALSE(
272-
(std::is_convertible<absl::CivilHour, absl::CivilMonth>::value));
273-
EXPECT_FALSE(
274-
(std::is_convertible<absl::CivilHour, absl::CivilYear>::value));
238+
EXPECT_FALSE((std::is_convertible<absl::CivilHour, absl::CivilDay>::value));
239+
EXPECT_FALSE((std::is_convertible<absl::CivilHour, absl::CivilMonth>::value));
240+
EXPECT_FALSE((std::is_convertible<absl::CivilHour, absl::CivilYear>::value));
275241

276-
EXPECT_FALSE(
277-
(std::is_convertible<absl::CivilDay, absl::CivilMonth>::value));
278-
EXPECT_FALSE(
279-
(std::is_convertible<absl::CivilDay, absl::CivilYear>::value));
242+
EXPECT_FALSE((std::is_convertible<absl::CivilDay, absl::CivilMonth>::value));
243+
EXPECT_FALSE((std::is_convertible<absl::CivilDay, absl::CivilYear>::value));
280244

281-
EXPECT_FALSE(
282-
(std::is_convertible<absl::CivilMonth, absl::CivilYear>::value));
245+
EXPECT_FALSE((std::is_convertible<absl::CivilMonth, absl::CivilYear>::value));
283246
}
284247

285248
TEST(CivilTime, ExplicitCrossAlignment) {
@@ -417,8 +380,7 @@ TEST(CivilTime, Relational) {
417380
// Tests the relational operators of two different civil-time types.
418381
TEST_RELATIONAL(absl::CivilDay(2014, 1, 1),
419382
absl::CivilMinute(2014, 1, 1, 1, 1));
420-
TEST_RELATIONAL(absl::CivilDay(2014, 1, 1),
421-
absl::CivilMonth(2014, 2));
383+
TEST_RELATIONAL(absl::CivilDay(2014, 1, 1), absl::CivilMonth(2014, 2));
422384

423385
#undef TEST_RELATIONAL
424386
}
@@ -812,8 +774,7 @@ TEST(CivilTime, ParseEdgeCases) {
812774
EXPECT_EQ("-9223372036854775808-01-01T00:00", absl::FormatCivilTime(mm));
813775

814776
absl::CivilHour hh;
815-
EXPECT_TRUE(
816-
absl::ParseLenientCivilTime("9223372036854775807-12-31T23", &hh));
777+
EXPECT_TRUE(absl::ParseLenientCivilTime("9223372036854775807-12-31T23", &hh));
817778
EXPECT_EQ("9223372036854775807-12-31T23", absl::FormatCivilTime(hh));
818779
EXPECT_TRUE(
819780
absl::ParseLenientCivilTime("-9223372036854775808-01-01T00", &hh));
@@ -1181,19 +1142,13 @@ TEST(CivilTime, LeapYears) {
11811142
int day;
11821143
} leap_day; // The date of the day after Feb 28.
11831144
} kLeapYearTable[]{
1184-
{1900, 365, {3, 1}},
1185-
{1999, 365, {3, 1}},
1145+
{1900, 365, {3, 1}}, {1999, 365, {3, 1}},
11861146
{2000, 366, {2, 29}}, // leap year
1187-
{2001, 365, {3, 1}},
1188-
{2002, 365, {3, 1}},
1189-
{2003, 365, {3, 1}},
1190-
{2004, 366, {2, 29}}, // leap year
1191-
{2005, 365, {3, 1}},
1192-
{2006, 365, {3, 1}},
1193-
{2007, 365, {3, 1}},
1194-
{2008, 366, {2, 29}}, // leap year
1195-
{2009, 365, {3, 1}},
1196-
{2100, 365, {3, 1}},
1147+
{2001, 365, {3, 1}}, {2002, 365, {3, 1}},
1148+
{2003, 365, {3, 1}}, {2004, 366, {2, 29}}, // leap year
1149+
{2005, 365, {3, 1}}, {2006, 365, {3, 1}},
1150+
{2007, 365, {3, 1}}, {2008, 366, {2, 29}}, // leap year
1151+
{2009, 365, {3, 1}}, {2100, 365, {3, 1}},
11971152
};
11981153

11991154
for (int i = 0; i < ABSL_ARRAYSIZE(kLeapYearTable); ++i) {
@@ -1223,7 +1178,7 @@ TEST(CivilTime, FirstThursdayInMonth) {
12231178

12241179
// Bonus: Date of Thanksgiving in the United States
12251180
// Rule: Fourth Thursday of November
1226-
const absl::CivilDay thanksgiving = thursday + 7 * 3;
1181+
const absl::CivilDay thanksgiving = thursday + 7 * 3;
12271182
EXPECT_EQ("2014-11-27", absl::FormatCivilTime(thanksgiving));
12281183
}
12291184

‎absl/time/clock.cc‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -125,7 +125,7 @@ class UnscaledCycleClockWrapperForGetCurrentTime {
125125
// spin-delay tuning.
126126

127127
// Acquire seqlock (*seq) and return the value to be written to unlock.
128-
static inline uint64_t SeqAcquire(std::atomic<uint64_t> *seq) {
128+
static inline uint64_t SeqAcquire(std::atomic<uint64_t>* seq) {
129129
uint64_t x = seq->fetch_add(1, std::memory_order_relaxed);
130130

131131
// We put a release fence between update to *seq and writes to shared data.
@@ -140,7 +140,7 @@ static inline uint64_t SeqAcquire(std::atomic<uint64_t> *seq) {
140140

141141
// Release seqlock (*seq) by writing x to it---a value previously returned by
142142
// SeqAcquire.
143-
static inline void SeqRelease(std::atomic<uint64_t> *seq, uint64_t x) {
143+
static inline void SeqRelease(std::atomic<uint64_t>* seq, uint64_t x) {
144144
// The unlock store to *seq must have release ordering so that all
145145
// updates to shared data must finish before this store.
146146
seq->store(x, std::memory_order_release); // release lock for readers
@@ -218,7 +218,7 @@ ABSL_CONST_INIT static TimeState time_state;
218218
// assumed to be complete resyncs, which shouldn't happen. If they do, a full
219219
// reinitialization of the outer algorithm should occur.)
220220
static int64_t GetCurrentTimeNanosFromKernel(uint64_t last_cycleclock,
221-
uint64_t *cycleclock)
221+
uint64_t* cycleclock)
222222
ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
223223
uint64_t local_approx_syscall_time_in_cycles = // local copy
224224
time_state.approx_syscall_time_in_cycles.load(std::memory_order_relaxed);
@@ -274,8 +274,8 @@ static int64_t GetCurrentTimeNanosSlowPath() ABSL_ATTRIBUTE_COLD;
274274
// Read the contents of *atomic into *sample.
275275
// Each field is read atomically, but to maintain atomicity between fields,
276276
// the access must be done under a lock.
277-
static void ReadTimeSampleAtomic(const struct TimeSampleAtomic *atomic,
278-
struct TimeSample *sample) {
277+
static void ReadTimeSampleAtomic(const struct TimeSampleAtomic* atomic,
278+
struct TimeSample* sample) {
279279
sample->base_ns = atomic->base_ns.load(std::memory_order_relaxed);
280280
sample->base_cycles = atomic->base_cycles.load(std::memory_order_relaxed);
281281
sample->nsscaled_per_cycle =
@@ -397,7 +397,7 @@ static uint64_t SafeDivideAndScale(uint64_t a, uint64_t b) {
397397

398398
static uint64_t UpdateLastSample(
399399
uint64_t now_cycles, uint64_t now_ns, uint64_t delta_cycles,
400-
const struct TimeSample *sample) ABSL_ATTRIBUTE_COLD;
400+
const struct TimeSample* sample) ABSL_ATTRIBUTE_COLD;
401401

402402
// The slow path of GetCurrentTimeNanos(). This is taken while gathering
403403
// initial samples, when enough time has elapsed since the last sample, and if
@@ -454,7 +454,7 @@ static int64_t GetCurrentTimeNanosSlowPath()
454454
// for readers. Returns the new estimated time.
455455
static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
456456
uint64_t delta_cycles,
457-
const struct TimeSample *sample)
457+
const struct TimeSample* sample)
458458
ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
459459
uint64_t estimated_base_ns = now_ns;
460460
uint64_t lock_value =

‎absl/time/clock_test.cc‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -114,8 +114,8 @@ TEST(SleepFor, Bounded) {
114114
EXPECT_TRUE(AssertSleepForBounded(d, early, late, timeout,
115115
AlarmPolicy::kWithoutAlarm));
116116
#if defined(ABSL_HAVE_ALARM)
117-
EXPECT_TRUE(AssertSleepForBounded(d, early, late, timeout,
118-
AlarmPolicy::kWithAlarm));
117+
EXPECT_TRUE(
118+
AssertSleepForBounded(d, early, late, timeout, AlarmPolicy::kWithAlarm));
119119
#endif
120120
}
121121

0 commit comments

Comments
 (0)