1 /*
2 * Copyright (c) 2024, The OpenThread Authors.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. Neither the name of the copyright holder nor the
13 * names of its contributors may be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #ifndef OT_GTEST_FAKE_PLATFORM_HPP_
30 #define OT_GTEST_FAKE_PLATFORM_HPP_
31
32 #include "openthread-core-config.h"
33
34 #include <map>
35 #include <vector>
36
37 #include <inttypes.h>
38
39 #include <openthread/error.h>
40 #include <openthread/instance.h>
41 #include <openthread/platform/alarm-micro.h>
42 #include <openthread/platform/alarm-milli.h>
43 #include <openthread/platform/radio.h>
44 #include <openthread/platform/time.h>
45
46 namespace ot {
47
48 class FakePlatform
49 {
50 public:
51 FakePlatform();
52 virtual ~FakePlatform();
53
CurrentPlatform()54 static FakePlatform &CurrentPlatform() { return *sPlatform; }
CurrentInstance()55 static otInstance *CurrentInstance() { return CurrentPlatform().mInstance; }
56
57 /**
58 * Run until something happened or timeout.
59 *
60 * @param aTimeout The timeout in us.
61 *
62 * @returns the remaining timeout.
63 */
64 uint64_t Run(uint64_t aTimeoutInUs = 0);
65
66 void GoInUs(uint64_t aTimeoutInUs = 0);
67
GoInMs(uint32_t aTimeoutInMs=0)68 void GoInMs(uint32_t aTimeoutInMs = 0) { GoInUs(aTimeoutInMs * OT_US_PER_MS); }
69
GetNow() const70 virtual uint64_t GetNow() const { return mNow; }
71
72 virtual void StartMilliAlarm(uint32_t aT0, uint32_t aDt);
73 virtual void StopMilliAlarm();
74 #if OPENTHREAD_CONFIG_PLATFORM_USEC_TIMER_ENABLE
75 virtual void StartMicroAlarm(uint32_t aT0, uint32_t aDt);
76 virtual void StopMicroAlarm();
77 #endif
78
GetReceiveChannel(void) const79 uint8_t GetReceiveChannel(void) const { return mChannel; }
GetTransmitBuffer()80 virtual otRadioFrame *GetTransmitBuffer() { return &mTransmitFrame; }
81 virtual otError Transmit(otRadioFrame *aFrame);
ReceiveAt(uint8_t aChannel,uint32_t aStart,uint32_t aDuration)82 virtual otError ReceiveAt(uint8_t aChannel, uint32_t aStart, uint32_t aDuration)
83 {
84 mReceiveAtChannel = aChannel;
85 mReceiveAtStart = mNow + aStart;
86 mReceiveAtEnd = mReceiveAtStart + aDuration;
87
88 return OT_ERROR_NONE;
89 }
90
Receive(uint8_t aChannel)91 virtual otError Receive(uint8_t aChannel)
92 {
93 mChannel = aChannel;
94 return OT_ERROR_NONE;
95 }
96
97 virtual otError SettingsGet(uint16_t aKey, uint16_t aIndex, uint8_t *aValue, uint16_t *aValueLength) const;
98 virtual otError SettingsSet(uint16_t aKey, const uint8_t *aValue, uint16_t aValueLength);
99 virtual otError SettingsAdd(uint16_t aKey, const uint8_t *aValue, uint16_t aValueLength);
100 virtual otError SettingsDelete(uint16_t aKey, int aIndex);
101 virtual void SettingsWipe();
102
103 virtual void FlashInit();
104 virtual void FlashErase(uint8_t aSwapIndex);
105 virtual void FlashRead(uint8_t aSwapIndex, uint32_t aOffset, void *aData, uint32_t aSize) const;
106 virtual void FlashWrite(uint8_t aSwapIndex, uint32_t aOffset, const void *aData, uint32_t aSize);
FlashGetSwapSize() const107 virtual uint32_t FlashGetSwapSize() const { return kFlashSwapSize; }
108
GetEui64() const109 virtual uint64_t GetEui64() const { return 0; }
110
111 protected:
112 void ProcessSchedules(uint64_t &aTimeout);
113
114 static constexpr uint64_t kAlarmStop = 0xffffffffffffffffUL;
115
116 static constexpr uint32_t kFlashSwapSize = 2048;
117 static constexpr uint32_t kFlashSwapNum = 2;
118
119 static FakePlatform *sPlatform;
120
121 otInstance *mInstance = nullptr;
122
123 uint64_t mNow = 0;
124 #if OPENTHREAD_CONFIG_PLATFORM_USEC_TIMER_ENABLE
125 uint64_t mMicroAlarmStart = kAlarmStop;
126 #endif
127 uint64_t mMilliAlarmStart = kAlarmStop;
128
129 uint64_t mReceiveAtStart = kAlarmStop;
130 uint64_t mReceiveAtEnd = kAlarmStop;
131
132 template <uint64_t FakePlatform::*T> void HandleSchedule();
133
134 otRadioFrame mTransmitFrame;
135 uint8_t mTransmitBuffer[OT_RADIO_FRAME_MAX_SIZE];
136 uint8_t mChannel = 0;
137 uint8_t mReceiveAtChannel = 0;
138
139 uint8_t mFlash[kFlashSwapSize * kFlashSwapNum];
140
141 std::map<uint32_t, std::vector<std::vector<uint8_t>>> mSettings;
142 };
143
HandleSchedule()144 template <> inline void FakePlatform::HandleSchedule<&FakePlatform::mMilliAlarmStart>()
145 {
146 otPlatAlarmMilliFired(mInstance);
147 }
148
149 #if OPENTHREAD_CONFIG_PLATFORM_USEC_TIMER_ENABLE
HandleSchedule()150 template <> inline void FakePlatform::HandleSchedule<&FakePlatform::mMicroAlarmStart>()
151 {
152 otPlatAlarmMicroFired(mInstance);
153 }
154 #endif
155
156 } // namespace ot
157
158 #endif // OT_GTEST_FAKE_PLATFORM_HPP_
159
