third_party/pigweed/repo/pw_trace/trace_facade_test.cc

   1 // Copyright 2020 The Pigweed Authors
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
   4 // use this file except in compliance with the License. You may obtain a copy of
   5 // the License at
   6 //
   7 //     https://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12 // License for the specific language governing permissions and limitations under
  13 // the License.
  14
  15 #define PW_TRACE_MODULE_NAME "TST"
  16 #include "gtest/gtest.h"
  17 #include "pw_trace/trace.h"
  18 #include "pw_trace_test/fake_backend.h"
  19
  20 using namespace trace_fake_backend;
  21
  22 // Used by fake backend
  23 LastEvent LastEvent::instance_;
  24
  25 namespace {
  26
  27 void TraceFunction() {
  28   PW_TRACE_FUNCTION();
  29   // Can't check label, since might change depending on compiler.
  30   EXPECT_TRUE(LastEvent::Instance().Get().IsEqualIgnoreLabel(
  31       Event(DurationStart,
  32             PW_TRACE_FLAGS_DEFAULT,
  33             nullptr,
  34             PW_TRACE_GROUP_LABEL_DEFAULT,
  35             PW_TRACE_TRACE_ID_DEFAULT)));
  36 }
  37
  38 void TraceFunctionGroup() {
  39   PW_TRACE_FUNCTION("FunctionGroup");
  40   // Can't check label, since might change depending on compiler.
  41   EXPECT_TRUE(LastEvent::Instance().Get().IsEqualIgnoreLabel(
  42       Event(DurationGroupStart,
  43             PW_TRACE_FLAGS_DEFAULT,
  44             nullptr,
  45             "FunctionGroup",
  46             PW_TRACE_TRACE_ID_DEFAULT)));
  47 }
  48
  49 const char kSomeData[] = "SOME DATA";
  50
  51 }  // namespace
  52
  53 TEST(BasicTrace, Instant) {
  54   PW_TRACE_INSTANT("Test");
  55   EXPECT_EQ(LastEvent::Instance().Get(),
  56             Event(Instantaneous,
  57                   PW_TRACE_FLAGS_DEFAULT,
  58                   "Test",
  59                   PW_TRACE_GROUP_LABEL_DEFAULT,
  60                   PW_TRACE_TRACE_ID_DEFAULT));
  61 }
  62
  63 TEST(BasicTrace, InstantGroup) {
  64   PW_TRACE_INSTANT("Test", "group");
  65   EXPECT_EQ(LastEvent::Instance().Get(),
  66             Event(InstantaneousGroup,
  67                   PW_TRACE_FLAGS_DEFAULT,
  68                   "Test",
  69                   "group",
  70                   PW_TRACE_TRACE_ID_DEFAULT));
  71 }
  72
  73 TEST(BasicTrace, Duration) {
  74   PW_TRACE_START("Test");
  75   EXPECT_EQ(LastEvent::Instance().Get(),
  76             Event(DurationStart,
  77                   PW_TRACE_FLAGS_DEFAULT,
  78                   "Test",
  79                   PW_TRACE_GROUP_LABEL_DEFAULT,
  80                   PW_TRACE_TRACE_ID_DEFAULT));
  81   PW_TRACE_END("Test");
  82   EXPECT_EQ(LastEvent::Instance().Get(),
  83             Event(DurationEnd,
  84                   PW_TRACE_FLAGS_DEFAULT,
  85                   "Test",
  86                   PW_TRACE_GROUP_LABEL_DEFAULT,
  87                   PW_TRACE_TRACE_ID_DEFAULT));
  88 }
  89
  90 TEST(BasicTrace, DurationGroup) {
  91   PW_TRACE_START("Parent", "group");
  92   EXPECT_EQ(LastEvent::Instance().Get(),
  93             Event(DurationGroupStart,
  94                   PW_TRACE_FLAGS_DEFAULT,
  95                   "Parent",
  96                   "group",
  97                   PW_TRACE_TRACE_ID_DEFAULT));
  98   PW_TRACE_START("Child", "group");
  99   EXPECT_EQ(LastEvent::Instance().Get(),
 100             Event(DurationGroupStart,
 101                   PW_TRACE_FLAGS_DEFAULT,
 102                   "Child",
 103                   "group",
 104                   PW_TRACE_TRACE_ID_DEFAULT));
 105   PW_TRACE_END("Child", "group");
 106   EXPECT_EQ(LastEvent::Instance().Get(),
 107             Event(DurationGroupEnd,
 108                   PW_TRACE_FLAGS_DEFAULT,
 109                   "Child",
 110                   "group",
 111                   PW_TRACE_TRACE_ID_DEFAULT));
 112   PW_TRACE_START("Other Child", "group");
 113   EXPECT_EQ(LastEvent::Instance().Get(),
 114             Event(DurationGroupStart,
 115                   PW_TRACE_FLAGS_DEFAULT,
 116                   "Other Child",
 117                   "group",
 118                   PW_TRACE_TRACE_ID_DEFAULT));
 119   PW_TRACE_END("Other Child", "group");
 120   EXPECT_EQ(LastEvent::Instance().Get(),
 121             Event(DurationGroupEnd,
 122                   PW_TRACE_FLAGS_DEFAULT,
 123                   "Other Child",
 124                   "group",
 125                   PW_TRACE_TRACE_ID_DEFAULT));
 126   PW_TRACE_END("Parent", "group");
 127   EXPECT_EQ(LastEvent::Instance().Get(),
 128             Event(DurationGroupEnd,
 129                   PW_TRACE_FLAGS_DEFAULT,
 130                   "Parent",
 131                   "group",
 132                   PW_TRACE_TRACE_ID_DEFAULT));
 133 }
 134
 135 TEST(BasicTrace, Async) {
 136   uint32_t trace_id = 1;
 137   PW_TRACE_START("async", "group", trace_id);
 138   EXPECT_EQ(
 139       LastEvent::Instance().Get(),
 140       Event(AsyncStart, PW_TRACE_FLAGS_DEFAULT, "async", "group", trace_id));
 141   PW_TRACE_INSTANT("step", "group", trace_id);
 142   EXPECT_EQ(
 143       LastEvent::Instance().Get(),
 144       Event(AsyncStep, PW_TRACE_FLAGS_DEFAULT, "step", "group", trace_id));
 145   PW_TRACE_END("async", "group", trace_id);
 146   EXPECT_EQ(
 147       LastEvent::Instance().Get(),
 148       Event(AsyncEnd, PW_TRACE_FLAGS_DEFAULT, "async", "group", trace_id));
 149 }
 150
 151 TEST(BasicTrace, Scope) {
 152   {
 153     PW_TRACE_SCOPE("scoped trace");
 154     EXPECT_EQ(LastEvent::Instance().Get(),
 155               Event(DurationStart,
 156                     PW_TRACE_FLAGS_DEFAULT,
 157                     "scoped trace",
 158                     PW_TRACE_GROUP_LABEL_DEFAULT,
 159                     PW_TRACE_TRACE_ID_DEFAULT));
 160   }
 161   EXPECT_EQ(LastEvent::Instance().Get(),
 162             Event(DurationEnd,
 163                   PW_TRACE_FLAGS_DEFAULT,
 164                   "scoped trace",
 165                   PW_TRACE_GROUP_LABEL_DEFAULT,
 166                   PW_TRACE_TRACE_ID_DEFAULT));
 167 }
 168
 169 TEST(BasicTrace, ScopeGroup) {
 170   {
 171     PW_TRACE_SCOPE("scoped group trace", "group");
 172     EXPECT_EQ(LastEvent::Instance().Get(),
 173               Event(DurationGroupStart,
 174                     PW_TRACE_FLAGS_DEFAULT,
 175                     "scoped group trace",
 176                     "group",
 177                     PW_TRACE_TRACE_ID_DEFAULT));
 178     {
 179       PW_TRACE_SCOPE("sub scoped group trace", "group");
 180       EXPECT_EQ(LastEvent::Instance().Get(),
 181                 Event(DurationGroupStart,
 182                       PW_TRACE_FLAGS_DEFAULT,
 183                       "sub scoped group trace",
 184                       "group",
 185                       PW_TRACE_TRACE_ID_DEFAULT));
 186     }
 187     EXPECT_EQ(LastEvent::Instance().Get(),
 188               Event(DurationGroupEnd,
 189                     PW_TRACE_FLAGS_DEFAULT,
 190                     "sub scoped group trace",
 191                     "group",
 192                     PW_TRACE_TRACE_ID_DEFAULT));
 193   }
 194   EXPECT_EQ(LastEvent::Instance().Get(),
 195             Event(DurationGroupEnd,
 196                   PW_TRACE_FLAGS_DEFAULT,
 197                   "scoped group trace",
 198                   "group",
 199                   PW_TRACE_TRACE_ID_DEFAULT));
 200 }
 201
 202 TEST(BasicTrace, ScopeTraceId) {
 203   static constexpr uint32_t kTraceId = 5;
 204   {
 205     PW_TRACE_SCOPE("scoped trace id", "group", kTraceId);
 206     EXPECT_EQ(LastEvent::Instance().Get(),
 207               Event(AsyncStart,
 208                     PW_TRACE_FLAGS_DEFAULT,
 209                     "scoped trace id",
 210                     "group",
 211                     kTraceId));
 212   }
 213   EXPECT_EQ(LastEvent::Instance().Get(),
 214             Event(AsyncEnd,
 215                   PW_TRACE_FLAGS_DEFAULT,
 216                   "scoped trace id",
 217                   "group",
 218                   kTraceId));
 219 }
 220
 221 TEST(BasicTrace, Function) {
 222   TraceFunction();
 223   // Can't check label, since might change depending on compiler.
 224   EXPECT_TRUE(LastEvent::Instance().Get().IsEqualIgnoreLabel(
 225       Event(DurationEnd,
 226             PW_TRACE_FLAGS_DEFAULT,
 227             nullptr,
 228             PW_TRACE_GROUP_LABEL_DEFAULT,
 229             PW_TRACE_TRACE_ID_DEFAULT)));
 230 }
 231
 232 TEST(BasicTrace, FunctionGroup) {
 233   TraceFunctionGroup();
 234   // Can't check label, since might change depending on compiler.
 235   EXPECT_TRUE(LastEvent::Instance().Get().IsEqualIgnoreLabel(
 236       Event(DurationGroupEnd,
 237             PW_TRACE_FLAGS_DEFAULT,
 238             nullptr,
 239             "FunctionGroup",
 240             PW_TRACE_TRACE_ID_DEFAULT)));
 241 }
 242
 243 TEST(BasicTrace, InstantData) {
 244   PW_TRACE_INSTANT_DATA("Test", "s", kSomeData, sizeof(kSomeData));
 245   EXPECT_EQ(LastEvent::Instance().Get(),
 246             Event(Instantaneous,
 247                   PW_TRACE_FLAGS_DEFAULT,
 248                   "Test",
 249                   PW_TRACE_GROUP_LABEL_DEFAULT,
 250                   PW_TRACE_TRACE_ID_DEFAULT,
 251                   "s",
 252                   kSomeData,
 253                   sizeof(kSomeData)));
 254 }
 255
 256 TEST(BasicTrace, InstantGroupData) {
 257   PW_TRACE_INSTANT_DATA("Test", "Group", "s", kSomeData, sizeof(kSomeData));
 258   EXPECT_EQ(LastEvent::Instance().Get(),
 259             Event(InstantaneousGroup,
 260                   PW_TRACE_FLAGS_DEFAULT,
 261                   "Test",
 262                   "Group",
 263                   PW_TRACE_TRACE_ID_DEFAULT,
 264                   "s",
 265                   kSomeData,
 266                   sizeof(kSomeData)));
 267 }
 268
 269 TEST(BasicTrace, DurationData) {
 270   PW_TRACE_START_DATA("Test", "s", kSomeData, sizeof(kSomeData));
 271   EXPECT_EQ(LastEvent::Instance().Get(),
 272             Event(DurationStart,
 273                   PW_TRACE_FLAGS_DEFAULT,
 274                   "Test",
 275                   PW_TRACE_GROUP_LABEL_DEFAULT,
 276                   PW_TRACE_TRACE_ID_DEFAULT,
 277                   "s",
 278                   kSomeData,
 279                   sizeof(kSomeData)));
 280   PW_TRACE_END_DATA("Test", "s", kSomeData, sizeof(kSomeData));
 281   EXPECT_EQ(LastEvent::Instance().Get(),
 282             Event(DurationEnd,
 283                   PW_TRACE_FLAGS_DEFAULT,
 284                   "Test",
 285                   PW_TRACE_GROUP_LABEL_DEFAULT,
 286                   PW_TRACE_TRACE_ID_DEFAULT,
 287                   "s",
 288                   kSomeData,
 289                   sizeof(kSomeData)));
 290 }
 291
 292 TEST(BasicTrace, DurationGroupData) {
 293   PW_TRACE_START_DATA("Parent", "group", "s", kSomeData, sizeof(kSomeData));
 294   EXPECT_EQ(LastEvent::Instance().Get(),
 295             Event(DurationGroupStart,
 296                   PW_TRACE_FLAGS_DEFAULT,
 297                   "Parent",
 298                   "group",
 299                   PW_TRACE_TRACE_ID_DEFAULT,
 300                   "s",
 301                   kSomeData,
 302                   sizeof(kSomeData)));
 303   PW_TRACE_START_DATA("Child", "group", "s", kSomeData, sizeof(kSomeData));
 304   EXPECT_EQ(LastEvent::Instance().Get(),
 305             Event(DurationGroupStart,
 306                   PW_TRACE_FLAGS_DEFAULT,
 307                   "Child",
 308                   "group",
 309                   PW_TRACE_TRACE_ID_DEFAULT,
 310                   "s",
 311                   kSomeData,
 312                   sizeof(kSomeData)));
 313   PW_TRACE_END_DATA("Child", "group", "s", kSomeData, sizeof(kSomeData));
 314   EXPECT_EQ(LastEvent::Instance().Get(),
 315             Event(DurationGroupEnd,
 316                   PW_TRACE_FLAGS_DEFAULT,
 317                   "Child",
 318                   "group",
 319                   PW_TRACE_TRACE_ID_DEFAULT,
 320                   "s",
 321                   kSomeData,
 322                   sizeof(kSomeData)));
 323   PW_TRACE_END_DATA("Parent", "group", "s", kSomeData, sizeof(kSomeData));
 324   EXPECT_EQ(LastEvent::Instance().Get(),
 325             Event(DurationGroupEnd,
 326                   PW_TRACE_FLAGS_DEFAULT,
 327                   "Parent",
 328                   "group",
 329                   PW_TRACE_TRACE_ID_DEFAULT,
 330                   "s",
 331                   kSomeData,
 332                   sizeof(kSomeData)));
 333 }
 334
 335 TEST(BasicTrace, AsyncData) {
 336   uint32_t trace_id = 1;
 337   PW_TRACE_START_DATA(
 338       "label for start", "group", trace_id, "s", kSomeData, sizeof(kSomeData));
 339   EXPECT_EQ(LastEvent::Instance().Get(),
 340             Event(AsyncStart,
 341                   PW_TRACE_FLAGS_DEFAULT,
 342                   "label for start",
 343                   "group",
 344                   trace_id,
 345                   "s",
 346                   kSomeData,
 347                   sizeof(kSomeData)));
 348   PW_TRACE_INSTANT_DATA(
 349       "label for step", "group", trace_id, "s", kSomeData, sizeof(kSomeData));
 350   EXPECT_EQ(LastEvent::Instance().Get(),
 351             Event(AsyncStep,
 352                   PW_TRACE_FLAGS_DEFAULT,
 353                   "label for step",
 354                   "group",
 355                   trace_id,
 356                   "s",
 357                   kSomeData,
 358                   sizeof(kSomeData)));
 359   PW_TRACE_END_DATA(
 360       "label for end", "group", trace_id, "s", kSomeData, sizeof(kSomeData));
 361   EXPECT_EQ(LastEvent::Instance().Get(),
 362             Event(AsyncEnd,
 363                   PW_TRACE_FLAGS_DEFAULT,
 364                   "label for end",
 365                   "group",
 366                   trace_id,
 367                   "s",
 368                   kSomeData,
 369                   sizeof(kSomeData)));
 370 }
 371
 372 TEST(BasicTrace, ProvideFlag) {
 373   PW_TRACE_INSTANT_FLAG(5, "Test");
 374   EXPECT_EQ(LastEvent::Instance().Get(),
 375             Event(Instantaneous,
 376                   5,
 377                   "Test",
 378                   PW_TRACE_GROUP_LABEL_DEFAULT,
 379                   PW_TRACE_TRACE_ID_DEFAULT));
 380 }
 381
 382 TEST(BasicTrace, MacroFlag) {
 383 #undef PW_TRACE_FLAGS
 384 #define PW_TRACE_FLAGS 6
 385   PW_TRACE_INSTANT("Test");
 386   EXPECT_EQ(LastEvent::Instance().Get(),
 387             Event(Instantaneous,
 388                   6,
 389                   "Test",
 390                   PW_TRACE_GROUP_LABEL_DEFAULT,
 391                   PW_TRACE_TRACE_ID_DEFAULT));
 392 #undef PW_TRACE_FLAGS
 393 #define PW_TRACE_FLAGS PW_TRACE_FLAGS_DEFAULT
 394   PW_TRACE_INSTANT("Test");
 395   EXPECT_EQ(LastEvent::Instance().Get(),
 396             Event(Instantaneous,
 397                   PW_TRACE_FLAGS_DEFAULT,
 398                   "Test",
 399                   PW_TRACE_GROUP_LABEL_DEFAULT,
 400                   PW_TRACE_TRACE_ID_DEFAULT));
 401 }