1 /** 2 * Copyright © 2019 IBM Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #include "elog_entry.hpp" 17 #include "extensions/openpower-pels/pel_types.hpp" 18 #include "extensions/openpower-pels/private_header.hpp" 19 #include "extensions/openpower-pels/user_header.hpp" 20 #include "mocks.hpp" 21 #include "pel_utils.hpp" 22 23 #include <gtest/gtest.h> 24 25 using namespace openpower::pels; 26 using ::testing::Return; 27 28 TEST(UserHeaderTest, SizeTest) 29 { 30 EXPECT_EQ(UserHeader::flattenedSize(), 24); 31 } 32 33 TEST(UserHeaderTest, UnflattenFlattenTest) 34 { 35 auto data = pelDataFactory(TestPELType::userHeaderSection); 36 37 Stream stream(data); 38 UserHeader uh(stream); 39 EXPECT_EQ(uh.valid(), true); 40 41 EXPECT_EQ(uh.header().id, 0x5548); 42 EXPECT_EQ(uh.header().size, UserHeader::flattenedSize()); 43 EXPECT_EQ(uh.header().version, 0x01); 44 EXPECT_EQ(uh.header().subType, 0x0A); 45 EXPECT_EQ(uh.header().componentID, 0x0B0C); 46 47 EXPECT_EQ(uh.subsystem(), 0x10); 48 EXPECT_EQ(uh.scope(), 0x04); 49 EXPECT_EQ(uh.severity(), 0x20); 50 EXPECT_EQ(uh.eventType(), 0x00); 51 EXPECT_EQ(uh.problemDomain(), 0x03); 52 EXPECT_EQ(uh.problemVector(), 0x04); 53 EXPECT_EQ(uh.actionFlags(), 0x80C0); 54 55 // Now flatten into a vector and check that this vector 56 // matches the original one. 57 std::vector<uint8_t> newData; 58 Stream newStream(newData); 59 60 uh.flatten(newStream); 61 EXPECT_EQ(data, newData); 62 } 63 64 TEST(UserHeaderTest, ShortDataTest) 65 { 66 auto data = pelDataFactory(TestPELType::userHeaderSection); 67 data.resize(data.size() - 1); 68 69 Stream stream(data); 70 UserHeader uh(stream); 71 72 EXPECT_EQ(uh.valid(), false); 73 } 74 75 TEST(UserHeaderTest, CorruptDataTest1) 76 { 77 auto data = pelDataFactory(TestPELType::userHeaderSection); 78 data.resize(data.size() - 1); 79 80 data.at(0) = 0; // corrupt the section ID 81 82 Stream stream(data); 83 UserHeader uh(stream); 84 85 EXPECT_EQ(uh.valid(), false); 86 } 87 88 TEST(UserHeaderTest, CorruptDataTest2) 89 { 90 auto data = pelDataFactory(TestPELType::userHeaderSection); 91 92 data.at(4) = 0x22; // corrupt the version 93 94 Stream stream(data); 95 UserHeader uh(stream); 96 97 EXPECT_EQ(uh.valid(), false); 98 } 99 100 // Construct the User Header from the message registry 101 TEST(UserHeaderTest, ConstructionTest) 102 { 103 using namespace openpower::pels::message; 104 { 105 Entry regEntry; 106 107 regEntry.name = "test"; 108 regEntry.subsystem = 5; 109 regEntry.severity = {{"", 0x40}}; 110 regEntry.actionFlags = 0xC000; 111 regEntry.eventType = 1; 112 regEntry.eventScope = 2; 113 114 MockDataInterface dataIface; 115 EXPECT_CALL(dataIface, getSystemType).WillOnce(Return("systemA")); 116 117 UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error, 118 dataIface); 119 120 ASSERT_TRUE(uh.valid()); 121 EXPECT_EQ(uh.header().id, 0x5548); 122 EXPECT_EQ(uh.header().size, UserHeader::flattenedSize()); 123 EXPECT_EQ(uh.header().version, 0x01); 124 EXPECT_EQ(uh.header().subType, 0x00); 125 EXPECT_EQ(uh.header().componentID, 126 static_cast<uint16_t>(ComponentID::phosphorLogging)); 127 128 ASSERT_EQ(uh.subsystem(), 5); 129 ASSERT_EQ(uh.severity(), 0x40); 130 ASSERT_EQ(uh.eventType(), 1); 131 ASSERT_EQ(uh.scope(), 2); 132 ASSERT_EQ(uh.problemDomain(), 0); 133 ASSERT_EQ(uh.problemVector(), 0); 134 ASSERT_EQ(uh.actionFlags(), 0xC000); 135 } 136 137 // Test the system type based severity lookups 138 { 139 Entry regEntry; 140 141 regEntry.name = "test"; 142 regEntry.subsystem = 5; 143 regEntry.severity = {{"", 0x20}, {"systemB", 0x10}, {"systemA", 0x00}}; 144 145 MockDataInterface dataIface; 146 EXPECT_CALL(dataIface, getSystemType) 147 .WillOnce(Return("systemA")) 148 .WillOnce(Return("systemB")) 149 .WillOnce(Return("systemC")); 150 151 { 152 UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error, 153 dataIface); 154 155 EXPECT_EQ(uh.severity(), 0x00); 156 } 157 158 { 159 UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error, 160 dataIface); 161 162 EXPECT_EQ(uh.severity(), 0x10); 163 } 164 165 { 166 UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error, 167 dataIface); 168 169 EXPECT_EQ(uh.severity(), 0x20); 170 } 171 } 172 } 173 174 // Test that the severity comes from the event log if not 175 // in the message registry 176 TEST(UserHeaderTest, UseEventLogSevTest) 177 { 178 using namespace openpower::pels::message; 179 Entry regEntry; 180 181 regEntry.name = "test"; 182 regEntry.subsystem = 5; 183 regEntry.actionFlags = 0xC000; 184 regEntry.eventType = 1; 185 regEntry.eventScope = 2; 186 // Leave off severity 187 188 MockDataInterface dataIface; 189 190 UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error, dataIface); 191 ASSERT_EQ(uh.severity(), 0x40); 192 } 193 194 // Test that the optional event type & scope fields work 195 TEST(UserHeaderTest, DefaultEventTypeScopeTest) 196 { 197 using namespace openpower::pels::message; 198 Entry regEntry; 199 200 regEntry.name = "test"; 201 regEntry.subsystem = 5; 202 regEntry.severity = {{"", 0x40}}; 203 regEntry.actionFlags = 0xC000; 204 205 MockDataInterface dataIface; 206 207 UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error, dataIface); 208 209 ASSERT_EQ(uh.eventType(), 0); 210 ASSERT_EQ(uh.scope(), 0x03); 211 } 212