Include the fcntl.h portability header where it's needed

[folly.git] / folly / test / BitsTest.cpp

diff --git a/folly/test/BitsTest.cpp b/folly/test/BitsTest.cpp
index 8f08a9e5ba0a23697c34c1a4482d1a4901d4ce24..cdce52012f45dccf97171bad43c5bb17994bb92e 100644 (file)
--- a/folly/test/BitsTest.cpp
+++ b/folly/test/BitsTest.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 Facebook, Inc.
+ * Copyright 2016 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,13 +16,20 @@
 
 // @author Tudor Bosman (tudorb@fb.com)
 
-#include <gflags/gflags.h>
-#include "folly/Bits.h"
-#include "folly/Benchmark.h"
+#include <folly/Bits.h>
+
 #include <gtest/gtest.h>
 
 using namespace folly;
 
+// Test constexpr-ness.
+#ifndef __clang__
+static_assert(findFirstSet(2u) == 2, "findFirstSet");
+static_assert(findLastSet(2u) == 2, "findLastSet");
+static_assert(nextPowTwo(2u) == 2, "nextPowTwo");
+static_assert(isPowTwo(2u), "isPowTwo");
+#endif  // __clang__
+
 namespace {
 
 template <class INT>
@@ -37,12 +44,6 @@ void testFFS() {
   }
 }
 
-template <class INT>
-unsigned int findLastSetPortable(INT x) {
-  return detail::findLastSetPortable(
-      static_cast<typename std::make_unsigned<INT>::type>(x));
-}
-
 template <class INT>
 void testFLS() {
   typedef typename std::make_unsigned<INT>::type UINT;
@@ -51,11 +52,9 @@ void testFLS() {
   for (size_t i = 0; i < bits; i++) {
     INT v1 = static_cast<UINT>(1) << i;
     EXPECT_EQ(i + 1, findLastSet(v1));
-    EXPECT_EQ(i + 1, findLastSetPortable(v1));
 
     INT v2 = (static_cast<UINT>(1) << i) - 1;
     EXPECT_EQ(i, findLastSet(v2));
-    EXPECT_EQ(i, findLastSetPortable(v2));
   }
 }
 
@@ -89,69 +88,54 @@ TEST(Bits, FindLastSet) {
   testFLS<unsigned long long>();
 }
 
-#define testPowTwo(nextPowTwoFunc) {                              \
-  EXPECT_EQ(1, nextPowTwoFunc(0u));                               \
-  EXPECT_EQ(1, nextPowTwoFunc(1u));                               \
-  EXPECT_EQ(2, nextPowTwoFunc(2u));                               \
-  EXPECT_EQ(4, nextPowTwoFunc(3u));                               \
-  EXPECT_EQ(4, nextPowTwoFunc(4u));                               \
-  EXPECT_EQ(8, nextPowTwoFunc(5u));                               \
-  EXPECT_EQ(8, nextPowTwoFunc(6u));                               \
-  EXPECT_EQ(8, nextPowTwoFunc(7u));                               \
-  EXPECT_EQ(8, nextPowTwoFunc(8u));                               \
-  EXPECT_EQ(16, nextPowTwoFunc(9u));                              \
-  EXPECT_EQ(16, nextPowTwoFunc(13u));                             \
-  EXPECT_EQ(16, nextPowTwoFunc(16u));                             \
-  EXPECT_EQ(512, nextPowTwoFunc(510u));                           \
-  EXPECT_EQ(512, nextPowTwoFunc(511u));                           \
-  EXPECT_EQ(512, nextPowTwoFunc(512u));                           \
-  EXPECT_EQ(1024, nextPowTwoFunc(513u));                          \
-  EXPECT_EQ(1024, nextPowTwoFunc(777u));                          \
-  EXPECT_EQ(1ul << 31, nextPowTwoFunc((1ul << 31) - 1));          \
-  EXPECT_EQ(1ul << 32, nextPowTwoFunc((1ul << 32) - 1));          \
-  EXPECT_EQ(1ull << 63, nextPowTwoFunc((1ull << 62) + 1));        \
-}
-
-
-#ifdef __GNUC__
-
 TEST(Bits, nextPowTwoClz) {
-  testPowTwo(nextPowTwo);
+  EXPECT_EQ(1, nextPowTwo(0u));
+  EXPECT_EQ(1, nextPowTwo(1u));
+  EXPECT_EQ(2, nextPowTwo(2u));
+  EXPECT_EQ(4, nextPowTwo(3u));
+  EXPECT_EQ(4, nextPowTwo(4u));
+  EXPECT_EQ(8, nextPowTwo(5u));
+  EXPECT_EQ(8, nextPowTwo(6u));
+  EXPECT_EQ(8, nextPowTwo(7u));
+  EXPECT_EQ(8, nextPowTwo(8u));
+  EXPECT_EQ(16, nextPowTwo(9u));
+  EXPECT_EQ(16, nextPowTwo(13u));
+  EXPECT_EQ(16, nextPowTwo(16u));
+  EXPECT_EQ(512, nextPowTwo(510u));
+  EXPECT_EQ(512, nextPowTwo(511u));
+  EXPECT_EQ(512, nextPowTwo(512u));
+  EXPECT_EQ(1024, nextPowTwo(513u));
+  EXPECT_EQ(1024, nextPowTwo(777u));
+  EXPECT_EQ(1ul << 31, nextPowTwo((1ul << 31) - 1));
+  EXPECT_EQ(1ull << 32, nextPowTwo((1ull << 32) - 1));
+  EXPECT_EQ(1ull << 63, nextPowTwo((1ull << 62) + 1));
 }
 
-int x; // prevent the loop from getting optimized away
-BENCHMARK(nextPowTwoClz, iters) {
-  x = folly::nextPowTwo(iters);
+TEST(Bits, isPowTwo) {
+  EXPECT_FALSE(isPowTwo(0u));
+  EXPECT_TRUE(isPowTwo(1ul));
+  EXPECT_TRUE(isPowTwo(2ull));
+  EXPECT_FALSE(isPowTwo(3ul));
+  EXPECT_TRUE(isPowTwo(4ul));
+  EXPECT_FALSE(isPowTwo(5ul));
+  EXPECT_TRUE(isPowTwo(8ul));
+  EXPECT_FALSE(isPowTwo(15u));
+  EXPECT_TRUE(isPowTwo(16u));
+  EXPECT_FALSE(isPowTwo(17u));
+  EXPECT_FALSE(isPowTwo(511ul));
+  EXPECT_TRUE(isPowTwo(512ul));
+  EXPECT_FALSE(isPowTwo(513ul));
+  EXPECT_FALSE(isPowTwo((1ul<<31) - 1));
+  EXPECT_TRUE(isPowTwo(1ul<<31));
+  EXPECT_FALSE(isPowTwo((1ul<<31) + 1));
+  EXPECT_FALSE(isPowTwo((1ull<<63) - 1));
+  EXPECT_TRUE(isPowTwo(1ull<<63));
+  EXPECT_FALSE(isPowTwo((1ull<<63) + 1));
 }
 
-#endif
-
-TEST(Bits, nextPowTwoPortable) {
-  testPowTwo(detail::nextPowTwoPortable);
+TEST(Bits, popcount) {
+  EXPECT_EQ(0, popcount(0U));
+  EXPECT_EQ(1, popcount(1U));
+  EXPECT_EQ(32, popcount(uint32_t(-1)));
+  EXPECT_EQ(64, popcount(uint64_t(-1)));
 }
-
-BENCHMARK(nextPowTwoPortable, iters) {
-  x = detail::nextPowTwoPortable(iters);
-}
-
-BENCHMARK_DRAW_LINE();
-
-int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
-  google::ParseCommandLineFlags(&argc, &argv, true);
-  auto ret = RUN_ALL_TESTS();
-  if (!ret && FLAGS_benchmark) {
-    folly::runBenchmarks();
-  }
-  return ret;
-}
-
-/*
-Benchmarks run on dual Xeon X5650's @ 2.67GHz w/hyperthreading enabled
-  (12 physical cores, 12 MB cache, 72 GB RAM)
-
-Benchmark                               Iters   Total t    t/iter iter/sec
-------------------------------------------------------------------------------
-*       nextPowTwoClz                 1000000  1.659 ms  1.659 ns  574.8 M
- +66.8% nextPowTwoPortable            1000000  2.767 ms  2.767 ns  344.7 M
-*/