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 auto nanoapp = MakeUnique<Nanoapp>();
45 auto nanoappInfo = MakeUnique<chreNslNanoappInfo>();
46 chreNslNanoappInfo *appInfo = nanoappInfo.get();
47 gNanoappInfos.push_back(std::move(nanoappInfo));
48 appInfo->magic = CHRE_NSL_NANOAPP_INFO_MAGIC;
49 appInfo->structMinorVersion = CHRE_NSL_NANOAPP_INFO_STRUCT_MINOR_VERSION;
50 appInfo->targetApiVersion = CHRE_API_VERSION;
51 appInfo->vendor = "Google";
52 appInfo->name = name;
53 appInfo->isSystemNanoapp = true;
54 appInfo->isTcmNanoapp = true;
55 appInfo->appId = appId;
56 appInfo->appVersion = appVersion;
57 appInfo->entryPoints.start = startFunc;
58 appInfo->entryPoints.handleEvent = handleEventFunc;
59 appInfo->entryPoints.end = endFunc;
60 appInfo->appVersionString = "<undefined>";
61 appInfo->appPermissions = appPerms;
62 EXPECT_FALSE(nanoapp.isNull());
63 nanoapp->loadStatic(appInfo);
64
65 return nanoapp;
66 }
67
deleteNanoappInfos()68 void deleteNanoappInfos() {
69 gNanoappInfos.clear();
70 }
71
defaultNanoappStart()72 bool defaultNanoappStart() {
73 return true;
74 }
75
defaultNanoappHandleEvent(uint32_t senderInstanceId,uint16_t eventType,const void * eventData)76 void defaultNanoappHandleEvent(uint32_t senderInstanceId, uint16_t eventType,
77 const void *eventData) {
78 UNUSED_VAR(senderInstanceId);
79 UNUSED_VAR(eventType);
80 UNUSED_VAR(eventData);
81 }
82
defaultNanoappEnd()83 void defaultNanoappEnd(){};
84
loadNanoapp(const char * name,uint64_t appId,uint32_t appVersion,uint32_t appPerms,decltype(nanoappStart) * startFunc,decltype(nanoappHandleEvent) * handleEventFunc,decltype(nanoappEnd) * endFunc)85 void loadNanoapp(const char *name, uint64_t appId, uint32_t appVersion,
86 uint32_t appPerms, decltype(nanoappStart) *startFunc,
87 decltype(nanoappHandleEvent) *handleEventFunc,
88 decltype(nanoappEnd) *endFunc) {
89 UniquePtr<Nanoapp> nanoapp = createStaticNanoapp(
90 name, appId, appVersion, appPerms, startFunc, handleEventFunc, endFunc);
91
92 EventLoopManagerSingleton::get()->deferCallback(
93 SystemCallbackType::FinishLoadingNanoapp, std::move(nanoapp),
94 testFinishLoadingNanoappCallback);
95
96 TestEventQueueSingleton::get()->waitForEvent(
97 CHRE_EVENT_SIMULATION_TEST_NANOAPP_LOADED);
98 }
99
100 template <>
unloadNanoapp(uint64_t appId)101 void unloadNanoapp<uint64_t>(uint64_t appId) {
102 uint64_t *ptr = memoryAlloc<uint64_t>();
103 ASSERT_NE(ptr, nullptr);
104 *ptr = appId;
105 EventLoopManagerSingleton::get()->deferCallback(
106 SystemCallbackType::HandleUnloadNanoapp, ptr,
107 testFinishUnloadingNanoappCallback);
108
109 TestEventQueueSingleton::get()->waitForEvent(
110 CHRE_EVENT_SIMULATION_TEST_NANOAPP_UNLOADED);
111 }
112
testFinishLoadingNanoappCallback(SystemCallbackType,UniquePtr<Nanoapp> && nanoapp)113 void testFinishLoadingNanoappCallback(SystemCallbackType /* type */,
114 UniquePtr<Nanoapp> &&nanoapp) {
115 EventLoopManagerSingleton::get()->getEventLoop().startNanoapp(nanoapp);
116 TestEventQueueSingleton::get()->pushEvent(
117 CHRE_EVENT_SIMULATION_TEST_NANOAPP_LOADED);
118 }
119
testFinishUnloadingNanoappCallback(uint16_t,void * data,void *)120 void testFinishUnloadingNanoappCallback(uint16_t /* type */, void *data,
121 void * /* extraData */) {
122 EventLoop &eventLoop = EventLoopManagerSingleton::get()->getEventLoop();
123 uint16_t instanceId = 0;
124 uint64_t *appId = static_cast<uint64_t *>(data);
125 eventLoop.findNanoappInstanceIdByAppId(*appId, &instanceId);
126 eventLoop.unloadNanoapp(instanceId, true);
127 memoryFree(data);
128 TestEventQueueSingleton::get()->pushEvent(
129 CHRE_EVENT_SIMULATION_TEST_NANOAPP_UNLOADED);
130 }
131
freeTestEventDataCallback(uint16_t,void * eventData)132 void freeTestEventDataCallback(uint16_t /*eventType*/, void *eventData) {
133 auto testEvent = static_cast<TestEvent *>(eventData);
134 memoryFree(testEvent->data);
135 memoryFree(testEvent);
136 }
137
138 } // namespace chre
139