1 /*
2 * Copyright (C) 2021 The Android Open Source Project
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
17 #include "FakeObd2Frame.h"
18
19 #include <PropertyUtils.h>
20 #include <VehicleObjectPool.h>
21 #include <VehiclePropertyStore.h>
22 #include <gtest/gtest.h>
23 #include <utils/SystemClock.h>
24
25 #include <set>
26
27 namespace android {
28 namespace hardware {
29 namespace automotive {
30 namespace vehicle {
31 namespace fake {
32 namespace obd2frame {
33
34 using ::aidl::android::hardware::automotive::vehicle::VehiclePropConfig;
35 using ::aidl::android::hardware::automotive::vehicle::VehicleProperty;
36 using ::aidl::android::hardware::automotive::vehicle::VehiclePropertyAccess;
37 using ::aidl::android::hardware::automotive::vehicle::VehiclePropertyChangeMode;
38 using ::aidl::android::hardware::automotive::vehicle::VehiclePropValue;
39
40 class FakeObd2FrameTest : public ::testing::Test {
41 protected:
SetUp()42 void SetUp() override {
43 std::shared_ptr<VehiclePropValuePool> valuePool = std::make_shared<VehiclePropValuePool>();
44 mPropertyStore = std::make_shared<VehiclePropertyStore>(valuePool);
45 mObd2Frame = std::make_unique<FakeObd2Frame>(mPropertyStore);
46
47 mPropertyStore->registerProperty(getObd2LiveFrameConfig());
48 mPropertyStore->registerProperty(
49 getObd2FreezeFrameConfig(),
50 [](const VehiclePropValue& propValue) { return propValue.timestamp; });
51 mPropertyStore->registerProperty(getObd2FreezeFrameInfoConfig());
52 }
53
getObd2LiveFrameConfig()54 VehiclePropConfig getObd2LiveFrameConfig() {
55 return VehiclePropConfig{.prop = OBD2_LIVE_FRAME,
56 .access = VehiclePropertyAccess::READ,
57 .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
58 .configArray = {1, 1}};
59 }
60
getObd2FreezeFrameConfig()61 VehiclePropConfig getObd2FreezeFrameConfig() {
62 return VehiclePropConfig{.prop = OBD2_FREEZE_FRAME,
63 .access = VehiclePropertyAccess::READ,
64 .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
65 .configArray = {0, 0}};
66 }
67
getObd2FreezeFrameInfoConfig()68 VehiclePropConfig getObd2FreezeFrameInfoConfig() {
69 return VehiclePropConfig{.prop = OBD2_FREEZE_FRAME_INFO,
70 .access = VehiclePropertyAccess::READ,
71 .changeMode = VehiclePropertyChangeMode::ON_CHANGE};
72 }
73
getFakeObd2Frame()74 FakeObd2Frame* getFakeObd2Frame() { return mObd2Frame.get(); }
75
getPropertyStore()76 VehiclePropertyStore* getPropertyStore() { return mPropertyStore.get(); }
77
78 private:
79 std::unique_ptr<FakeObd2Frame> mObd2Frame;
80 std::shared_ptr<VehiclePropertyStore> mPropertyStore;
81 };
82
TEST_F(FakeObd2FrameTest,testIsDiagnosticPropertyTrue)83 TEST_F(FakeObd2FrameTest, testIsDiagnosticPropertyTrue) {
84 for (auto prop : std::vector<int32_t>({
85 OBD2_LIVE_FRAME,
86 OBD2_FREEZE_FRAME,
87 OBD2_FREEZE_FRAME_CLEAR,
88 OBD2_FREEZE_FRAME_INFO,
89 })) {
90 EXPECT_TRUE(FakeObd2Frame::isDiagnosticProperty(VehiclePropConfig{
91 .prop = prop,
92 }));
93 }
94 }
95
TEST_F(FakeObd2FrameTest,testIsDiagnosticPropertyFalse)96 TEST_F(FakeObd2FrameTest, testIsDiagnosticPropertyFalse) {
97 ASSERT_FALSE(FakeObd2Frame::isDiagnosticProperty(VehiclePropConfig{
98 .prop = toInt(VehicleProperty::INFO_VIN),
99 }));
100 }
101
TEST_F(FakeObd2FrameTest,testInitObd2LiveFrame)102 TEST_F(FakeObd2FrameTest, testInitObd2LiveFrame) {
103 int64_t timestamp = elapsedRealtimeNano();
104
105 getFakeObd2Frame()->initObd2LiveFrame(getObd2LiveFrameConfig());
106
107 auto result = getPropertyStore()->readValue(OBD2_LIVE_FRAME);
108
109 ASSERT_TRUE(result.ok());
110 auto& value = result.value();
111
112 EXPECT_GE(value->timestamp, timestamp);
113 EXPECT_EQ(value->value.stringValue, "");
114 EXPECT_EQ(value->value.int32Values.size(), static_cast<size_t>(33));
115 EXPECT_EQ(value->value.floatValues.size(), static_cast<size_t>(72));
116 }
117
TEST_F(FakeObd2FrameTest,testInitFreezeFrame)118 TEST_F(FakeObd2FrameTest, testInitFreezeFrame) {
119 getFakeObd2Frame()->initObd2FreezeFrame(getObd2FreezeFrameConfig());
120
121 auto result = getPropertyStore()->readValuesForProperty(OBD2_FREEZE_FRAME);
122
123 ASSERT_TRUE(result.ok());
124 ASSERT_EQ(result.value().size(), static_cast<size_t>(3));
125 }
126
TEST_F(FakeObd2FrameTest,testGetObd2DtcInfo)127 TEST_F(FakeObd2FrameTest, testGetObd2DtcInfo) {
128 getFakeObd2Frame()->initObd2FreezeFrame(getObd2FreezeFrameConfig());
129
130 auto result = getFakeObd2Frame()->getObd2DtcInfo();
131
132 ASSERT_TRUE(result.ok());
133 EXPECT_EQ(result.value()->prop, OBD2_FREEZE_FRAME_INFO);
134 EXPECT_EQ(result.value()->value.int64Values.size(), static_cast<size_t>(3));
135 }
136
TEST_F(FakeObd2FrameTest,testGetObd2FreezeFrame)137 TEST_F(FakeObd2FrameTest, testGetObd2FreezeFrame) {
138 getFakeObd2Frame()->initObd2FreezeFrame(getObd2FreezeFrameConfig());
139
140 auto result = getFakeObd2Frame()->getObd2DtcInfo();
141
142 ASSERT_TRUE(result.ok());
143 ASSERT_EQ(result.value()->prop, OBD2_FREEZE_FRAME_INFO);
144 ASSERT_EQ(result.value()->value.int64Values.size(), static_cast<size_t>(3));
145
146 std::set<std::string> dtcs;
147
148 for (int64_t timestamp : result.value()->value.int64Values) {
149 auto freezeFrameResult = getFakeObd2Frame()->getObd2FreezeFrame(VehiclePropValue{
150 .value.int64Values = {timestamp},
151 });
152
153 ASSERT_TRUE(freezeFrameResult.ok());
154
155 dtcs.insert(freezeFrameResult.value()->value.stringValue);
156 }
157
158 ASSERT_EQ(dtcs, std::set<std::string>({"P0070", "P0102", "P0123"}));
159 }
160
TEST_F(FakeObd2FrameTest,testClearObd2FreezeFrameAll)161 TEST_F(FakeObd2FrameTest, testClearObd2FreezeFrameAll) {
162 getFakeObd2Frame()->initObd2FreezeFrame(getObd2FreezeFrameConfig());
163
164 auto result = getFakeObd2Frame()->getObd2DtcInfo();
165
166 ASSERT_TRUE(result.ok());
167 ASSERT_EQ(result.value()->prop, OBD2_FREEZE_FRAME_INFO);
168 ASSERT_EQ(result.value()->value.int64Values.size(), static_cast<size_t>(3));
169
170 ASSERT_TRUE(getFakeObd2Frame()->clearObd2FreezeFrames(VehiclePropValue{}).ok());
171
172 result = getFakeObd2Frame()->getObd2DtcInfo();
173
174 ASSERT_TRUE(result.ok());
175 EXPECT_EQ(result.value()->prop, OBD2_FREEZE_FRAME_INFO);
176 EXPECT_EQ(result.value()->value.int64Values.size(), static_cast<size_t>(0));
177 }
178
TEST_F(FakeObd2FrameTest,testClearObd2FreezeFrameByTimestamp)179 TEST_F(FakeObd2FrameTest, testClearObd2FreezeFrameByTimestamp) {
180 getFakeObd2Frame()->initObd2FreezeFrame(getObd2FreezeFrameConfig());
181
182 auto result = getFakeObd2Frame()->getObd2DtcInfo();
183
184 ASSERT_TRUE(result.ok());
185 ASSERT_EQ(result.value()->prop, OBD2_FREEZE_FRAME_INFO);
186 ASSERT_EQ(result.value()->value.int64Values.size(), static_cast<size_t>(3));
187
188 ASSERT_TRUE(getFakeObd2Frame()
189 ->clearObd2FreezeFrames(VehiclePropValue{
190 .value.int64Values = {result.value()->value.int64Values[0],
191 result.value()->value.int64Values[1]}})
192 .ok());
193
194 result = getFakeObd2Frame()->getObd2DtcInfo();
195
196 ASSERT_TRUE(result.ok());
197 EXPECT_EQ(result.value()->prop, OBD2_FREEZE_FRAME_INFO);
198 EXPECT_EQ(result.value()->value.int64Values.size(), static_cast<size_t>(1));
199 }
200
201 } // namespace obd2frame
202 } // namespace fake
203 } // namespace vehicle
204 } // namespace automotive
205 } // namespace hardware
206 } // namespace android
207