Source code
Revision control
Copy as Markdown
Other Tools
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#include "FOGFixture.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "mozilla/glean/GleanMetrics.h"
#include "mozilla/glean/GleanPings.h"
#include "mozilla/glean/fog_ffi_generated.h"
#include "mozilla/Maybe.h"
#include "mozilla/Result.h"
#include "mozilla/ResultVariant.h"
#include "mozilla/TimeStamp.h"
#include "nsTArray.h"
#include "mozilla/Preferences.h"
#include "mozilla/Unused.h"
#include "nsString.h"
#include "prtime.h"
using mozilla::Preferences;
using mozilla::TimeDuration;
using namespace mozilla::glean;
using namespace mozilla::glean::impl;
#define DATA_PREF "datareporting.healthreport.uploadEnabled"
extern "C" {
// This function is called by the rust code in test.rs if a non-fatal test
// failure occurs.
void GTest_FOG_ExpectFailure(const char* aMessage) {
EXPECT_STREQ(aMessage, "");
}
}
TEST_F(FOGFixture, BuiltinPingsRegistered) {
Preferences::SetInt("telemetry.fog.test.localhost_port", -1);
nsAutoCString metricsPingName("metrics");
nsAutoCString baselinePingName("baseline");
nsAutoCString eventsPingName("events");
ASSERT_EQ(NS_OK, fog_submit_ping(&metricsPingName));
ASSERT_EQ(NS_OK, fog_submit_ping(&baselinePingName));
ASSERT_EQ(NS_OK, fog_submit_ping(&eventsPingName));
}
TEST_F(FOGFixture, TestCppCounterWorks) {
mozilla::glean::test_only::bad_code.Add(42);
ASSERT_EQ(42, mozilla::glean::test_only::bad_code.TestGetValue("test-ping"_ns)
.unwrap()
.value());
// And test that the ping name's optional, while you're at it:
ASSERT_EQ(42, test_only::bad_code.TestGetValue().unwrap().value());
}
TEST_F(FOGFixture, TestCppStringWorks) {
auto kValue = "cheez!"_ns;
mozilla::glean::test_only::cheesy_string.Set(kValue);
ASSERT_STREQ(kValue.get(), mozilla::glean::test_only::cheesy_string
.TestGetValue("test-ping"_ns)
.unwrap()
.value()
.get());
}
TEST_F(FOGFixture, TestCppTimespanWorks) {
mozilla::glean::test_only::can_we_time_it.Start();
PR_Sleep(PR_MillisecondsToInterval(10));
mozilla::glean::test_only::can_we_time_it.Stop();
ASSERT_TRUE(
mozilla::glean::test_only::can_we_time_it.TestGetValue("test-ping"_ns)
.unwrap()
.value() > 0);
}
TEST_F(FOGFixture, TestCppUuidWorks) {
nsCString kTestUuid("decafdec-afde-cafd-ecaf-decafdecafde");
test_only::what_id_it.Set(kTestUuid);
ASSERT_STREQ(kTestUuid.get(),
test_only::what_id_it.TestGetValue("test-ping"_ns)
.unwrap()
.value()
.get());
test_only::what_id_it.GenerateAndSet();
// Since we generate v4 UUIDs, and the first character of the third group
// isn't 4, this won't ever collide with kTestUuid.
ASSERT_STRNE(kTestUuid.get(),
test_only::what_id_it.TestGetValue("test-ping"_ns)
.unwrap()
.value()
.get());
}
TEST_F(FOGFixture, TestCppBooleanWorks) {
mozilla::glean::test_only::can_we_flag_it.Set(false);
ASSERT_EQ(false, mozilla::glean::test_only::can_we_flag_it
.TestGetValue("test-ping"_ns)
.unwrap()
.value());
}
MATCHER_P(BitEq, x, "bit equal") {
static_assert(sizeof(x) == sizeof(arg));
return std::memcmp(&arg, &x, sizeof(x)) == 0;
}
TEST_F(FOGFixture, TestCppDatetimeWorks) {
PRExplodedTime date{0, 35, 10, 12, 6, 10, 2020, 0, 0, {5 * 60 * 60, 0}};
test_only::what_a_date.Set(&date);
auto received = test_only::what_a_date.TestGetValue("test-ping"_ns).unwrap();
ASSERT_THAT(received.value(), BitEq(date));
}
using mozilla::Some;
using mozilla::glean::test_only_ipc::AnEventExtra;
using mozilla::glean::test_only_ipc::EventWithExtraExtra;
using std::tuple;
TEST_F(FOGFixture, TestCppEventWorks) {
test_only_ipc::no_extra_event.Record();
ASSERT_TRUE(test_only_ipc::no_extra_event.TestGetValue("store1"_ns)
.unwrap()
.isSome());
AnEventExtra extra = {.extra1 = Some("can set extras"_ns)};
test_only_ipc::an_event.Record(Some(extra));
auto optEvents = test_only_ipc::an_event.TestGetValue("store1"_ns).unwrap();
ASSERT_TRUE(optEvents.isSome());
auto events = optEvents.extract();
ASSERT_EQ(1UL, events.Length());
ASSERT_STREQ("test_only.ipc", events[0].mCategory.get());
ASSERT_STREQ("an_event", events[0].mName.get());
ASSERT_EQ(1UL, events[0].mExtra.Length());
ASSERT_STREQ("extra1", std::get<0>(events[0].mExtra[0]).get());
ASSERT_STREQ("can set extras", std::get<1>(events[0].mExtra[0]).get());
}
TEST_F(FOGFixture, TestCppEventsWithDifferentExtraTypes) {
EventWithExtraExtra extra = {.extra1 = Some("can set extras"_ns),
.extra2 = Some(37),
.extra3LongerName = Some(false)};
test_only_ipc::event_with_extra.Record(Some(extra));
auto optEvents =
test_only_ipc::event_with_extra.TestGetValue("store1"_ns).unwrap();
ASSERT_TRUE(optEvents.isSome());
auto events = optEvents.extract();
ASSERT_EQ(1UL, events.Length());
// The list of extra key/value pairs can be in any order.
ASSERT_EQ(3UL, events[0].mExtra.Length());
for (auto extra : events[0].mExtra) {
auto key = std::get<0>(extra);
auto value = std::get<1>(extra);
if (key == "extra1"_ns) {
ASSERT_STREQ("can set extras", value.get());
} else if (key == "extra2"_ns) {
ASSERT_STREQ("37", value.get());
} else if (key == "extra3_longer_name"_ns) {
ASSERT_STREQ("false", value.get());
} else {
ASSERT_TRUE(false)
<< "Invalid extra item recorded.";
}
}
}
TEST_F(FOGFixture, TestCppMemoryDistWorks) {
test_only::do_you_remember.Accumulate(7);
test_only::do_you_remember.Accumulate(17);
DistributionData data =
test_only::do_you_remember.TestGetValue("test-ping"_ns).unwrap().ref();
// Sum is in bytes, test_only::do_you_remember is in megabytes. So
// multiplication ahoy!
ASSERT_EQ(data.sum, 24UL * 1024 * 1024);
ASSERT_EQ(data.count, 2UL);
for (const auto& entry : data.values) {
const uint64_t bucket = entry.GetKey();
const uint64_t count = entry.GetData();
ASSERT_TRUE(count == 0 ||
(count == 1 && (bucket == 17520006 || bucket == 7053950)))
<< "Only two occupied buckets";
}
}
TEST_F(FOGFixture, TestCppCustomDistWorks) {
test_only_ipc::a_custom_dist.AccumulateSamples({7, 268435458});
DistributionData data =
test_only_ipc::a_custom_dist.TestGetValue("store1"_ns).unwrap().ref();
ASSERT_EQ(data.sum, 7UL + 268435458);
ASSERT_EQ(data.count, 2UL);
for (const auto& entry : data.values) {
const uint64_t bucket = entry.GetKey();
const uint64_t count = entry.GetData();
ASSERT_TRUE(count == 0 ||
(count == 1 && (bucket == 1 || bucket == 268435456)))
<< "Only two occupied buckets";
}
}
TEST_F(FOGFixture, TestCppPings) {
test_only::one_ping_one_bool.Set(false);
const auto& ping = mozilla::glean_pings::OnePingOnly;
bool submitted = false;
ping.TestBeforeNextSubmit([&submitted](const nsACString& aReason) {
submitted = true;
ASSERT_EQ(false,
test_only::one_ping_one_bool.TestGetValue().unwrap().ref());
});
ping.Submit();
ASSERT_TRUE(submitted)
<< "Must have actually called the lambda.";
}
TEST_F(FOGFixture, TestCppStringLists) {
auto kValue = "cheez!"_ns;
auto kValue2 = "cheezier!"_ns;
auto kValue3 = "cheeziest."_ns;
nsTArray<nsCString> cheezList;
cheezList.EmplaceBack(kValue);
cheezList.EmplaceBack(kValue2);
test_only::cheesy_string_list.Set(cheezList);
auto val = test_only::cheesy_string_list.TestGetValue().unwrap().value();
// Note: This is fragile if the order is ever not preserved.
ASSERT_STREQ(kValue.get(), val[0].get());
ASSERT_STREQ(kValue2.get(), val[1].get());
test_only::cheesy_string_list.Add(kValue3);
val = test_only::cheesy_string_list.TestGetValue().unwrap().value();
ASSERT_STREQ(kValue3.get(), val[2].get());
}
TEST_F(FOGFixture, TestCppTimingDistWorks) {
auto id1 = test_only::what_time_is_it.Start();
auto id2 = test_only::what_time_is_it.Start();
PR_Sleep(PR_MillisecondsToInterval(5));
auto id3 = test_only::what_time_is_it.Start();
test_only::what_time_is_it.Cancel(std::move(id1));
PR_Sleep(PR_MillisecondsToInterval(5));
test_only::what_time_is_it.StopAndAccumulate(std::move(id2));
test_only::what_time_is_it.StopAndAccumulate(std::move(id3));
DistributionData data =
test_only::what_time_is_it.TestGetValue().unwrap().ref();
// Cancelled timers should not increase count.
ASSERT_EQ(data.count, 2UL);
const uint64_t NANOS_IN_MILLIS = 1e6;
// Give ourselves a 200000ns (0.2ms) window to be off on fast machines.
const uint64_t EPSILON = 200000;
// We don't know exactly how long those sleeps took, only that it was at
// least 15ms total.
ASSERT_GT(data.sum, (uint64_t)(15 * NANOS_IN_MILLIS) - EPSILON);
// We also can't guarantee the buckets, but we can guarantee two samples.
uint64_t sampleCount = 0;
for (const auto& value : data.values.Values()) {
sampleCount += value;
}
ASSERT_EQ(sampleCount, (uint64_t)2);
}
TEST_F(FOGFixture, TestCppTimingDistNegativeDuration) {
// Intentionally a negative duration to test the error case.
auto negDuration = TimeDuration::FromSeconds(-1);
test_only::what_time_is_it.AccumulateRawDuration(negDuration);
ASSERT_EQ(mozilla::Nothing(),
test_only::what_time_is_it.TestGetValue().unwrap());
}
TEST_F(FOGFixture, TestLabeledBooleanWorks) {
ASSERT_EQ(mozilla::Nothing(),
test_only::mabels_like_balloons.Get("hot_air"_ns)
.TestGetValue()
.unwrap());
test_only::mabels_like_balloons.Get("hot_air"_ns).Set(true);
test_only::mabels_like_balloons.Get("helium"_ns).Set(false);
ASSERT_EQ(true, test_only::mabels_like_balloons.Get("hot_air"_ns)
.TestGetValue()
.unwrap()
.ref());
ASSERT_EQ(false, test_only::mabels_like_balloons.Get("helium"_ns)
.TestGetValue()
.unwrap()
.ref());
}
TEST_F(FOGFixture, TestLabeledBooleanWithLabelsWorks) {
ASSERT_EQ(mozilla::Nothing(),
test_only::mabels_like_labeled_balloons
.EnumGet(test_only::MabelsLikeLabeledBalloonsLabel::eWater)
.TestGetValue()
.unwrap());
test_only::mabels_like_labeled_balloons
.EnumGet(test_only::MabelsLikeLabeledBalloonsLabel::eWater)
.Set(true);
test_only::mabels_like_labeled_balloons
.EnumGet(test_only::MabelsLikeLabeledBalloonsLabel::eBirthdayParty)
.Set(false);
ASSERT_EQ(true,
test_only::mabels_like_labeled_balloons
.EnumGet(test_only::MabelsLikeLabeledBalloonsLabel::eWater)
.TestGetValue()
.unwrap()
.ref());
ASSERT_EQ(
false,
test_only::mabels_like_labeled_balloons
.EnumGet(test_only::MabelsLikeLabeledBalloonsLabel::eBirthdayParty)
.TestGetValue()
.unwrap()
.ref());
}
TEST_F(FOGFixture, TestLabeledCounterWorks) {
ASSERT_EQ(mozilla::Nothing(),
test_only::mabels_kitchen_counters.Get("marble"_ns)
.TestGetValue()
.unwrap());
test_only::mabels_kitchen_counters.Get("marble"_ns).Add(1);
test_only::mabels_kitchen_counters.Get("laminate"_ns).Add(2);
ASSERT_EQ(1, test_only::mabels_kitchen_counters.Get("marble"_ns)
.TestGetValue()
.unwrap()
.ref());
ASSERT_EQ(2, test_only::mabels_kitchen_counters.Get("laminate"_ns)
.TestGetValue()
.unwrap()
.ref());
}
TEST_F(FOGFixture, TestLabeledCounterWithLabelsWorks) {
ASSERT_EQ(
mozilla::Nothing(),
test_only::mabels_labeled_counters
.EnumGet(test_only::MabelsLabeledCountersLabel::eNextToTheFridge)
.TestGetValue()
.unwrap());
test_only::mabels_labeled_counters
.EnumGet(test_only::MabelsLabeledCountersLabel::eNextToTheFridge)
.Add(1);
test_only::mabels_labeled_counters
.EnumGet(test_only::MabelsLabeledCountersLabel::eClean)
.Add(2);
test_only::mabels_labeled_counters
.EnumGet(test_only::MabelsLabeledCountersLabel::e1stCounter)
.Add(3);
ASSERT_EQ(
1, test_only::mabels_labeled_counters
.EnumGet(test_only::MabelsLabeledCountersLabel::eNextToTheFridge)
.TestGetValue()
.unwrap()
.ref());
ASSERT_EQ(2, test_only::mabels_labeled_counters
.EnumGet(test_only::MabelsLabeledCountersLabel::eClean)
.TestGetValue()
.unwrap()
.ref());
ASSERT_EQ(3, test_only::mabels_labeled_counters
.EnumGet(test_only::MabelsLabeledCountersLabel::e1stCounter)
.TestGetValue()
.unwrap()
.ref());
}
TEST_F(FOGFixture, TestLabeledStringWorks) {
ASSERT_EQ(mozilla::Nothing(),
test_only::mabels_balloon_strings.Get("twine"_ns)
.TestGetValue()
.unwrap());
test_only::mabels_balloon_strings.Get("twine"_ns).Set("seems acceptable"_ns);
test_only::mabels_balloon_strings.Get("parachute_cord"_ns)
.Set("preferred"_ns);
ASSERT_STREQ("seems acceptable",
test_only::mabels_balloon_strings.Get("twine"_ns)
.TestGetValue()
.unwrap()
.ref()
.get());
ASSERT_STREQ("preferred",
test_only::mabels_balloon_strings.Get("parachute_cord"_ns)
.TestGetValue()
.unwrap()
.ref()
.get());
}
TEST_F(FOGFixture, TestLabeledStringWithLabelsWorks) {
ASSERT_EQ(mozilla::Nothing(),
test_only::mabels_balloon_labels
.EnumGet(test_only::MabelsBalloonLabelsLabel::eCelebratory)
.TestGetValue()
.unwrap());
test_only::mabels_balloon_labels
.EnumGet(test_only::MabelsBalloonLabelsLabel::eCelebratory)
.Set("for birthdays, etc."_ns);
test_only::mabels_balloon_labels
.EnumGet(test_only::MabelsBalloonLabelsLabel::eCelebratoryAndSnarky)
.Set("for retirements and bridal showers"_ns);
ASSERT_STREQ("for birthdays, etc.",
test_only::mabels_balloon_labels
.EnumGet(test_only::MabelsBalloonLabelsLabel::eCelebratory)
.TestGetValue()
.unwrap()
.ref()
.get());
ASSERT_STREQ(
"for retirements and bridal showers",
test_only::mabels_balloon_labels
.EnumGet(test_only::MabelsBalloonLabelsLabel::eCelebratoryAndSnarky)
.TestGetValue()
.unwrap()
.ref()
.get());
}
TEST_F(FOGFixture, TestCppQuantityWorks) {
// This joke only works in base 13.
const uint32_t kValue = 6 * 9;
mozilla::glean::test_only::meaning_of_life.Set(kValue);
ASSERT_EQ(kValue, mozilla::glean::test_only::meaning_of_life.TestGetValue()
.unwrap()
.value());
}
TEST_F(FOGFixture, TestCppRateWorks) {
// 1) Standard rate with internal denominator
const int32_t kNum = 22;
const int32_t kDen = 7; // because I like pi, even just approximately.
test_only_ipc::irate.AddToNumerator(kNum);
test_only_ipc::irate.AddToDenominator(kDen);
auto value = test_only_ipc::irate.TestGetValue().unwrap();
ASSERT_EQ(kNum, value.ref().first);
ASSERT_EQ(kDen, value.ref().second);
// 2) Rate with external denominator
test_only_ipc::rate_with_external_denominator.AddToNumerator(kNum);
test_only_ipc::an_external_denominator.Add(kDen);
value = test_only_ipc::rate_with_external_denominator.TestGetValue().unwrap();
ASSERT_EQ(kNum, value.ref().first);
ASSERT_EQ(kDen, value.ref().second);
ASSERT_EQ(
kDen,
test_only_ipc::an_external_denominator.TestGetValue().unwrap().extract());
}
TEST_F(FOGFixture, TestCppUrlWorks) {
mozilla::glean::test_only_ipc::a_url.Set(kValue);
ASSERT_STREQ(kValue.get(),
mozilla::glean::test_only_ipc::a_url.TestGetValue("store1"_ns)
.unwrap()
.value()
.get());
}
TEST_F(FOGFixture, TestCppTextWorks) {
auto kValue =
"République is a French-inspired bakery, café, bar and formal dining room located in the Mid-city neighborhood of Los Angeles, set in a historic 1928 space ..."_ns;
mozilla::glean::test_only_ipc::a_text.Set(kValue);
ASSERT_STREQ(kValue.get(),
mozilla::glean::test_only_ipc::a_text.TestGetValue()
.unwrap()
.value()
.get());
}
TEST_F(FOGFixture, TestLabeledCustomDistributionWorks) {
ASSERT_EQ(mozilla::Nothing(),
test_only::mabels_custom_label_lengths.Get("officeSupplies"_ns)
.TestGetValue()
.unwrap());
test_only::mabels_custom_label_lengths.Get("officeSupplies"_ns)
.AccumulateSamples({7, 268435458});
DistributionData data =
test_only::mabels_custom_label_lengths.Get("officeSupplies"_ns)
.TestGetValue()
.unwrap()
.ref();
ASSERT_EQ(data.sum, 7UL + 268435458);
ASSERT_EQ(data.count, 2UL);
for (const auto& entry : data.values) {
const uint64_t bucket = entry.GetKey();
const uint64_t count = entry.GetData();
ASSERT_TRUE(count == 0 ||
(count == 1 && (bucket == 1 || bucket == 268435456)))
<< "Only two occupied buckets";
}
}
TEST_F(FOGFixture, TestLabeledMemoryDistWorks) {
test_only::what_do_you_remember.Get("bittersweet"_ns).Accumulate(7);
test_only::what_do_you_remember.Get("bittersweet"_ns).Accumulate(17);
DistributionData data = test_only::what_do_you_remember.Get("bittersweet"_ns)
.TestGetValue()
.unwrap()
.ref();
// Sum is in bytes, test_only::what_do_you_remember is in megabytes. So
// multiplication ahoy!
ASSERT_EQ(data.sum, 24UL * 1024 * 1024);
ASSERT_EQ(data.count, 2UL);
for (const auto& entry : data.values) {
const uint64_t bucket = entry.GetKey();
const uint64_t count = entry.GetData();
ASSERT_TRUE(count == 0 ||
(count == 1 && (bucket == 17520006 || bucket == 7053950)))
<< "Only two occupied buckets";
}
}
TEST_F(FOGFixture, TestLabeledTimingDistWorks) {
auto id1 = test_only::where_has_the_time_gone.Get("UTC"_ns).Start();
auto id2 = test_only::where_has_the_time_gone.Get("UTC"_ns).Start();
PR_Sleep(PR_MillisecondsToInterval(5));
auto id3 = test_only::where_has_the_time_gone.Get("UTC"_ns).Start();
test_only::where_has_the_time_gone.Get("UTC"_ns).Cancel(std::move(id1));
PR_Sleep(PR_MillisecondsToInterval(5));
test_only::where_has_the_time_gone.Get("UTC"_ns).StopAndAccumulate(
std::move(id2));
test_only::where_has_the_time_gone.Get("UTC"_ns).StopAndAccumulate(
std::move(id3));
DistributionData data = test_only::where_has_the_time_gone.Get("UTC"_ns)
.TestGetValue()
.unwrap()
.ref();
// Cancelled timers should not increase count.
ASSERT_EQ(data.count, 2UL);
const uint64_t NANOS_IN_MILLIS = 1e6;
// Give ourselves a 200000ns (0.2ms) window to be off on fast machines.
const uint64_t EPSILON = 200000;
// We don't know exactly how long those sleeps took, only that it was at
// least 15ms total.
ASSERT_GT(data.sum, (uint64_t)(15 * NANOS_IN_MILLIS) - EPSILON);
// We also can't guarantee the buckets, but we can guarantee two samples.
uint64_t sampleCount = 0;
for (const auto& value : data.values.Values()) {
sampleCount += value;
}
ASSERT_EQ(sampleCount, (uint64_t)2);
}
TEST_F(FOGFixture, TestLabeledQuantityWorks) {
ASSERT_EQ(mozilla::Nothing(),
test_only::button_jars.Get("shirt"_ns).TestGetValue().unwrap());
test_only::button_jars.Get("shirt"_ns).Set(42);
test_only::button_jars.Get("push"_ns).Set(0);
ASSERT_EQ(
42, test_only::button_jars.Get("shirt"_ns).TestGetValue().unwrap().ref());
ASSERT_EQ(
0, test_only::button_jars.Get("push"_ns).TestGetValue().unwrap().ref());
}
extern "C" void Rust_TestRustInGTest();
TEST_F(FOGFixture, TestRustInGTest) { Rust_TestRustInGTest(); }
extern "C" void Rust_TestJogfile();
TEST_F(FOGFixture, TestJogfile) { Rust_TestJogfile(); }