takashi kadono / Mbed OS Nucleo446_SSD1331

Color Oled(SSD1331) connect to STMicroelectronics Nucleo-F466

Dependencies:   ssd1331

mbed-os/TESTS/mbedmicro-rtos-mbed/threads/main.cpp@3:f3764f852aa8, 2018-10-11 (annotated)

Committer:
kadonotakashi
Date:
Thu Oct 11 02:27:46 2018 +0000
Revision:
3:f3764f852aa8
Parent:
0:8fdf9a60065b 
Nucreo 446 + SSD1331 test version;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
kadonotakashi 0:8fdf9a60065b 1 /* mbed Microcontroller Library
kadonotakashi 0:8fdf9a60065b 2 * Copyright (c) 2017 ARM Limited
kadonotakashi 0:8fdf9a60065b 3 *
kadonotakashi 0:8fdf9a60065b 4 * Licensed under the Apache License, Version 2.0 (the "License");
kadonotakashi 0:8fdf9a60065b 5 * you may not use this file except in compliance with the License.
kadonotakashi 0:8fdf9a60065b 6 * You may obtain a copy of the License at
kadonotakashi 0:8fdf9a60065b 7 *
kadonotakashi 0:8fdf9a60065b 8 * http://www.apache.org/licenses/LICENSE-2.0
kadonotakashi 0:8fdf9a60065b 9 *
kadonotakashi 0:8fdf9a60065b 10 * Unless required by applicable law or agreed to in writing, software
kadonotakashi 0:8fdf9a60065b 11 * distributed under the License is distributed on an "AS IS" BASIS,
kadonotakashi 0:8fdf9a60065b 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
kadonotakashi 0:8fdf9a60065b 13 * See the License for the specific language governing permissions and
kadonotakashi 0:8fdf9a60065b 14 * limitations under the License.
kadonotakashi 0:8fdf9a60065b 15 */
kadonotakashi 0:8fdf9a60065b 16 #include "mbed.h"
kadonotakashi 0:8fdf9a60065b 17 #include "greentea-client/test_env.h"
kadonotakashi 0:8fdf9a60065b 18 #include "unity.h"
kadonotakashi 0:8fdf9a60065b 19 #include "utest.h"
kadonotakashi 0:8fdf9a60065b 20 #include "rtos.h"
kadonotakashi 0:8fdf9a60065b 21 #include "SynchronizedIntegral.h"
kadonotakashi 0:8fdf9a60065b 22 #include "LockGuard.h"
kadonotakashi 0:8fdf9a60065b 23
kadonotakashi 0:8fdf9a60065b 24 #if defined(MBED_RTOS_SINGLE_THREAD)
kadonotakashi 0:8fdf9a60065b 25 #error [NOT_SUPPORTED] test not supported
kadonotakashi 0:8fdf9a60065b 26 #endif
kadonotakashi 0:8fdf9a60065b 27
kadonotakashi 0:8fdf9a60065b 28 #if !DEVICE_USTICKER
kadonotakashi 0:8fdf9a60065b 29 #error [NOT_SUPPORTED] test not supported
kadonotakashi 0:8fdf9a60065b 30 #endif
kadonotakashi 0:8fdf9a60065b 31
kadonotakashi 0:8fdf9a60065b 32 #define THREAD_STACK_SIZE 512
kadonotakashi 0:8fdf9a60065b 33 #if defined(__CORTEX_A9)
kadonotakashi 0:8fdf9a60065b 34 #define PARALLEL_THREAD_STACK_SIZE 512
kadonotakashi 0:8fdf9a60065b 35 #elif defined(__CORTEX_M23) || defined(__CORTEX_M33)
kadonotakashi 0:8fdf9a60065b 36 #define PARALLEL_THREAD_STACK_SIZE 512
kadonotakashi 0:8fdf9a60065b 37 #elif defined(__ARM_FM)
kadonotakashi 0:8fdf9a60065b 38 #define PARALLEL_THREAD_STACK_SIZE 512
kadonotakashi 0:8fdf9a60065b 39 #else
kadonotakashi 0:8fdf9a60065b 40 #define PARALLEL_THREAD_STACK_SIZE 384
kadonotakashi 0:8fdf9a60065b 41 #endif
kadonotakashi 0:8fdf9a60065b 42 #define CHILD_THREAD_STACK_SIZE 384
kadonotakashi 0:8fdf9a60065b 43
kadonotakashi 0:8fdf9a60065b 44 using namespace utest::v1;
kadonotakashi 0:8fdf9a60065b 45
kadonotakashi 0:8fdf9a60065b 46 // The counter type used accross all the tests
kadonotakashi 0:8fdf9a60065b 47 // It is internall ysynchronized so read
kadonotakashi 0:8fdf9a60065b 48 typedef SynchronizedIntegral<int> counter_t;
kadonotakashi 0:8fdf9a60065b 49
kadonotakashi 0:8fdf9a60065b 50 template<osPriority P, uint32_t S>
kadonotakashi 0:8fdf9a60065b 51 class ParallelThread : public Thread {
kadonotakashi 0:8fdf9a60065b 52 public:
kadonotakashi 0:8fdf9a60065b 53 ParallelThread() : Thread(P, S) { }
kadonotakashi 0:8fdf9a60065b 54 };
kadonotakashi 0:8fdf9a60065b 55
kadonotakashi 0:8fdf9a60065b 56 // Tasks with different functions to test on threads
kadonotakashi 0:8fdf9a60065b 57 void increment(counter_t *counter)
kadonotakashi 0:8fdf9a60065b 58 {
kadonotakashi 0:8fdf9a60065b 59 (*counter)++;
kadonotakashi 0:8fdf9a60065b 60 }
kadonotakashi 0:8fdf9a60065b 61
kadonotakashi 0:8fdf9a60065b 62 void increment_with_yield(counter_t *counter)
kadonotakashi 0:8fdf9a60065b 63 {
kadonotakashi 0:8fdf9a60065b 64 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 65 (*counter)++;
kadonotakashi 0:8fdf9a60065b 66 }
kadonotakashi 0:8fdf9a60065b 67
kadonotakashi 0:8fdf9a60065b 68 void increment_with_wait(counter_t *counter)
kadonotakashi 0:8fdf9a60065b 69 {
kadonotakashi 0:8fdf9a60065b 70 ThisThread::sleep_for(100);
kadonotakashi 0:8fdf9a60065b 71 (*counter)++;
kadonotakashi 0:8fdf9a60065b 72 }
kadonotakashi 0:8fdf9a60065b 73
kadonotakashi 0:8fdf9a60065b 74 void increment_with_child(counter_t *counter)
kadonotakashi 0:8fdf9a60065b 75 {
kadonotakashi 0:8fdf9a60065b 76 Thread *child = new (std::nothrow) Thread(osPriorityNormal, CHILD_THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 77 char *dummy = new (std::nothrow) char[CHILD_THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 78 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 79
kadonotakashi 0:8fdf9a60065b 80 // Don't fail test due to lack of memory. Call function directly instead
kadonotakashi 0:8fdf9a60065b 81 if (!child || !dummy) {
kadonotakashi 0:8fdf9a60065b 82 increment(counter);
kadonotakashi 0:8fdf9a60065b 83 delete child;
kadonotakashi 0:8fdf9a60065b 84 return;
kadonotakashi 0:8fdf9a60065b 85 }
kadonotakashi 0:8fdf9a60065b 86 child->start(callback(increment, counter));
kadonotakashi 0:8fdf9a60065b 87 child->join();
kadonotakashi 0:8fdf9a60065b 88 delete child;
kadonotakashi 0:8fdf9a60065b 89 }
kadonotakashi 0:8fdf9a60065b 90
kadonotakashi 0:8fdf9a60065b 91 void increment_with_murder(counter_t *counter)
kadonotakashi 0:8fdf9a60065b 92 {
kadonotakashi 0:8fdf9a60065b 93 {
kadonotakashi 0:8fdf9a60065b 94 // take ownership of the counter mutex so it prevent the child to
kadonotakashi 0:8fdf9a60065b 95 // modify counter.
kadonotakashi 0:8fdf9a60065b 96 LockGuard lock(counter->internal_mutex());
kadonotakashi 0:8fdf9a60065b 97 Thread *child = new (std::nothrow) Thread(osPriorityNormal, CHILD_THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 98 char *dummy = new (std::nothrow) char[CHILD_THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 99 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 100
kadonotakashi 0:8fdf9a60065b 101 // Don't fail test due to lack of memory.
kadonotakashi 0:8fdf9a60065b 102 if (!child || !dummy) {
kadonotakashi 0:8fdf9a60065b 103 delete child;
kadonotakashi 0:8fdf9a60065b 104 goto end;
kadonotakashi 0:8fdf9a60065b 105 }
kadonotakashi 0:8fdf9a60065b 106 child->start(callback(increment, counter));
kadonotakashi 0:8fdf9a60065b 107 child->terminate();
kadonotakashi 0:8fdf9a60065b 108 delete child;
kadonotakashi 0:8fdf9a60065b 109 }
kadonotakashi 0:8fdf9a60065b 110
kadonotakashi 0:8fdf9a60065b 111 end:
kadonotakashi 0:8fdf9a60065b 112 (*counter)++;
kadonotakashi 0:8fdf9a60065b 113 }
kadonotakashi 0:8fdf9a60065b 114
kadonotakashi 0:8fdf9a60065b 115 void self_terminate(Thread *self)
kadonotakashi 0:8fdf9a60065b 116 {
kadonotakashi 0:8fdf9a60065b 117 self->terminate();
kadonotakashi 0:8fdf9a60065b 118 // Code should not get here
kadonotakashi 0:8fdf9a60065b 119 TEST_ASSERT(0);
kadonotakashi 0:8fdf9a60065b 120 }
kadonotakashi 0:8fdf9a60065b 121
kadonotakashi 0:8fdf9a60065b 122 // Tests that spawn tasks in different configurations
kadonotakashi 0:8fdf9a60065b 123
kadonotakashi 0:8fdf9a60065b 124 /** Template for tests: single thread, with yield, with wait, with child, with murder
kadonotakashi 0:8fdf9a60065b 125
kadonotakashi 0:8fdf9a60065b 126 Testing single thread
kadonotakashi 0:8fdf9a60065b 127 Given single thread is started
kadonotakashi 0:8fdf9a60065b 128 when the thread increments the counter
kadonotakashi 0:8fdf9a60065b 129 then the final value of the counter is equal to 1
kadonotakashi 0:8fdf9a60065b 130
kadonotakashi 0:8fdf9a60065b 131 Testing single thread with yield
kadonotakashi 0:8fdf9a60065b 132 Given single thread is started
kadonotakashi 0:8fdf9a60065b 133 when the thread yields and then increments the counter
kadonotakashi 0:8fdf9a60065b 134 then the final value of the counter is equal to 1
kadonotakashi 0:8fdf9a60065b 135
kadonotakashi 0:8fdf9a60065b 136 Testing single thread with wait
kadonotakashi 0:8fdf9a60065b 137 Given single thread is started
kadonotakashi 0:8fdf9a60065b 138 when the thread waits for 100ms and then increments the counter
kadonotakashi 0:8fdf9a60065b 139 then the final value of the counter is equal to 1
kadonotakashi 0:8fdf9a60065b 140
kadonotakashi 0:8fdf9a60065b 141 Testing single thread with child
kadonotakashi 0:8fdf9a60065b 142 Given single thread is started
kadonotakashi 0:8fdf9a60065b 143 when the thread spawns another thread that increments the counter
kadonotakashi 0:8fdf9a60065b 144 then the final value of the counter is equal to 1
kadonotakashi 0:8fdf9a60065b 145
kadonotakashi 0:8fdf9a60065b 146 Testing serial threads with murder
kadonotakashi 0:8fdf9a60065b 147 Given single thread is started
kadonotakashi 0:8fdf9a60065b 148 when the parent thread is holding a lock
kadonotakashi 0:8fdf9a60065b 149 and the parent thread spawns a child thread that waits for the lock before incrementing the counter
kadonotakashi 0:8fdf9a60065b 150 and the parent terminates the child before releasing the lock
kadonotakashi 0:8fdf9a60065b 151 and the parent increments the counter
kadonotakashi 0:8fdf9a60065b 152 then the final value of the counter is equal to 1
kadonotakashi 0:8fdf9a60065b 153 */
kadonotakashi 0:8fdf9a60065b 154 template <void (*F)(counter_t *)>
kadonotakashi 0:8fdf9a60065b 155 void test_single_thread()
kadonotakashi 0:8fdf9a60065b 156 {
kadonotakashi 0:8fdf9a60065b 157 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 158 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 159 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 160
kadonotakashi 0:8fdf9a60065b 161 counter_t counter(0);
kadonotakashi 0:8fdf9a60065b 162 Thread thread(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 163 thread.start(callback(F, &counter));
kadonotakashi 0:8fdf9a60065b 164 thread.join();
kadonotakashi 0:8fdf9a60065b 165 TEST_ASSERT_EQUAL(counter, 1);
kadonotakashi 0:8fdf9a60065b 166 }
kadonotakashi 0:8fdf9a60065b 167
kadonotakashi 0:8fdf9a60065b 168 /** Template for tests: parallel threads, with yield, with wait, with child, with murder
kadonotakashi 0:8fdf9a60065b 169
kadonotakashi 0:8fdf9a60065b 170 Testing parallel threads
kadonotakashi 0:8fdf9a60065b 171 Given multiple threads are started in parallel
kadonotakashi 0:8fdf9a60065b 172 when each of the threads increments the counter
kadonotakashi 0:8fdf9a60065b 173 then the final value of the counter is equal to number of threads
kadonotakashi 0:8fdf9a60065b 174
kadonotakashi 0:8fdf9a60065b 175 Testing parallel threads with yield
kadonotakashi 0:8fdf9a60065b 176 Given multiple threads are started in parallel
kadonotakashi 0:8fdf9a60065b 177 when each of the threads yields and then increments the counter
kadonotakashi 0:8fdf9a60065b 178 then the final value of the counter is equal to number of threads
kadonotakashi 0:8fdf9a60065b 179
kadonotakashi 0:8fdf9a60065b 180 Testing parallel threads with wait
kadonotakashi 0:8fdf9a60065b 181 Given multiple threads are started in parallel
kadonotakashi 0:8fdf9a60065b 182 when each of the threads waits for 100ms and then increments the counter
kadonotakashi 0:8fdf9a60065b 183 then the final value of the counter is equal to number of threads
kadonotakashi 0:8fdf9a60065b 184
kadonotakashi 0:8fdf9a60065b 185 Testing parallel threads with child
kadonotakashi 0:8fdf9a60065b 186 Given multiple threads are started in parallel
kadonotakashi 0:8fdf9a60065b 187 when each of the threads spawns another thread that increments the counter
kadonotakashi 0:8fdf9a60065b 188 then the final value of the counter is equal to number of parallel threads
kadonotakashi 0:8fdf9a60065b 189
kadonotakashi 0:8fdf9a60065b 190 Testing parallel threads with murder
kadonotakashi 0:8fdf9a60065b 191 Given multiple threads are started in parallel
kadonotakashi 0:8fdf9a60065b 192 when the parent thread is holding a lock
kadonotakashi 0:8fdf9a60065b 193 and the parent thread spawns a child thread that waits for the lock before incrementing the counter
kadonotakashi 0:8fdf9a60065b 194 and the parent terminates the child before releasing the lock
kadonotakashi 0:8fdf9a60065b 195 and the parent increments the counter
kadonotakashi 0:8fdf9a60065b 196 then the final value of the counter is equal to number of parallel threads
kadonotakashi 0:8fdf9a60065b 197 */
kadonotakashi 0:8fdf9a60065b 198 template <int N, void (*F)(counter_t *)>
kadonotakashi 0:8fdf9a60065b 199 void test_parallel_threads()
kadonotakashi 0:8fdf9a60065b 200 {
kadonotakashi 0:8fdf9a60065b 201 char *dummy = new (std::nothrow) char[PARALLEL_THREAD_STACK_SIZE * N];
kadonotakashi 0:8fdf9a60065b 202 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 203 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 204
kadonotakashi 0:8fdf9a60065b 205 counter_t counter(0);
kadonotakashi 0:8fdf9a60065b 206 ParallelThread<osPriorityNormal, PARALLEL_THREAD_STACK_SIZE> threads[N];
kadonotakashi 0:8fdf9a60065b 207
kadonotakashi 0:8fdf9a60065b 208 for (int i = 0; i < N; i++) {
kadonotakashi 0:8fdf9a60065b 209 threads[i].start(callback(F, &counter));
kadonotakashi 0:8fdf9a60065b 210 }
kadonotakashi 0:8fdf9a60065b 211
kadonotakashi 0:8fdf9a60065b 212 for (int i = 0; i < N; i++) {
kadonotakashi 0:8fdf9a60065b 213 threads[i].join();
kadonotakashi 0:8fdf9a60065b 214 }
kadonotakashi 0:8fdf9a60065b 215
kadonotakashi 0:8fdf9a60065b 216 TEST_ASSERT_EQUAL(counter, N);
kadonotakashi 0:8fdf9a60065b 217 }
kadonotakashi 0:8fdf9a60065b 218
kadonotakashi 0:8fdf9a60065b 219 /** Template for tests: serial threads, with yield, with wait, with child, with murder
kadonotakashi 0:8fdf9a60065b 220
kadonotakashi 0:8fdf9a60065b 221 Testing serial threads
kadonotakashi 0:8fdf9a60065b 222 Given multiple threads are started serially
kadonotakashi 0:8fdf9a60065b 223 when each of the threads increments the counter
kadonotakashi 0:8fdf9a60065b 224 then the final value of the counter is equal to number of threads
kadonotakashi 0:8fdf9a60065b 225
kadonotakashi 0:8fdf9a60065b 226 Testing serial threads with yield
kadonotakashi 0:8fdf9a60065b 227 Given multiple threads are started serially
kadonotakashi 0:8fdf9a60065b 228 when each of the threads yields and then increments the counter
kadonotakashi 0:8fdf9a60065b 229 then the final value of the counter is equal to number of threads
kadonotakashi 0:8fdf9a60065b 230
kadonotakashi 0:8fdf9a60065b 231 Testing serial threads with wait
kadonotakashi 0:8fdf9a60065b 232 Given multiple threads are started serially
kadonotakashi 0:8fdf9a60065b 233 when each of the threads waits for 100ms and then increments the counter
kadonotakashi 0:8fdf9a60065b 234 then the final value of the counter is equal to number of threads
kadonotakashi 0:8fdf9a60065b 235
kadonotakashi 0:8fdf9a60065b 236 Testing serial threads with child
kadonotakashi 0:8fdf9a60065b 237 Given multiple threads are started serially
kadonotakashi 0:8fdf9a60065b 238 when each of the threads spawns another thread that increments the counter
kadonotakashi 0:8fdf9a60065b 239 then the final value of the counter is equal to number of serial threads
kadonotakashi 0:8fdf9a60065b 240
kadonotakashi 0:8fdf9a60065b 241 Testing serial threads with murder
kadonotakashi 0:8fdf9a60065b 242 Given multiple threads are started serially
kadonotakashi 0:8fdf9a60065b 243 when the parent thread is holding a lock
kadonotakashi 0:8fdf9a60065b 244 and the parent thread spawns a child thread that waits for the lock before incrementing the counter
kadonotakashi 0:8fdf9a60065b 245 and the parent terminates the child before releasing the lock
kadonotakashi 0:8fdf9a60065b 246 and the parent increments the counter
kadonotakashi 0:8fdf9a60065b 247 then the final value of the counter is equal to number of serial threads
kadonotakashi 0:8fdf9a60065b 248 */
kadonotakashi 0:8fdf9a60065b 249 template <int N, void (*F)(counter_t *)>
kadonotakashi 0:8fdf9a60065b 250 void test_serial_threads()
kadonotakashi 0:8fdf9a60065b 251 {
kadonotakashi 0:8fdf9a60065b 252 counter_t counter(0);
kadonotakashi 0:8fdf9a60065b 253 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 254 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 255 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 256
kadonotakashi 0:8fdf9a60065b 257 for (int i = 0; i < N; i++) {
kadonotakashi 0:8fdf9a60065b 258 Thread thread(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 259 thread.start(callback(F, &counter));
kadonotakashi 0:8fdf9a60065b 260 thread.join();
kadonotakashi 0:8fdf9a60065b 261 }
kadonotakashi 0:8fdf9a60065b 262
kadonotakashi 0:8fdf9a60065b 263 TEST_ASSERT_EQUAL(counter, N);
kadonotakashi 0:8fdf9a60065b 264 }
kadonotakashi 0:8fdf9a60065b 265
kadonotakashi 0:8fdf9a60065b 266 /** Testing thread self terminate
kadonotakashi 0:8fdf9a60065b 267
kadonotakashi 0:8fdf9a60065b 268 Given the thread is running
kadonotakashi 0:8fdf9a60065b 269 when the thread calls @a terminate on its self
kadonotakashi 0:8fdf9a60065b 270 then the thread terminates execution cleanly
kadonotakashi 0:8fdf9a60065b 271 */
kadonotakashi 0:8fdf9a60065b 272 void test_self_terminate()
kadonotakashi 0:8fdf9a60065b 273 {
kadonotakashi 0:8fdf9a60065b 274 Thread *thread = new (std::nothrow) Thread(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 275 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 276 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 277
kadonotakashi 0:8fdf9a60065b 278 // Don't fail test due to lack of memory.
kadonotakashi 0:8fdf9a60065b 279 if (!thread || !dummy) {
kadonotakashi 0:8fdf9a60065b 280 goto end;
kadonotakashi 0:8fdf9a60065b 281 }
kadonotakashi 0:8fdf9a60065b 282 thread->start(callback(self_terminate, thread));
kadonotakashi 0:8fdf9a60065b 283 thread->join();
kadonotakashi 0:8fdf9a60065b 284
kadonotakashi 0:8fdf9a60065b 285 end:
kadonotakashi 0:8fdf9a60065b 286 delete thread;
kadonotakashi 0:8fdf9a60065b 287 }
kadonotakashi 0:8fdf9a60065b 288
kadonotakashi 0:8fdf9a60065b 289 void flags_wait()
kadonotakashi 0:8fdf9a60065b 290 {
kadonotakashi 0:8fdf9a60065b 291 uint32_t flags = ThisThread::flags_wait_all(0x1);
kadonotakashi 0:8fdf9a60065b 292 TEST_ASSERT_EQUAL(0x1, flags);
kadonotakashi 0:8fdf9a60065b 293 }
kadonotakashi 0:8fdf9a60065b 294
kadonotakashi 0:8fdf9a60065b 295 void flags_wait_tout()
kadonotakashi 0:8fdf9a60065b 296 {
kadonotakashi 0:8fdf9a60065b 297 uint32_t flags = ThisThread::flags_wait_all_for(0x2, 50);
kadonotakashi 0:8fdf9a60065b 298 TEST_ASSERT_EQUAL(0x1, flags);
kadonotakashi 0:8fdf9a60065b 299 }
kadonotakashi 0:8fdf9a60065b 300
kadonotakashi 0:8fdf9a60065b 301 void flags_wait_multibit()
kadonotakashi 0:8fdf9a60065b 302 {
kadonotakashi 0:8fdf9a60065b 303 uint32_t flags = ThisThread::flags_wait_all(0x1 | 0x2);
kadonotakashi 0:8fdf9a60065b 304 TEST_ASSERT_EQUAL(0x3, flags);
kadonotakashi 0:8fdf9a60065b 305 }
kadonotakashi 0:8fdf9a60065b 306
kadonotakashi 0:8fdf9a60065b 307 void flags_wait_multibit_any()
kadonotakashi 0:8fdf9a60065b 308 {
kadonotakashi 0:8fdf9a60065b 309 uint32_t flags = ThisThread::flags_wait_any(0x1 | 0x2);
kadonotakashi 0:8fdf9a60065b 310 TEST_ASSERT_NOT_EQUAL(0x0, flags);
kadonotakashi 0:8fdf9a60065b 311 }
kadonotakashi 0:8fdf9a60065b 312
kadonotakashi 0:8fdf9a60065b 313 void flags_wait_multibit_tout()
kadonotakashi 0:8fdf9a60065b 314 {
kadonotakashi 0:8fdf9a60065b 315 uint32_t flags = ThisThread::flags_wait_all_for(0x1 | 0x2, 50);
kadonotakashi 0:8fdf9a60065b 316 TEST_ASSERT_NOT_EQUAL(0x3, flags);
kadonotakashi 0:8fdf9a60065b 317 }
kadonotakashi 0:8fdf9a60065b 318
kadonotakashi 0:8fdf9a60065b 319 /**
kadonotakashi 0:8fdf9a60065b 320 Testing thread flags: wait
kadonotakashi 0:8fdf9a60065b 321 Given two threads (A & B) are started
kadonotakashi 0:8fdf9a60065b 322 when thread A executes @a flags_wait_all(0x1)
kadonotakashi 0:8fdf9a60065b 323 and thread B execute @a flags_set(0x1)
kadonotakashi 0:8fdf9a60065b 324 then thread A exits the wait and continues execution
kadonotakashi 0:8fdf9a60065b 325
kadonotakashi 0:8fdf9a60065b 326 Testing thread flags: timeout
kadonotakashi 0:8fdf9a60065b 327 Given two threads (A & B) are started
kadonotakashi 0:8fdf9a60065b 328 when thread A executes @a flags_wait_all_for(0x1 | 0x2, 50) with a timeout of 50ms
kadonotakashi 0:8fdf9a60065b 329 and thread B execute @a flags_set(0x2)
kadonotakashi 0:8fdf9a60065b 330 then thread A keeps waiting for correct flags until it timeouts
kadonotakashi 0:8fdf9a60065b 331
kadonotakashi 0:8fdf9a60065b 332 Testing thread flags: multi-bit
kadonotakashi 0:8fdf9a60065b 333 Given two threads (A & B) are started
kadonotakashi 0:8fdf9a60065b 334 when thread A executes @a flags_wait_all(0x1 | 0x2)
kadonotakashi 0:8fdf9a60065b 335 and thread B execute @a flags_set(0x1 | 0x2)
kadonotakashi 0:8fdf9a60065b 336 then thread A exits the wait and continues execution
kadonotakashi 0:8fdf9a60065b 337
kadonotakashi 0:8fdf9a60065b 338 Testing thread flags: multi-bit any
kadonotakashi 0:8fdf9a60065b 339 Given two threads (A & B) are started
kadonotakashi 0:8fdf9a60065b 340 when thread A executes @a flags_wait_any(0x1 | 0x2)
kadonotakashi 0:8fdf9a60065b 341 and thread B execute @a flags_set(0x1)
kadonotakashi 0:8fdf9a60065b 342 then thread A exits the wait and continues execution
kadonotakashi 0:8fdf9a60065b 343
kadonotakashi 0:8fdf9a60065b 344 Testing thread flags: multi-bit timeout
kadonotakashi 0:8fdf9a60065b 345 Given two threads (A & B) are started
kadonotakashi 0:8fdf9a60065b 346 when thread A executes @a flags_wait_all_for(0x1, 50) with a timeout of 50ms
kadonotakashi 0:8fdf9a60065b 347 and thread B execute @a flags_set(0x2)
kadonotakashi 0:8fdf9a60065b 348 then thread A keeps waiting for correct flags until it timeouts
kadonotakashi 0:8fdf9a60065b 349 */
kadonotakashi 0:8fdf9a60065b 350 template <int S, void (*F)()>
kadonotakashi 0:8fdf9a60065b 351 void test_thread_flags_set()
kadonotakashi 0:8fdf9a60065b 352 {
kadonotakashi 0:8fdf9a60065b 353 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 354 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 355 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 356
kadonotakashi 0:8fdf9a60065b 357 Thread t_wait(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 358
kadonotakashi 0:8fdf9a60065b 359 t_wait.start(callback(F));
kadonotakashi 0:8fdf9a60065b 360
kadonotakashi 0:8fdf9a60065b 361 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 362
kadonotakashi 0:8fdf9a60065b 363 Thread::State state = t_wait.get_state();
kadonotakashi 0:8fdf9a60065b 364 TEST_ASSERT_EQUAL(Thread::WaitingThreadFlag, state);
kadonotakashi 0:8fdf9a60065b 365
kadonotakashi 0:8fdf9a60065b 366 int32_t res = t_wait.flags_set(S);
kadonotakashi 0:8fdf9a60065b 367
kadonotakashi 0:8fdf9a60065b 368 t_wait.join();
kadonotakashi 0:8fdf9a60065b 369 }
kadonotakashi 0:8fdf9a60065b 370
kadonotakashi 0:8fdf9a60065b 371 void flags_clear()
kadonotakashi 0:8fdf9a60065b 372 {
kadonotakashi 0:8fdf9a60065b 373 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 374
kadonotakashi 0:8fdf9a60065b 375 int32_t sig = ThisThread::flags_clear(0x1);
kadonotakashi 0:8fdf9a60065b 376 TEST_ASSERT_EQUAL(0x1, sig);
kadonotakashi 0:8fdf9a60065b 377
kadonotakashi 0:8fdf9a60065b 378 /* Flags cleared we should get timeout */
kadonotakashi 0:8fdf9a60065b 379 uint32_t flags = ThisThread::flags_wait_all_for(0x1, 0);
kadonotakashi 0:8fdf9a60065b 380 TEST_ASSERT_EQUAL(0, flags);
kadonotakashi 0:8fdf9a60065b 381 }
kadonotakashi 0:8fdf9a60065b 382
kadonotakashi 0:8fdf9a60065b 383 /** Testing thread flags: flags clear
kadonotakashi 0:8fdf9a60065b 384
kadonotakashi 0:8fdf9a60065b 385 Given two threads (A & B) are started
kadonotakashi 0:8fdf9a60065b 386 when thread A executes @a flags_set(0x1)
kadonotakashi 0:8fdf9a60065b 387 and thread B execute @a flags_clear(0x1)
kadonotakashi 0:8fdf9a60065b 388 and thread B execute @a flags_wait_all_for(0x1, 0)
kadonotakashi 0:8fdf9a60065b 389 then thread B @a flags_wait_all_for return should be 0 indicating no flags set
kadonotakashi 0:8fdf9a60065b 390 */
kadonotakashi 0:8fdf9a60065b 391 void test_thread_flags_clear()
kadonotakashi 0:8fdf9a60065b 392 {
kadonotakashi 0:8fdf9a60065b 393 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 394 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 395 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 396
kadonotakashi 0:8fdf9a60065b 397 Thread t_wait(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 398
kadonotakashi 0:8fdf9a60065b 399 t_wait.start(callback(flags_clear));
kadonotakashi 0:8fdf9a60065b 400
kadonotakashi 0:8fdf9a60065b 401 int32_t res = t_wait.flags_set(0x1);
kadonotakashi 0:8fdf9a60065b 402 TEST_ASSERT_EQUAL(0x1, res);
kadonotakashi 0:8fdf9a60065b 403
kadonotakashi 0:8fdf9a60065b 404 t_wait.join();
kadonotakashi 0:8fdf9a60065b 405 }
kadonotakashi 0:8fdf9a60065b 406
kadonotakashi 0:8fdf9a60065b 407 void thread_wait_flags()
kadonotakashi 0:8fdf9a60065b 408 {
kadonotakashi 0:8fdf9a60065b 409 ThisThread::flags_wait_all(0x1);
kadonotakashi 0:8fdf9a60065b 410 }
kadonotakashi 0:8fdf9a60065b 411
kadonotakashi 0:8fdf9a60065b 412 void stack_info()
kadonotakashi 0:8fdf9a60065b 413 {
kadonotakashi 0:8fdf9a60065b 414 ThisThread::flags_wait_all(0x1);
kadonotakashi 0:8fdf9a60065b 415
kadonotakashi 0:8fdf9a60065b 416 thread_wait_flags();
kadonotakashi 0:8fdf9a60065b 417
kadonotakashi 0:8fdf9a60065b 418 ThisThread::flags_wait_all(0x1);
kadonotakashi 0:8fdf9a60065b 419 }
kadonotakashi 0:8fdf9a60065b 420
kadonotakashi 0:8fdf9a60065b 421 /** Testing thread stack info
kadonotakashi 0:8fdf9a60065b 422
kadonotakashi 0:8fdf9a60065b 423 Given the thread is running
kadonotakashi 0:8fdf9a60065b 424 when a function is called from the thread context
kadonotakashi 0:8fdf9a60065b 425 then the stack usage goes up
kadonotakashi 0:8fdf9a60065b 426 and the reported stack size is as requested in the constructor
kadonotakashi 0:8fdf9a60065b 427 and the sum of free and used stack sizes is equal to the total stack size
kadonotakashi 0:8fdf9a60065b 428 when the function returns
kadonotakashi 0:8fdf9a60065b 429 then the stack usage goes down
kadonotakashi 0:8fdf9a60065b 430 and the reported stack size is as requested in the constructor
kadonotakashi 0:8fdf9a60065b 431 and the sum of free and used stack sizes is equal to the total stack size
kadonotakashi 0:8fdf9a60065b 432 */
kadonotakashi 0:8fdf9a60065b 433 void test_thread_stack_info()
kadonotakashi 0:8fdf9a60065b 434 {
kadonotakashi 0:8fdf9a60065b 435 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 436 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 437 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 438
kadonotakashi 0:8fdf9a60065b 439 Thread t(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 440 t.start(callback(stack_info));
kadonotakashi 0:8fdf9a60065b 441
kadonotakashi 0:8fdf9a60065b 442 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 443
kadonotakashi 0:8fdf9a60065b 444 TEST_ASSERT_EQUAL(THREAD_STACK_SIZE, t.stack_size());
kadonotakashi 0:8fdf9a60065b 445 TEST_ASSERT_EQUAL(THREAD_STACK_SIZE, t.free_stack() + t.used_stack());
kadonotakashi 0:8fdf9a60065b 446 uint32_t last_stack = t.used_stack();
kadonotakashi 0:8fdf9a60065b 447
kadonotakashi 0:8fdf9a60065b 448 t.flags_set(0x1);
kadonotakashi 0:8fdf9a60065b 449 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 450
kadonotakashi 0:8fdf9a60065b 451 TEST_ASSERT_EQUAL(THREAD_STACK_SIZE, t.free_stack() + t.used_stack());
kadonotakashi 0:8fdf9a60065b 452 TEST_ASSERT(last_stack <= t.used_stack());
kadonotakashi 0:8fdf9a60065b 453 last_stack = t.used_stack();
kadonotakashi 0:8fdf9a60065b 454
kadonotakashi 0:8fdf9a60065b 455 t.flags_set(0x1);
kadonotakashi 0:8fdf9a60065b 456 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 457
kadonotakashi 0:8fdf9a60065b 458 TEST_ASSERT_EQUAL(THREAD_STACK_SIZE, t.free_stack() + t.used_stack());
kadonotakashi 0:8fdf9a60065b 459 TEST_ASSERT(last_stack >= t.used_stack());
kadonotakashi 0:8fdf9a60065b 460
kadonotakashi 0:8fdf9a60065b 461 t.flags_set(0x1);
kadonotakashi 0:8fdf9a60065b 462
kadonotakashi 0:8fdf9a60065b 463 t.join();
kadonotakashi 0:8fdf9a60065b 464 }
kadonotakashi 0:8fdf9a60065b 465
kadonotakashi 0:8fdf9a60065b 466 /** Testing thread wait aka delay
kadonotakashi 0:8fdf9a60065b 467
kadonotakashi 0:8fdf9a60065b 468 Given the thread is running
kadonotakashi 0:8fdf9a60065b 469 when the @a wait function is called
kadonotakashi 0:8fdf9a60065b 470 then the thread sleeps for given amount of time
kadonotakashi 0:8fdf9a60065b 471 */
kadonotakashi 0:8fdf9a60065b 472 void test_thread_wait()
kadonotakashi 0:8fdf9a60065b 473 {
kadonotakashi 0:8fdf9a60065b 474 Timer timer;
kadonotakashi 0:8fdf9a60065b 475 timer.start();
kadonotakashi 0:8fdf9a60065b 476
kadonotakashi 0:8fdf9a60065b 477 Thread::wait(150);
kadonotakashi 0:8fdf9a60065b 478
kadonotakashi 0:8fdf9a60065b 479 TEST_ASSERT_UINT32_WITHIN(50000, 150000, timer.read_us());
kadonotakashi 0:8fdf9a60065b 480 }
kadonotakashi 0:8fdf9a60065b 481
kadonotakashi 0:8fdf9a60065b 482 /** Testing thread name
kadonotakashi 0:8fdf9a60065b 483
kadonotakashi 0:8fdf9a60065b 484 Given a thread is started with a specified name
kadonotakashi 0:8fdf9a60065b 485 when the name is queried using @a get_name
kadonotakashi 0:8fdf9a60065b 486 then the returned name is as set
kadonotakashi 0:8fdf9a60065b 487 */
kadonotakashi 0:8fdf9a60065b 488 void test_thread_name()
kadonotakashi 0:8fdf9a60065b 489 {
kadonotakashi 0:8fdf9a60065b 490 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 491 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 492 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 493
kadonotakashi 0:8fdf9a60065b 494 const char tname[] = "Amazing thread";
kadonotakashi 0:8fdf9a60065b 495 Thread t(osPriorityNormal, THREAD_STACK_SIZE, NULL, tname);
kadonotakashi 0:8fdf9a60065b 496 t.start(callback(thread_wait_flags));
kadonotakashi 0:8fdf9a60065b 497 TEST_ASSERT_EQUAL(strcmp(tname, t.get_name()), 0);
kadonotakashi 0:8fdf9a60065b 498 t.flags_set(0x1);
kadonotakashi 0:8fdf9a60065b 499 t.join();
kadonotakashi 0:8fdf9a60065b 500 }
kadonotakashi 0:8fdf9a60065b 501
kadonotakashi 0:8fdf9a60065b 502 void test_deleted_thread()
kadonotakashi 0:8fdf9a60065b 503 {
kadonotakashi 0:8fdf9a60065b 504 }
kadonotakashi 0:8fdf9a60065b 505
kadonotakashi 0:8fdf9a60065b 506 /** Testing thread states: deleted
kadonotakashi 0:8fdf9a60065b 507
kadonotakashi 0:8fdf9a60065b 508 Given the thread is not started
kadonotakashi 0:8fdf9a60065b 509 then its state, as reported by @a get_state, is @a Deleted
kadonotakashi 0:8fdf9a60065b 510 when the thread is started and finishes executing
kadonotakashi 0:8fdf9a60065b 511 then its state, as reported by @a get_state, is @a Deleted
kadonotakashi 0:8fdf9a60065b 512 */
kadonotakashi 0:8fdf9a60065b 513 void test_deleted()
kadonotakashi 0:8fdf9a60065b 514 {
kadonotakashi 0:8fdf9a60065b 515 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 516 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 517 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 518
kadonotakashi 0:8fdf9a60065b 519 Thread t(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 520
kadonotakashi 0:8fdf9a60065b 521 TEST_ASSERT_EQUAL(Thread::Deleted, t.get_state());
kadonotakashi 0:8fdf9a60065b 522
kadonotakashi 0:8fdf9a60065b 523 t.start(callback(test_deleted_thread));
kadonotakashi 0:8fdf9a60065b 524
kadonotakashi 0:8fdf9a60065b 525 t.join();
kadonotakashi 0:8fdf9a60065b 526 TEST_ASSERT_EQUAL(Thread::Deleted, t.get_state());
kadonotakashi 0:8fdf9a60065b 527 }
kadonotakashi 0:8fdf9a60065b 528
kadonotakashi 0:8fdf9a60065b 529 void test_delay_thread()
kadonotakashi 0:8fdf9a60065b 530 {
kadonotakashi 0:8fdf9a60065b 531 Thread::wait(50);
kadonotakashi 0:8fdf9a60065b 532 }
kadonotakashi 0:8fdf9a60065b 533
kadonotakashi 0:8fdf9a60065b 534 /** Testing thread states: wait delay
kadonotakashi 0:8fdf9a60065b 535
kadonotakashi 0:8fdf9a60065b 536 Given the thread is running
kadonotakashi 0:8fdf9a60065b 537 when thread calls @a wait
kadonotakashi 0:8fdf9a60065b 538 then its state, as reported by @a get_state, is @a WaitingDelay
kadonotakashi 0:8fdf9a60065b 539 */
kadonotakashi 0:8fdf9a60065b 540 void test_delay()
kadonotakashi 0:8fdf9a60065b 541 {
kadonotakashi 0:8fdf9a60065b 542 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 543 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 544 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 545
kadonotakashi 0:8fdf9a60065b 546 Thread t(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 547
kadonotakashi 0:8fdf9a60065b 548 t.start(callback(test_delay_thread));
kadonotakashi 0:8fdf9a60065b 549
kadonotakashi 0:8fdf9a60065b 550 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 551
kadonotakashi 0:8fdf9a60065b 552 TEST_ASSERT_EQUAL(Thread::WaitingDelay, t.get_state());
kadonotakashi 0:8fdf9a60065b 553
kadonotakashi 0:8fdf9a60065b 554 t.join();
kadonotakashi 0:8fdf9a60065b 555 TEST_ASSERT_EQUAL(Thread::Deleted, t.get_state());
kadonotakashi 0:8fdf9a60065b 556 }
kadonotakashi 0:8fdf9a60065b 557
kadonotakashi 0:8fdf9a60065b 558 void test_thread_flags_thread()
kadonotakashi 0:8fdf9a60065b 559 {
kadonotakashi 0:8fdf9a60065b 560 ThisThread::flags_wait_all(0x1);
kadonotakashi 0:8fdf9a60065b 561 }
kadonotakashi 0:8fdf9a60065b 562
kadonotakashi 0:8fdf9a60065b 563 /** Testing thread states: wait flags
kadonotakashi 0:8fdf9a60065b 564
kadonotakashi 0:8fdf9a60065b 565 Given the thread is running
kadonotakashi 0:8fdf9a60065b 566 when thread waits for flags
kadonotakashi 0:8fdf9a60065b 567 then its state, as reported by @a get_state, is @a WaitingThreadFlag
kadonotakashi 0:8fdf9a60065b 568 */
kadonotakashi 0:8fdf9a60065b 569 void test_thread_flags()
kadonotakashi 0:8fdf9a60065b 570 {
kadonotakashi 0:8fdf9a60065b 571 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 572 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 573 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 574
kadonotakashi 0:8fdf9a60065b 575 Thread t(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 576
kadonotakashi 0:8fdf9a60065b 577 t.start(callback(test_thread_flags_thread));
kadonotakashi 0:8fdf9a60065b 578
kadonotakashi 0:8fdf9a60065b 579 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 580
kadonotakashi 0:8fdf9a60065b 581 TEST_ASSERT_EQUAL(Thread::WaitingThreadFlag, t.get_state());
kadonotakashi 0:8fdf9a60065b 582
kadonotakashi 0:8fdf9a60065b 583 t.flags_set(0x1);
kadonotakashi 0:8fdf9a60065b 584 }
kadonotakashi 0:8fdf9a60065b 585
kadonotakashi 0:8fdf9a60065b 586 void test_evt_flag_thread(EventFlags *evtflg)
kadonotakashi 0:8fdf9a60065b 587 {
kadonotakashi 0:8fdf9a60065b 588 evtflg->wait_any(0x1);
kadonotakashi 0:8fdf9a60065b 589 }
kadonotakashi 0:8fdf9a60065b 590
kadonotakashi 0:8fdf9a60065b 591 /** Testing thread states: wait evt flag
kadonotakashi 0:8fdf9a60065b 592
kadonotakashi 0:8fdf9a60065b 593 Given the thread is running
kadonotakashi 0:8fdf9a60065b 594 when thread waits for an event flag
kadonotakashi 0:8fdf9a60065b 595 then its state, as reported by @a get_state, is @a WaitingEventFlag
kadonotakashi 0:8fdf9a60065b 596 */
kadonotakashi 0:8fdf9a60065b 597 void test_evt_flag()
kadonotakashi 0:8fdf9a60065b 598 {
kadonotakashi 0:8fdf9a60065b 599 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 600 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 601 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 602
kadonotakashi 0:8fdf9a60065b 603 Thread t(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 604 EventFlags evtflg;
kadonotakashi 0:8fdf9a60065b 605
kadonotakashi 0:8fdf9a60065b 606 t.start(callback(test_evt_flag_thread, &evtflg));
kadonotakashi 0:8fdf9a60065b 607
kadonotakashi 0:8fdf9a60065b 608 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 609
kadonotakashi 0:8fdf9a60065b 610 TEST_ASSERT_EQUAL(Thread::WaitingEventFlag, t.get_state());
kadonotakashi 0:8fdf9a60065b 611
kadonotakashi 0:8fdf9a60065b 612 evtflg.set(0x1);
kadonotakashi 0:8fdf9a60065b 613 }
kadonotakashi 0:8fdf9a60065b 614
kadonotakashi 0:8fdf9a60065b 615 void test_mutex_thread(Mutex *mutex)
kadonotakashi 0:8fdf9a60065b 616 {
kadonotakashi 0:8fdf9a60065b 617 mutex->lock();
kadonotakashi 0:8fdf9a60065b 618 }
kadonotakashi 0:8fdf9a60065b 619
kadonotakashi 0:8fdf9a60065b 620 /** Testing thread states: wait mutex
kadonotakashi 0:8fdf9a60065b 621
kadonotakashi 0:8fdf9a60065b 622 Given the thread is running
kadonotakashi 0:8fdf9a60065b 623 when thread waits for a mutex
kadonotakashi 0:8fdf9a60065b 624 then its state, as reported by @a get_state, is @a WaitingMutex
kadonotakashi 0:8fdf9a60065b 625 */
kadonotakashi 0:8fdf9a60065b 626 void test_mutex()
kadonotakashi 0:8fdf9a60065b 627 {
kadonotakashi 0:8fdf9a60065b 628 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 629 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 630 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 631
kadonotakashi 0:8fdf9a60065b 632 Thread t(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 633 Mutex mutex;
kadonotakashi 0:8fdf9a60065b 634
kadonotakashi 0:8fdf9a60065b 635 mutex.lock();
kadonotakashi 0:8fdf9a60065b 636
kadonotakashi 0:8fdf9a60065b 637 t.start(callback(test_mutex_thread, &mutex));
kadonotakashi 0:8fdf9a60065b 638
kadonotakashi 0:8fdf9a60065b 639 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 640
kadonotakashi 0:8fdf9a60065b 641 TEST_ASSERT_EQUAL(Thread::WaitingMutex, t.get_state());
kadonotakashi 0:8fdf9a60065b 642
kadonotakashi 0:8fdf9a60065b 643 mutex.unlock();
kadonotakashi 0:8fdf9a60065b 644 }
kadonotakashi 0:8fdf9a60065b 645
kadonotakashi 0:8fdf9a60065b 646 void test_semaphore_thread(Semaphore *sem)
kadonotakashi 0:8fdf9a60065b 647 {
kadonotakashi 0:8fdf9a60065b 648 sem->wait();
kadonotakashi 0:8fdf9a60065b 649 }
kadonotakashi 0:8fdf9a60065b 650
kadonotakashi 0:8fdf9a60065b 651 /** Testing thread states: wait semaphore
kadonotakashi 0:8fdf9a60065b 652
kadonotakashi 0:8fdf9a60065b 653 Given the thread is running
kadonotakashi 0:8fdf9a60065b 654 when thread waits for a semaphore
kadonotakashi 0:8fdf9a60065b 655 then its state, as reported by @a get_state, is @a WaitingSemaphore
kadonotakashi 0:8fdf9a60065b 656 */
kadonotakashi 0:8fdf9a60065b 657 void test_semaphore()
kadonotakashi 0:8fdf9a60065b 658 {
kadonotakashi 0:8fdf9a60065b 659 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 660 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 661 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 662
kadonotakashi 0:8fdf9a60065b 663 Thread t(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 664 Semaphore sem;
kadonotakashi 0:8fdf9a60065b 665
kadonotakashi 0:8fdf9a60065b 666 t.start(callback(test_semaphore_thread, &sem));
kadonotakashi 0:8fdf9a60065b 667
kadonotakashi 0:8fdf9a60065b 668 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 669
kadonotakashi 0:8fdf9a60065b 670 TEST_ASSERT_EQUAL(Thread::WaitingSemaphore, t.get_state());
kadonotakashi 0:8fdf9a60065b 671
kadonotakashi 0:8fdf9a60065b 672 sem.release();
kadonotakashi 0:8fdf9a60065b 673 }
kadonotakashi 0:8fdf9a60065b 674
kadonotakashi 0:8fdf9a60065b 675 void test_msg_get_thread(Queue<int32_t, 1> *queue)
kadonotakashi 0:8fdf9a60065b 676 {
kadonotakashi 0:8fdf9a60065b 677 queue->get();
kadonotakashi 0:8fdf9a60065b 678 }
kadonotakashi 0:8fdf9a60065b 679
kadonotakashi 0:8fdf9a60065b 680 /** Testing thread states: wait message get
kadonotakashi 0:8fdf9a60065b 681
kadonotakashi 0:8fdf9a60065b 682 Given the thread is running
kadonotakashi 0:8fdf9a60065b 683 when thread tries to get a message from an empty queue
kadonotakashi 0:8fdf9a60065b 684 then its state, as reported by @a get_state, is @a WaitingMessageGet
kadonotakashi 0:8fdf9a60065b 685 */
kadonotakashi 0:8fdf9a60065b 686 void test_msg_get()
kadonotakashi 0:8fdf9a60065b 687 {
kadonotakashi 0:8fdf9a60065b 688 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 689 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 690 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 691
kadonotakashi 0:8fdf9a60065b 692 Thread t(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 693 Queue<int32_t, 1> queue;
kadonotakashi 0:8fdf9a60065b 694
kadonotakashi 0:8fdf9a60065b 695 t.start(callback(test_msg_get_thread, &queue));
kadonotakashi 0:8fdf9a60065b 696
kadonotakashi 0:8fdf9a60065b 697 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 698
kadonotakashi 0:8fdf9a60065b 699 TEST_ASSERT_EQUAL(Thread::WaitingMessageGet, t.get_state());
kadonotakashi 0:8fdf9a60065b 700
kadonotakashi 0:8fdf9a60065b 701 queue.put((int32_t *)0xE1EE7);
kadonotakashi 0:8fdf9a60065b 702 }
kadonotakashi 0:8fdf9a60065b 703
kadonotakashi 0:8fdf9a60065b 704 void test_msg_put_thread(Queue<int32_t, 1> *queue)
kadonotakashi 0:8fdf9a60065b 705 {
kadonotakashi 0:8fdf9a60065b 706 queue->put((int32_t *)0xDEADBEEF, osWaitForever);
kadonotakashi 0:8fdf9a60065b 707
kadonotakashi 0:8fdf9a60065b 708 }
kadonotakashi 0:8fdf9a60065b 709
kadonotakashi 0:8fdf9a60065b 710 /** Testing thread states: wait message put
kadonotakashi 0:8fdf9a60065b 711
kadonotakashi 0:8fdf9a60065b 712 Given the thread is running
kadonotakashi 0:8fdf9a60065b 713 when thread tries to put a message into a full queue
kadonotakashi 0:8fdf9a60065b 714 then its state, as reported by @a get_state, is @a WaitingMessagePut
kadonotakashi 0:8fdf9a60065b 715 */
kadonotakashi 0:8fdf9a60065b 716 void test_msg_put()
kadonotakashi 0:8fdf9a60065b 717 {
kadonotakashi 0:8fdf9a60065b 718 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 719 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 720 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 721
kadonotakashi 0:8fdf9a60065b 722 Thread t(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 723 Queue<int32_t, 1> queue;
kadonotakashi 0:8fdf9a60065b 724
kadonotakashi 0:8fdf9a60065b 725 queue.put((int32_t *)0xE1EE7);
kadonotakashi 0:8fdf9a60065b 726
kadonotakashi 0:8fdf9a60065b 727 t.start(callback(test_msg_put_thread, &queue));
kadonotakashi 0:8fdf9a60065b 728
kadonotakashi 0:8fdf9a60065b 729 ThisThread::yield();
kadonotakashi 0:8fdf9a60065b 730
kadonotakashi 0:8fdf9a60065b 731 TEST_ASSERT_EQUAL(Thread::WaitingMessagePut, t.get_state());
kadonotakashi 0:8fdf9a60065b 732 queue.get();
kadonotakashi 0:8fdf9a60065b 733 }
kadonotakashi 0:8fdf9a60065b 734
kadonotakashi 0:8fdf9a60065b 735 /** Utility function that places some date on the stack */
kadonotakashi 0:8fdf9a60065b 736 void use_some_stack()
kadonotakashi 0:8fdf9a60065b 737 {
kadonotakashi 0:8fdf9a60065b 738 volatile uint32_t stack_filler[10] = {0xDEADBEEF};
kadonotakashi 0:8fdf9a60065b 739 }
kadonotakashi 0:8fdf9a60065b 740
kadonotakashi 0:8fdf9a60065b 741 /** Testing thread with external stack memory
kadonotakashi 0:8fdf9a60065b 742
kadonotakashi 0:8fdf9a60065b 743 Given external buffer is supplied as stack to a thread
kadonotakashi 0:8fdf9a60065b 744 when the thread executes
kadonotakashi 0:8fdf9a60065b 745 then the supplies buffer is used as a stack
kadonotakashi 0:8fdf9a60065b 746 */
kadonotakashi 0:8fdf9a60065b 747 void test_thread_ext_stack()
kadonotakashi 0:8fdf9a60065b 748 {
kadonotakashi 0:8fdf9a60065b 749 char stack[512];
kadonotakashi 0:8fdf9a60065b 750 Thread t(osPriorityNormal, sizeof(stack), (unsigned char *)stack);
kadonotakashi 0:8fdf9a60065b 751
kadonotakashi 0:8fdf9a60065b 752 memset(&stack, 0, sizeof(stack));
kadonotakashi 0:8fdf9a60065b 753 t.start(callback(use_some_stack));
kadonotakashi 0:8fdf9a60065b 754 t.join();
kadonotakashi 0:8fdf9a60065b 755
kadonotakashi 0:8fdf9a60065b 756 /* If buffer was used as a stack it was cleared with pattern and some data were placed in it */
kadonotakashi 0:8fdf9a60065b 757 for (unsigned i = 0; i < sizeof(stack); i++) {
kadonotakashi 0:8fdf9a60065b 758 if (stack[i] != 0) {
kadonotakashi 0:8fdf9a60065b 759 return;
kadonotakashi 0:8fdf9a60065b 760 }
kadonotakashi 0:8fdf9a60065b 761 }
kadonotakashi 0:8fdf9a60065b 762
kadonotakashi 0:8fdf9a60065b 763 TEST_FAIL_MESSAGE("External stack was not used.");
kadonotakashi 0:8fdf9a60065b 764 }
kadonotakashi 0:8fdf9a60065b 765
kadonotakashi 0:8fdf9a60065b 766 /** Testing thread priority operations
kadonotakashi 0:8fdf9a60065b 767
kadonotakashi 0:8fdf9a60065b 768 Given thread running with osPriorityNormal
kadonotakashi 0:8fdf9a60065b 769 when new priority is set using @a set_priority
kadonotakashi 0:8fdf9a60065b 770 then priority is changed and can be retrieved using @a get_priority
kadonotakashi 0:8fdf9a60065b 771 */
kadonotakashi 0:8fdf9a60065b 772 void test_thread_prio()
kadonotakashi 0:8fdf9a60065b 773 {
kadonotakashi 0:8fdf9a60065b 774 char *dummy = new (std::nothrow) char[THREAD_STACK_SIZE];
kadonotakashi 0:8fdf9a60065b 775 delete[] dummy;
kadonotakashi 0:8fdf9a60065b 776 TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory to run test");
kadonotakashi 0:8fdf9a60065b 777
kadonotakashi 0:8fdf9a60065b 778 Thread t(osPriorityNormal, THREAD_STACK_SIZE);
kadonotakashi 0:8fdf9a60065b 779 t.start(callback(thread_wait_flags));
kadonotakashi 0:8fdf9a60065b 780
kadonotakashi 0:8fdf9a60065b 781 TEST_ASSERT_EQUAL(osPriorityNormal, t.get_priority());
kadonotakashi 0:8fdf9a60065b 782
kadonotakashi 0:8fdf9a60065b 783 t.set_priority(osPriorityHigh);
kadonotakashi 0:8fdf9a60065b 784
kadonotakashi 0:8fdf9a60065b 785 TEST_ASSERT_EQUAL(osPriorityHigh, t.get_priority());
kadonotakashi 0:8fdf9a60065b 786
kadonotakashi 0:8fdf9a60065b 787 t.flags_set(0x1);
kadonotakashi 0:8fdf9a60065b 788 t.join();
kadonotakashi 0:8fdf9a60065b 789 }
kadonotakashi 0:8fdf9a60065b 790
kadonotakashi 0:8fdf9a60065b 791 utest::v1::status_t test_setup(const size_t number_of_cases)
kadonotakashi 0:8fdf9a60065b 792 {
kadonotakashi 0:8fdf9a60065b 793 GREENTEA_SETUP(20, "default_auto");
kadonotakashi 0:8fdf9a60065b 794 return verbose_test_setup_handler(number_of_cases);
kadonotakashi 0:8fdf9a60065b 795 }
kadonotakashi 0:8fdf9a60065b 796
kadonotakashi 0:8fdf9a60065b 797 #define DEFAULT_HANDLERS NULL,NULL,greentea_case_setup_handler,greentea_case_teardown_handler,greentea_case_failure_abort_handler
kadonotakashi 0:8fdf9a60065b 798
kadonotakashi 0:8fdf9a60065b 799 // Test cases. It's spelled out rather than constructed with macro because
kadonotakashi 0:8fdf9a60065b 800 // macros don't play nicely with the templates (extra comma).
kadonotakashi 0:8fdf9a60065b 801 static const case_t cases[] = {
kadonotakashi 0:8fdf9a60065b 802 {"Testing single thread", test_single_thread<increment>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 803 {"Testing parallel threads", test_parallel_threads<3, increment>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 804 {"Testing serial threads", test_serial_threads<10, increment>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 805
kadonotakashi 0:8fdf9a60065b 806 {"Testing single thread with yield", test_single_thread<increment_with_yield>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 807 {"Testing parallel threads with yield", test_parallel_threads<3, increment_with_yield>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 808 {"Testing serial threads with yield", test_serial_threads<10, increment_with_yield>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 809
kadonotakashi 0:8fdf9a60065b 810 {"Testing single thread with wait", test_single_thread<increment_with_wait>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 811 {"Testing parallel threads with wait", test_parallel_threads<3, increment_with_wait>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 812 {"Testing serial threads with wait", test_serial_threads<10, increment_with_wait>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 813
kadonotakashi 0:8fdf9a60065b 814 {"Testing single thread with child", test_single_thread<increment_with_child>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 815 {"Testing parallel threads with child", test_parallel_threads<2, increment_with_child>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 816 {"Testing serial threads with child", test_serial_threads<10, increment_with_child>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 817
kadonotakashi 0:8fdf9a60065b 818 {"Testing single thread with murder", test_single_thread<increment_with_murder>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 819 {"Testing parallel threads with murder", test_parallel_threads<2, increment_with_murder>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 820 {"Testing serial threads with murder", test_serial_threads<10, increment_with_murder>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 821
kadonotakashi 0:8fdf9a60065b 822 {"Testing thread self terminate", test_self_terminate, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 823
kadonotakashi 0:8fdf9a60065b 824 {"Testing thread flags: wait", test_thread_flags_set<0x1, flags_wait>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 825 {"Testing thread flags: timeout", test_thread_flags_set<0x1, flags_wait_tout>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 826 {"Testing thread flags: multi-bit all", test_thread_flags_set<0x3, flags_wait_multibit>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 827 {"Testing thread flags: multi-bit all timeout", test_thread_flags_set<0x1, flags_wait_multibit_tout>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 828 {"Testing thread flags: multi-bit any", test_thread_flags_set<0x1, flags_wait_multibit_any>, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 829 {"Testing thread flags: flags clear", test_thread_flags_clear, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 830
kadonotakashi 0:8fdf9a60065b 831 {"Testing thread stack info", test_thread_stack_info, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 832 {"Testing thread wait", test_thread_wait, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 833 {"Testing thread name", test_thread_name, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 834
kadonotakashi 0:8fdf9a60065b 835 {"Testing thread states: deleted", test_deleted, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 836 {"Testing thread states: wait delay", test_delay, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 837 {"Testing thread states: wait thread flags", test_thread_flags, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 838 {"Testing thread states: wait event flag", test_evt_flag, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 839 {"Testing thread states: wait mutex", test_mutex, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 840 {"Testing thread states: wait semaphore", test_semaphore, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 841 {"Testing thread states: wait message get", test_msg_get, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 842 {"Testing thread states: wait message put", test_msg_put, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 843
kadonotakashi 0:8fdf9a60065b 844 {"Testing thread with external stack memory", test_thread_ext_stack, DEFAULT_HANDLERS},
kadonotakashi 0:8fdf9a60065b 845 {"Testing thread priority ops", test_thread_prio, DEFAULT_HANDLERS}
kadonotakashi 0:8fdf9a60065b 846
kadonotakashi 0:8fdf9a60065b 847 };
kadonotakashi 0:8fdf9a60065b 848
kadonotakashi 0:8fdf9a60065b 849 Specification specification(test_setup, cases);
kadonotakashi 0:8fdf9a60065b 850
kadonotakashi 0:8fdf9a60065b 851 int main()
kadonotakashi 0:8fdf9a60065b 852 {
kadonotakashi 0:8fdf9a60065b 853 return !Harness::run(specification);
kadonotakashi 0:8fdf9a60065b 854 }