aboutsummaryrefslogtreecommitdiffstats
path: root/test/test.h
blob: 7394d7511c79b64d61bff7185e95a8809536ca7a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
/*
    ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
                 2011,2012,2013 Giovanni Di Sirio.

    This file is part of ChibiOS/RT.

    ChibiOS/RT is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    ChibiOS/RT is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/**
 * @file    test.h
 * @brief   Tests support header.
 *
 * @addtogroup test
 * @{
 */

#ifndef _TEST_H_
#define _TEST_H_

/**
 * @brief   Delay inserted between test cases.
 */
#if !defined(DELAY_BETWEEN_TESTS) || defined(__DOXYGEN__)
#define DELAY_BETWEEN_TESTS     200
#endif

/**
 * @brief   If @p TRUE then benchmarks are not included.
 */
#if !defined(TEST_NO_BENCHMARKS) || defined(__DOXYGEN__)
#define TEST_NO_BENCHMARKS      FALSE
#endif

#define MAX_THREADS             5
#define MAX_TOKENS              16

#if defined(CH_ARCHITECTURE_AVR) || defined(CH_ARCHITECTURE_MSP430)
#define THREADS_STACK_SIZE      48
#elif defined(CH_ARCHITECTURE_STM8)
#define THREADS_STACK_SIZE      64
#elif defined(CH_ARCHITECTURE_SIMIA32)
#define THREADS_STACK_SIZE      512
#else
#define THREADS_STACK_SIZE      128
#endif
#define WA_SIZE THD_WA_SIZE(THREADS_STACK_SIZE)

/**
 * @brief   Structure representing a test case.
 */
struct testcase {
  const char *name;             /**< @brief Test case name.                 */
  void (*setup)(void);          /**< @brief Test case preparation function. */
  void (*teardown)(void);       /**< @brief Test case clean up function.    */
  void (*execute)(void);        /**< @brief Test case execution function.   */
};

#ifndef __DOXYGEN__
union test_buffers {
  struct {
    WORKING_AREA(T0, THREADS_STACK_SIZE);
    WORKING_AREA(T1, THREADS_STACK_SIZE);
    WORKING_AREA(T2, THREADS_STACK_SIZE);
    WORKING_AREA(T3, THREADS_STACK_SIZE);
    WORKING_AREA(T4, THREADS_STACK_SIZE);
  } wa;
  uint8_t buffer[WA_SIZE * 5];
};
#endif

#ifdef __cplusplus
extern "C" {
#endif
  msg_t TestThread(void *p);
  void test_printn(uint32_t n);
  void test_print(const char *msgp);
  void test_println(const char *msgp);
  void test_emit_token(char token);
  bool_t _test_fail(unsigned point);
  bool_t _test_assert(unsigned point, bool_t condition);
  bool_t _test_assert_sequence(unsigned point, char *expected);
  bool_t _test_assert_time_window(unsigned point, systime_t start, systime_t end);
  void test_terminate_threads(void);
  void test_wait_threads(void);
  systime_t test_wait_tick(void);
  void test_start_timer(unsigned ms);
#if CH_DBG_THREADS_PROFILING
  void test_cpu_pulse(unsigned duration);
#endif
#if defined(WIN32)
  void ChkIntSources(void);
#endif
#ifdef __cplusplus
}
#endif

/**
 * @brief   Test failure enforcement.
 */
#define test_fail(point) {                                                  \
  _test_fail(point);                                                        \
  return;                                                                   \
}

/**
 * @brief   Test assertion.
 *
 * @param[in] point     numeric assertion identifier
 * @param[in] condition a boolean expression that must be verified to be true
 * @param[in] msg       failure message
 */
#define test_assert(point, condition, msg) {                                \
  if (_test_assert(point, condition))                                       \
    return;                                                                 \
}

/**
 * @brief   Test assertion with lock.
 *
 * @param[in] point     numeric assertion identifier
 * @param[in] condition a boolean expression that must be verified to be true
 * @param[in] msg       failure message
 */
#define test_assert_lock(point, condition, msg) {                           \
  chSysLock();                                                              \
  if (_test_assert(point, condition)) {                                     \
    chSysUnlock();                                                          \
    return;                                                                 \
  }                                                                         \
  chSysUnlock();                                                            \
}

/**
 * @brief   Test sequence assertion.
 *
 * @param[in] point     numeric assertion identifier
 * @param[in] expected  string to be matched with the tokens buffer
 */
#define test_assert_sequence(point, expected) {                             \
  if (_test_assert_sequence(point, expected))                               \
    return;                                                                 \
}

/**
 * @brief   Test time window assertion.
 *
 * @param[in] point     numeric assertion identifier
 * @param[in] start     initial time in the window (included)
 * @param[in] end       final time in the window (not included)
 */
#define test_assert_time_window(point, start, end) {                        \
  if (_test_assert_time_window(point, start, end))                          \
    return;                                                                 \
}

#if !defined(__DOXYGEN__)
extern Thread *threads[MAX_THREADS];
extern union test_buffers test;
extern void * ROMCONST wa[];
extern bool_t test_timer_done;
#endif

#endif /* _TEST_H_ */

/** @} */