blob: d4f3532311a06ee59216bc57e318480481e43949 [file] [log] [blame]
// Copyright 2020 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
#include "pw_metric/metric.h"
#include "gtest/gtest.h"
#include "pw_log/log.h"
namespace pw::metric {
TEST(Metric, FloatFromObject) {
// Note leading bit is 1; it is stripped from the name to store the type.
Token token = 0xf1223344;
TypedMetric<float> m(token, 1.5f);
EXPECT_EQ(m.name(), 0x71223344u);
EXPECT_TRUE(m.is_float());
EXPECT_FALSE(m.is_int());
EXPECT_EQ(m.value(), 1.5f);
m.Set(55.1f);
EXPECT_EQ(m.value(), 55.1f);
// No increment operation for float.
}
TEST(Metric, IntFromObject) {
// Note leading bit is 1; it is stripped from the name to store the type.
Token token = 0xf1223344;
TypedMetric<uint32_t> m(token, static_cast<uint32_t>(31337u));
EXPECT_EQ(m.name(), 0x71223344u);
EXPECT_TRUE(m.is_int());
EXPECT_FALSE(m.is_float());
EXPECT_EQ(m.value(), 31337u);
m.Set(414u);
EXPECT_EQ(m.value(), 414u);
m.Increment();
EXPECT_EQ(m.value(), 415u);
m.Increment(11u);
EXPECT_EQ(m.value(), 426u);
}
TEST(m, IntFromMacroLocal) {
PW_METRIC(m, "some_metric", 14u);
EXPECT_TRUE(m.is_int());
EXPECT_EQ(m.value(), 14u);
}
TEST(Metric, FloatFromMacroLocal) {
PW_METRIC(m, "some_metric", 3.14f);
EXPECT_TRUE(m.is_float());
EXPECT_EQ(m.value(), 3.14f);
}
TEST(Metric, GroupMacroInFunctionContext) {
PW_METRIC_GROUP(group, "fancy_subsystem");
PW_METRIC(group, x, "x", 5555u);
PW_METRIC(group, y, "y", 6.0f);
// These calls are needed to satisfy GCC, otherwise GCC warns about an unused
// variable (even though it is used and passed to the group, which adds it):
//
// metric_test.cc:72:20: error: variable 'x' set but not used
// [-Werror=unused-but-set-variable]
//
x.Increment(10);
y.Set(5.0f);
group.Dump();
EXPECT_EQ(group.metrics().size(), 2u);
}
// The below are compile tests to ensure the macros work at global scope.
// Case 1: No group specified.
PW_METRIC(global_x, "global_x", 5555u);
PW_METRIC(global_y, "global_y", 6.0f);
// Case 2: Group specified.
PW_METRIC_GROUP(global_group, "a_global_group");
PW_METRIC(global_group, global_z, "global_x", 5555u);
PW_METRIC(global_group, global_w, "global_y", 6.0f);
// A fake object to illustrate the API and show nesting metrics.
// This also tests creating metrics as members inside a class.
class I2cBus {
public:
void Transaction() {
// An entirely unconvincing fake I2C transaction implementation.
transactions_.Increment();
bytes_sent_.Increment(5);
}
Group& stats() { return metrics_; }
private:
// Test a group with metrics in it, as a class member.
// Note that in many cases, the group would be passed in externally instead.
PW_METRIC_GROUP(metrics_, "i2c");
PW_METRIC(metrics_, bus_errors_, "bus_errors", 0u);
PW_METRIC(metrics_, transactions_, "transactions", 0u);
PW_METRIC(metrics_, bytes_sent_, "bytes_sent", 0u);
// Test metrics without a group, as a class member.
PW_METRIC(a, "a", 0u);
PW_METRIC(b, "b", 10.0f);
PW_METRIC(c, "c", 525u);
};
class Gyro {
public:
Gyro(I2cBus& i2c_bus, Group& parent_metrics) : i2c_bus_(i2c_bus) {
// Make the gyro a child of the I2C bus. Note that the other arrangement,
// where the i2c bus is a child of the gyro, doesn't work if there are
// multiple objects on the I2C bus due to the intrusive list mechanism.
parent_metrics.Add(metrics_);
}
void Init() {
i2c_bus_.Transaction();
initialized_.Increment();
}
void ReadAngularVelocity() {
// Pretend to be doing some transactions and pulling angular velocity.
// Pretend this gyro is inefficient and requires multiple transactions.
i2c_bus_.Transaction();
i2c_bus_.Transaction();
i2c_bus_.Transaction();
num_samples_.Increment();
}
Group& stats() { return metrics_; }
private:
I2cBus& i2c_bus_;
// In this case, "gyro" groups the relevant metrics, but it is possible to
// have freestanding metrics directly without a group; however, those
// free-standing metrics must be added to a group or list supplied elsewhere
// for collection.
PW_METRIC_GROUP(metrics_, "gyro");
PW_METRIC(metrics_, num_samples_, "num_samples", 1u);
PW_METRIC(metrics_, init_time_us_, "init_time_us", 1.0f);
PW_METRIC(metrics_, initialized_, "initialized", 0u);
};
// The below test produces output like:
//
// "$6doqFw==": {
// "$05OCZw==": {
// "$VpPfzg==": 1,
// "$LGPMBQ==": 1.000000,
// "$+iJvUg==": 5,
// }
// "$9hPNxw==": 65,
// "$oK7HmA==": 13,
// "$FCM4qQ==": 0,
// }
//
// Note the metric names are tokenized with base64. Decoding requires using the
// Pigweed detokenizer. With a detokenizing-enabled logger, you would get:
//
// "i2c": {
// "gyro": {
// "num_sampleses": 1,
// "init_time_us": 1.000000,
// "initialized": 5,
// }
// "bus_errors": 65,
// "transactions": 13,
// "bytes_sent": 0,
// }
//
TEST(Metric, InlineConstructionWithGroups) {
I2cBus i2c_bus;
Gyro gyro(i2c_bus, i2c_bus.stats());
gyro.Init();
gyro.ReadAngularVelocity();
gyro.ReadAngularVelocity();
gyro.ReadAngularVelocity();
gyro.ReadAngularVelocity();
// This "test" doesn't really test anything, and more illustrates how to the
// metrics could be instantiated in an object tree.
//
// Unfortunatlely, testing dump is difficult since we don't have log
// redirection for tests.
i2c_bus.stats().Dump();
}
// PW_METRIC_STATIC doesn't support class scopes, since a definition must be
// provided outside of the class body.
// TODO(keir): add support for class scopes and enable this test
#if 0
class MetricTest: public ::testing::Test {
public:
void Increment() {
metric_.Increment();
}
private:
PW_METRIC_STATIC(metric_, "metric", 0u);
};
TEST_F(MetricTest, StaticWithinAClass) {
Increment();
}
#endif
Metric* StaticMetricIncrement() {
PW_METRIC_STATIC(metric, "metric", 0u);
metric.Increment();
return &metric;
}
TEST(Metric, StaticWithinAFunction) {
Metric* metric = StaticMetricIncrement();
EXPECT_EQ(metric->as_int(), 1u);
StaticMetricIncrement();
EXPECT_EQ(metric->as_int(), 2u);
}
} // namespace pw::metric