Function TEST

test/rand_util_unittest.cc:23–64

}  // namespace

TEST(RandUtilTest, Sanity) {
    EXPECT_EQ(butil::RandInt(0, 0), 0);
    EXPECT_EQ(butil::RandInt(kIntMin, kIntMin), kIntMin);
    EXPECT_EQ(butil::RandInt(kIntMax, kIntMax), kIntMax);

    for (int i = 0; i < 10; ++i) {
        uint64_t value = butil::fast_rand_in(
            (uint64_t)0, std::numeric_limits<uint64_t>::max());
        if (value != std::numeric_limits<uint64_t>::min() &&
            value != std::numeric_limits<uint64_t>::max()) {
            break;
        } else {
            EXPECT_NE(9, i) << "Never meet random except min/max of uint64";
        }
    }
    for (int i = 0; i < 10; ++i) {
        int64_t value = butil::fast_rand_in(
            std::numeric_limits<int64_t>::min(),
            std::numeric_limits<int64_t>::max());
        if (value != std::numeric_limits<int64_t>::min() &&
            value != std::numeric_limits<int64_t>::max()) {
            break;
        } else {
            EXPECT_NE(9, i) << "Never meet random except min/max of int64";
        }
    }
    EXPECT_EQ(butil::fast_rand_in(-1, -1), -1);
    EXPECT_EQ(butil::fast_rand_in(1, 1), 1);
    EXPECT_EQ(butil::fast_rand_in(0, 0), 0);
    EXPECT_EQ(butil::fast_rand_in(std::numeric_limits<int64_t>::min(),
                                  std::numeric_limits<int64_t>::min()),
              std::numeric_limits<int64_t>::min());
    EXPECT_EQ(butil::fast_rand_in(std::numeric_limits<int64_t>::max(),
                                  std::numeric_limits<int64_t>::max()),
              std::numeric_limits<int64_t>::max());
    EXPECT_EQ(butil::fast_rand_in(std::numeric_limits<uint64_t>::min(),
                                  std::numeric_limits<uint64_t>::min()),
              std::numeric_limits<uint64_t>::min());
    EXPECT_EQ(butil::fast_rand_in(std::numeric_limits<uint64_t>::max(),
                                  std::numeric_limits<uint64_t>::max()),
              std::numeric_limits<uint64_t>::max());
}

TEST(RandUtilTest, RandDouble) {
    // Force 64-bit precision, making sure we're not in a 80-bit FPU register.