unittests/XRay/FDRBlockVerifierTest.cpp

   1 //===- llvm/unittest/XRay/FDRBlockVerifierTest.cpp --------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 #include "llvm/Testing/Support/Error.h"
  10 #include "llvm/XRay/BlockIndexer.h"
  11 #include "llvm/XRay/BlockVerifier.h"
  12 #include "llvm/XRay/FDRLogBuilder.h"
  13 #include "llvm/XRay/FDRRecords.h"
  14 #include "gmock/gmock.h"
  15 #include "gtest/gtest.h"
  16
  17 namespace llvm {
  18 namespace xray {
  19 namespace {
  20
  21 using ::testing::ElementsAre;
  22 using ::testing::Not;
  23 using ::testing::SizeIs;
  24
  25 TEST(FDRBlockVerifierTest, ValidBlocksV3) {
  26   auto Block0 = LogBuilder()
  27                     .add<BufferExtents>(80)
  28                     .add<NewBufferRecord>(1)
  29                     .add<WallclockRecord>(1, 2)
  30                     .add<PIDRecord>(1)
  31                     .add<NewCPUIDRecord>(1, 2)
  32                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
  33                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
  34                     .consume();
  35   auto Block1 = LogBuilder()
  36                     .add<BufferExtents>(80)
  37                     .add<NewBufferRecord>(1)
  38                     .add<WallclockRecord>(1, 2)
  39                     .add<PIDRecord>(1)
  40                     .add<NewCPUIDRecord>(1, 2)
  41                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
  42                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
  43                     .consume();
  44   auto Block2 = LogBuilder()
  45                     .add<BufferExtents>(80)
  46                     .add<NewBufferRecord>(2)
  47                     .add<WallclockRecord>(1, 2)
  48                     .add<PIDRecord>(1)
  49                     .add<NewCPUIDRecord>(2, 2)
  50                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
  51                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
  52                     .consume();
  53   BlockIndexer::Index Index;
  54   BlockIndexer Indexer(Index);
  55   for (auto B : {std::ref(Block0), std::ref(Block1), std::ref(Block2)}) {
  56     for (auto &R : B.get())
  57       ASSERT_FALSE(errorToBool(R->apply(Indexer)));
  58     ASSERT_FALSE(errorToBool(Indexer.flush()));
  59   }
  60
  61   BlockVerifier Verifier;
  62   for (auto &ProcessThreadBlocks : Index) {
  63     auto &Blocks = ProcessThreadBlocks.second;
  64     for (auto &B : Blocks) {
  65       for (auto *R : B.Records)
  66         ASSERT_FALSE(errorToBool(R->apply(Verifier)));
  67       ASSERT_FALSE(errorToBool(Verifier.verify()));
  68       Verifier.reset();
  69     }
  70   }
  71 }
  72
  73 TEST(FDRBlockVerifierTest, MissingPIDRecord) {
  74   auto Block = LogBuilder()
  75                    .add<BufferExtents>(20)
  76                    .add<NewBufferRecord>(1)
  77                    .add<WallclockRecord>(1, 2)
  78                    .add<NewCPUIDRecord>(1, 2)
  79                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
  80                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
  81                    .consume();
  82   BlockVerifier Verifier;
  83   for (auto &R : Block)
  84     ASSERT_FALSE(errorToBool(R->apply(Verifier)));
  85   ASSERT_FALSE(errorToBool(Verifier.verify()));
  86 }
  87
  88 TEST(FDRBlockVerifierTest, MissingBufferExtents) {
  89   auto Block = LogBuilder()
  90                    .add<NewBufferRecord>(1)
  91                    .add<WallclockRecord>(1, 2)
  92                    .add<NewCPUIDRecord>(1, 2)
  93                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
  94                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
  95                    .consume();
  96   BlockVerifier Verifier;
  97   for (auto &R : Block)
  98     ASSERT_FALSE(errorToBool(R->apply(Verifier)));
  99   ASSERT_FALSE(errorToBool(Verifier.verify()));
 100 }
 101
 102 TEST(FDRBlockVerifierTest, IgnoreRecordsAfterEOB) {
 103   auto Block = LogBuilder()
 104                    .add<NewBufferRecord>(1)
 105                    .add<WallclockRecord>(1, 2)
 106                    .add<NewCPUIDRecord>(1, 2)
 107                    .add<EndBufferRecord>()
 108                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
 109                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
 110                    .consume();
 111   BlockVerifier Verifier;
 112   for (auto &R : Block)
 113     ASSERT_FALSE(errorToBool(R->apply(Verifier)));
 114   ASSERT_FALSE(errorToBool(Verifier.verify()));
 115 }
 116
 117 TEST(FDRBlockVerifierTest, MalformedV2) {
 118   auto Block = LogBuilder()
 119                    .add<NewBufferRecord>(1)
 120                    .add<WallclockRecord>(1, 2)
 121                    .add<NewCPUIDRecord>(1, 2)
 122                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
 123                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
 124                    .add<NewBufferRecord>(2)
 125                    .consume();
 126   BlockVerifier Verifier;
 127
 128   ASSERT_THAT(Block, SizeIs(6u));
 129   EXPECT_THAT_ERROR(Block[0]->apply(Verifier), Succeeded());
 130   EXPECT_THAT_ERROR(Block[1]->apply(Verifier), Succeeded());
 131   EXPECT_THAT_ERROR(Block[2]->apply(Verifier), Succeeded());
 132   EXPECT_THAT_ERROR(Block[3]->apply(Verifier), Succeeded());
 133   EXPECT_THAT_ERROR(Block[4]->apply(Verifier), Succeeded());
 134   EXPECT_THAT_ERROR(Block[5]->apply(Verifier), Failed());
 135 }
 136
 137 } // namespace
 138 } // namespace xray
 139 } // namespace llvm