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 "test_util.h"
18
19 #include <gtest/gtest.h>
20
21 #include "chre/core/event_loop_manager.h"
22 #include "chre/core/nanoapp.h"
23 #include "chre/util/dynamic_vector.h"
24 #include "chre/util/macros.h"
25 #include "chre/util/memory.h"
26 #include "chre_api/chre/version.h"
27 #include "nanoapp/include/chre_nsl_internal/platform/shared/nanoapp_support_lib_dso.h"
28
29 namespace chre {
30
31 namespace {
32
33 // Keep the chreNslNanoappInfo instances alive for the lifetime of the
34 // test nanoapps.
35 DynamicVector<UniquePtr<chreNslNanoappInfo>> gNanoappInfos;
36
37 } // namespace
38
createStaticNanoapp(const char * name,uint64_t appId,uint32_t appVersion,uint32_t appPerms,decltype(nanoappStart) * startFunc,decltype(nanoappHandleEvent) * handleEventFunc,decltype(nanoappEnd) * endFunc)39 UniquePtr<Nanoapp> createStaticNanoapp(
40 const char *name, uint64_t appId, uint32_t appVersion, uint32_t appPerms,
41 decltype(nanoappStart) *startFunc,
42 decltype(nanoappHandleEvent) *handleEventFunc,
43 decltype(nanoappEnd) *endFunc) {
44 return createStaticNanoapp(CHRE_NSL_NANOAPP_INFO_STRUCT_MINOR_VERSION, name,
45 appId, appVersion, appPerms, startFunc,
46 handleEventFunc, endFunc);
47 }
48
createStaticNanoapp(uint8_t infoStructVersion,const char * name,uint64_t appId,uint32_t appVersion,uint32_t appPerms,decltype(nanoappStart) * startFunc,decltype(nanoappHandleEvent) * handleEventFunc,decltype(nanoappEnd) * endFunc)49 UniquePtr<Nanoapp> createStaticNanoapp(
50 uint8_t infoStructVersion, const char *name, uint64_t appId,
51 uint32_t appVersion, uint32_t appPerms, decltype(nanoappStart) *startFunc,
52 decltype(nanoappHandleEvent) *handleEventFunc,
53 decltype(nanoappEnd) *endFunc) {
54 auto nanoapp = MakeUnique<Nanoapp>();
55 auto nanoappInfo = MakeUnique<chreNslNanoappInfo>();
56 chreNslNanoappInfo *appInfo = nanoappInfo.get();
57 gNanoappInfos.push_back(std::move(nanoappInfo));
58 appInfo->magic = CHRE_NSL_NANOAPP_INFO_MAGIC;
59 appInfo->structMinorVersion = infoStructVersion;
60 appInfo->targetApiVersion = CHRE_API_VERSION;
61 appInfo->vendor = "Google";
62 appInfo->name = name;
63 appInfo->isSystemNanoapp = true;
64 appInfo->isTcmNanoapp = true;
65 appInfo->appId = appId;
66 appInfo->appVersion = appVersion;
67 appInfo->entryPoints.start = startFunc;
68 appInfo->entryPoints.handleEvent = handleEventFunc;
69 appInfo->entryPoints.end = endFunc;
70 appInfo->appVersionString = "<undefined>";
71 appInfo->appPermissions = appPerms;
72 EXPECT_FALSE(nanoapp.isNull());
73 nanoapp->loadStatic(appInfo);
74
75 return nanoapp;
76 }
77
deleteNanoappInfos()78 void deleteNanoappInfos() {
79 gNanoappInfos.clear();
80 }
81
defaultNanoappStart()82 bool defaultNanoappStart() {
83 return true;
84 }
85
defaultNanoappHandleEvent(uint32_t senderInstanceId,uint16_t eventType,const void * eventData)86 void defaultNanoappHandleEvent(uint32_t senderInstanceId, uint16_t eventType,
87 const void *eventData) {
88 UNUSED_VAR(senderInstanceId);
89 UNUSED_VAR(eventType);
90 UNUSED_VAR(eventData);
91 }
92
defaultNanoappEnd()93 void defaultNanoappEnd(){};
94
loadNanoapp(const char * name,uint64_t appId,uint32_t appVersion,uint32_t appPerms,decltype(nanoappStart) * startFunc,decltype(nanoappHandleEvent) * handleEventFunc,decltype(nanoappEnd) * endFunc)95 void loadNanoapp(const char *name, uint64_t appId, uint32_t appVersion,
96 uint32_t appPerms, decltype(nanoappStart) *startFunc,
97 decltype(nanoappHandleEvent) *handleEventFunc,
98 decltype(nanoappEnd) *endFunc) {
99 UniquePtr<Nanoapp> nanoapp = createStaticNanoapp(
100 name, appId, appVersion, appPerms, startFunc, handleEventFunc, endFunc);
101
102 EventLoopManagerSingleton::get()->deferCallback(
103 SystemCallbackType::FinishLoadingNanoapp, std::move(nanoapp),
104 testFinishLoadingNanoappCallback);
105
106 TestEventQueueSingleton::get()->waitForEvent(
107 CHRE_EVENT_SIMULATION_TEST_NANOAPP_LOADED);
108 }
109
110 template <>
unloadNanoapp(uint64_t appId)111 void unloadNanoapp<uint64_t>(uint64_t appId) {
112 uint64_t *ptr = memoryAlloc<uint64_t>();
113 ASSERT_NE(ptr, nullptr);
114 *ptr = appId;
115 EventLoopManagerSingleton::get()->deferCallback(
116 SystemCallbackType::HandleUnloadNanoapp, ptr,
117 testFinishUnloadingNanoappCallback);
118
119 TestEventQueueSingleton::get()->waitForEvent(
120 CHRE_EVENT_SIMULATION_TEST_NANOAPP_UNLOADED);
121 }
122
testFinishLoadingNanoappCallback(SystemCallbackType,UniquePtr<Nanoapp> && nanoapp)123 void testFinishLoadingNanoappCallback(SystemCallbackType /* type */,
124 UniquePtr<Nanoapp> &&nanoapp) {
125 EventLoopManagerSingleton::get()->getEventLoop().startNanoapp(nanoapp);
126 TestEventQueueSingleton::get()->pushEvent(
127 CHRE_EVENT_SIMULATION_TEST_NANOAPP_LOADED);
128 }
129
testFinishUnloadingNanoappCallback(uint16_t,void * data,void *)130 void testFinishUnloadingNanoappCallback(uint16_t /* type */, void *data,
131 void * /* extraData */) {
132 EventLoop &eventLoop = EventLoopManagerSingleton::get()->getEventLoop();
133 uint16_t instanceId = 0;
134 uint64_t *appId = static_cast<uint64_t *>(data);
135 eventLoop.findNanoappInstanceIdByAppId(*appId, &instanceId);
136 eventLoop.unloadNanoapp(instanceId, true);
137 memoryFree(data);
138 TestEventQueueSingleton::get()->pushEvent(
139 CHRE_EVENT_SIMULATION_TEST_NANOAPP_UNLOADED);
140 }
141
freeTestEventDataCallback(uint16_t,void * eventData)142 void freeTestEventDataCallback(uint16_t /*eventType*/, void *eventData) {
143 auto testEvent = static_cast<TestEvent *>(eventData);
144 memoryFree(testEvent->data);
145 memoryFree(testEvent);
146 }
147
148 } // namespace chre
149