andreika-git
/
ChibiOS
mirror of https://github.com/andreika-git/ChibiOS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/branches/kernel_3_dev@6697 35acf78f-673a-0410-8e92-d51de3d6d3f4

This commit is contained in:
gdisirio 2014-02-10 15:37:51 +00:00
parent 4fc90c99b7
commit be1b2cbd33
5 changed files with 275 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
test/nil/test_sequence_000.c
View File

@ -1,183 +0,0 @@
/*
ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include "hal.h"
#include "ch_test.h"
#include "test_root.h"
/**
* @page test_sequence_000 Threads Functionality
*
* File: @ref test_sequence_000.c
*
* <h2>Description</h2>
* This sequence tests the ChibiOS/NIL functionalities related to threading.
*
* <h2>Test Cases</h2>
* - @subpage test_000_000
* - @subpage test_000_001
* .
*/
/****************************************************************************
* Shared code.
****************************************************************************/
/****************************************************************************
* Test cases.
****************************************************************************/
#if TRUE || defined(__DOXYGEN__)
/**
* @page test_000_000 System Tick Counter functionality
*
* <h2>Description</h2>
* The functionality of the API @p chVTGetSystemTimeX() is tested.
*
* <h2>Conditions</h2>
* None.
*
* <h2>Test Steps</h2>
* - A System Tick Counter increment is expected, the test simply hangs if
* it does not happen.
* .
*/
static void test_000_000_execute(void) {
systime_t time;
/* A System Tick Counter increment is expected, the test simply hangs if
it does not happen.*/
test_set_step(1);
{
time = chVTGetSystemTimeX();
while (time == chVTGetSystemTimeX()) {
}
}
}
static const testcase_t test_000_000 = {
"System Tick Counter functionality",
NULL,
NULL,
test_000_000_execute
};
#endif /* TRUE */
#if TRUE || defined(__DOXYGEN__)
/**
* @page test_000_001 Thread Sleep functionality
*
* <h2>Description</h2>
* The functionality of the API @p chThdSleep() and derivatives is tested.
*
* <h2>Conditions</h2>
* None.
*
* <h2>Test Steps</h2>
* - The current system time is read then a sleep is performed for 100 system
* ticks and on exit the system time is verified again.
* - The current system time is read then a sleep is performed for 100000
* microseconds and on exit the system time is verified again.
* - The current system time is read then a sleep is performed for 100
* milliseconds and on exit the system time is verified again.
* - The current system time is read then a sleep is performed for 1
* second and on exit the system time is verified again.
* .
*/
static void test_000_001_execute(void) {
systime_t time;
/* The current system time is read then a sleep is performed for 100 system
ticks and on exit the system time is verified again.*/
test_set_step(1);
{
time = chVTGetSystemTimeX();
chThdSleep(100);
test_assert_time_window(time + 100,
time + 100 + 1,
"out of time window");
}
/* The current system time is read then a sleep is performed for 100000
microseconds and on exit the system time is verified again.*/
test_set_step(2);
{
time = chVTGetSystemTimeX();
chThdSleepMicroseconds(100);
test_assert_time_window(time + US2ST(100),
time + US2ST(100) + 1,
"out of time window");
}
/* The current system time is read then a sleep is performed for 100
milliseconds and on exit the system time is verified again.*/
test_set_step(3);
{
time = chVTGetSystemTimeX();
chThdSleepMilliseconds(100);
test_assert_time_window(time + MS2ST(100),
time + MS2ST(100) + 1,
"out of time window");
}
/* The current system time is read then a sleep is performed for 1
second and on exit the system time is verified again.*/
test_set_step(4);
{
time = chVTGetSystemTimeX();
chThdSleepSeconds(1);
test_assert_time_window(time + S2ST(1),
time + S2ST(1) + 1,
"out of time window");
}
test_set_step(5);
{
time = chVTGetSystemTimeX();
chThdSleepUntil(time + 100);
test_assert_time_window(time + 100,
time + 100 + 1,
"out of time window");
}
}
static const testcase_t test_000_001 = {
"Thread Sleep functionality",
NULL,
NULL,
test_000_001_execute
};
#endif /* TRUE */
/****************************************************************************
* Exported data.
****************************************************************************/
/**
* @brief Sequence brief description.
*/
const testcase_t * const test_sequence_000[] = {
#if TRUE || defined(__DOXYGEN__)
&test_000_000,
#endif
#if TRUE || defined(__DOXYGEN__)
&test_000_001,
#endif
NULL
};

169
test/nil/test_sequence_001.c
View File

@ -19,15 +19,16 @@
#include "test_root.h" #include "test_root.h"
/** /**
* @page test_sequence_001 Semaphores functionality * @page test_sequence_000 Threads Functionality
* *
* File: @ref test_sequence_001.c * File: @ref test_sequence_000.c
* *
* <h2>Description</h2> * <h2>Description</h2>
* This sequence tests the ChibiOS/NIL functionalities related to semaphores. * This sequence tests the ChibiOS/NIL functionalities related to threading.
* *
* <h2>Test Cases</h2> * <h2>Test Cases</h2>
* - @subpage test_001_000 * - @subpage test_000_000
* - @subpage test_000_001
* . * .
*/ */
@ -35,7 +36,6 @@
* Shared code. * Shared code.
****************************************************************************/ ****************************************************************************/
static semaphore_t sem1;
/**************************************************************************** /****************************************************************************
* Test cases. * Test cases.
@ -43,124 +43,125 @@ static semaphore_t sem1;
#if TRUE || defined(__DOXYGEN__) #if TRUE || defined(__DOXYGEN__)
/** /**
* @page test_001_000 Semaphores primitives, no state change * @page test_000_000 System Tick Counter functionality
* *
* <h2>Description</h2> * <h2>Description</h2>
* Wait, Signal and Reset primitives are tested. The testing thread does not * The functionality of the API @p chVTGetSystemTimeX() is tested.
* trigger a state change.
* *
* <h2>Conditions</h2> * <h2>Conditions</h2>
* None. * None.
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - The function chSemWait() is invoked, the Semaphore counter is tested * - A System Tick Counter increment is expected, the test simply hangs if
* for correct value after the call. * it does not happen.
* - The function chSemSignal() is invoked, the Semaphore counter is tested
* for correct value after the call.
* - The function chSemReset() is invoked, the Semaphore counter is tested
* for correct value after the call.
* . * .
*/ */
static void test_001_000_setup(void) { static void test_000_000_execute(void) {
systime_t time;
chSemObjectInit(&sem1, 1); /* A System Tick Counter increment is expected, the test simply hangs if
} it does not happen.*/
static void test_001_000_teardown(void) {
chSemReset(&sem1, 0);
}
static void test_001_000_execute(void) {
/* The function chSemWait() is invoked, the Semaphore counter is tested
for correct value after the call.*/
test_set_step(1); test_set_step(1);
{ {
chSemWait(&sem1); time = chVTGetSystemTimeX();
test_assert_lock(chSemGetCounterI(&sem1) == 0, while (time == chVTGetSystemTimeX()) {
"wrong counter value"); }
}
/* The function chSemSignal() is invoked, the Semaphore counter is tested
for correct value after the call.*/
test_set_step(2);
{
chSemSignal(&sem1);
test_assert_lock(chSemGetCounterI(&sem1) == 1,
"wrong counter value");
}
/* The function chSemReset() is invoked, the Semaphore counter is tested
for correct value after the call.*/
test_set_step(3);
{
chSemReset(&sem1, 2);
test_assert_lock(chSemGetCounterI(&sem1) == 2,
"wrong counter value");
} }
} }
static const testcase_t test_001_000 = { static const testcase_t test_000_000 = {
"Brief description", "System Tick Counter functionality",
test_001_000_setup, NULL,
test_001_000_teardown, NULL,
test_001_000_execute test_000_000_execute
}; };
#endif /* TRUE */ #endif /* TRUE */
#if TRUE || defined(__DOXYGEN__) #if TRUE || defined(__DOXYGEN__)
/** /**
* @page test_001_000 Semaphores timeout * @page test_000_001 Thread Sleep functionality
* *
* <h2>Description</h2> * <h2>Description</h2>
* Timeouts on semaphores are tested. * The functionality of the API @p chThdSleep() and derivatives is tested.
* *
* <h2>Conditions</h2> * <h2>Conditions</h2>
* None. * None.
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - The function chSemWaitTimeout() is invoked, after return the system * - The current system time is read then a sleep is performed for 100 system
* time, the counter and the returned message are tested. * ticks and on exit the system time is verified again.
* - The current system time is read then a sleep is performed for 100000
* microseconds and on exit the system time is verified again.
* - The current system time is read then a sleep is performed for 100
* milliseconds and on exit the system time is verified again.
* - The current system time is read then a sleep is performed for 1
* second and on exit the system time is verified again.
* . * .
*/ */
static void test_001_001_setup(void) { static void test_000_001_execute(void) {
chSemObjectInit(&sem1, 0);
}
static void test_001_001_teardown(void) {
chSemReset(&sem1, 0);
}
static void test_001_001_execute(void) {
systime_t time; systime_t time;
msg_t msg;
/* The function chSemWaitTimeout() is invoked, after return the system /* The current system time is read then a sleep is performed for 100 system
time, the counter and the returned message are tested.*/ ticks and on exit the system time is verified again.*/
test_set_step(1); test_set_step(1);
{ {
time = chVTGetSystemTimeX(); time = chVTGetSystemTimeX();
msg = chSemWaitTimeout(&sem1, 100); chThdSleep(100);
test_assert_time_window(time + 100,
time + 100 + 1,
"out of time window");
}
/* The current system time is read then a sleep is performed for 100000
microseconds and on exit the system time is verified again.*/
test_set_step(2);
{
time = chVTGetSystemTimeX();
chThdSleepMicroseconds(100);
test_assert_time_window(time + US2ST(100),
time + US2ST(100) + 1,
"out of time window");
}
/* The current system time is read then a sleep is performed for 100
milliseconds and on exit the system time is verified again.*/
test_set_step(3);
{
time = chVTGetSystemTimeX();
chThdSleepMilliseconds(100);
test_assert_time_window(time + MS2ST(100),
time + MS2ST(100) + 1,
"out of time window");
}
/* The current system time is read then a sleep is performed for 1
second and on exit the system time is verified again.*/
test_set_step(4);
{
time = chVTGetSystemTimeX();
chThdSleepSeconds(1);
test_assert_time_window(time + S2ST(1),
time + S2ST(1) + 1,
"out of time window");
}
test_set_step(5);
{
time = chVTGetSystemTimeX();
chThdSleepUntil(time + 100);
test_assert_time_window(time + 100, test_assert_time_window(time + 100,
time + 100 + 1, time + 100 + 1,
"out of time window"); "out of time window");
test_assert_lock(chSemGetCounterI(&sem1) == 0,
"wrong counter value");
test_assert(MSG_TIMEOUT == msg,
"wrong timeout message");
} }
} }
static const testcase_t test_001_001 = { static const testcase_t test_000_001 = {
"Brief description", "Thread Sleep functionality",
test_001_001_setup, NULL,
test_001_001_teardown, NULL,
test_001_001_execute test_000_001_execute
}; };
#endif /* TRUE */ #endif /* TRUE */
@ -171,12 +172,12 @@ static const testcase_t test_001_001 = {
/** /**
* @brief Sequence brief description. * @brief Sequence brief description.
*/ */
const testcase_t * const test_sequence_001[] = { const testcase_t * const test_sequence_000[] = {
#if TRUE || defined(__DOXYGEN__) #if TRUE || defined(__DOXYGEN__)
&test_001_000, &test_000_000,
#endif #endif
#if TRUE || defined(__DOXYGEN__) #if TRUE || defined(__DOXYGEN__)
&test_001_001, &test_000_001,
#endif #endif
NULL NULL
}; };

8
test/nil/test_sequence_001.h
View File

@ -14,9 +14,9 @@
limitations under the License. limitations under the License.
*/ */
#ifndef _TEST_SEQUENCE_001_H_ #ifndef _TEST_SEQUENCE_000_H_
#define _TEST_SEQUENCE_001_H_ #define _TEST_SEQUENCE_000_H_
extern const testcase_t * const test_sequence_001[]; extern const testcase_t * const test_sequence_000[];
#endif /* _TEST_SEQUENCE_001_H_ */ #endif /* _TEST_SEQUENCE_000_H_ */

182
test/nil/test_sequence_002.c Normal file
View File

@ -0,0 +1,182 @@
/*
ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include "hal.h"
#include "ch_test.h"
#include "test_root.h"
/**
* @page test_sequence_001 Semaphores functionality
*
* File: @ref test_sequence_001.c
*
* <h2>Description</h2>
* This sequence tests the ChibiOS/NIL functionalities related to semaphores.
*
* <h2>Test Cases</h2>
* - @subpage test_001_000
* .
*/
/****************************************************************************
* Shared code.
****************************************************************************/
static semaphore_t sem1;
/****************************************************************************
* Test cases.
****************************************************************************/
#if TRUE || defined(__DOXYGEN__)
/**
* @page test_001_000 Semaphores primitives, no state change
*
* <h2>Description</h2>
* Wait, Signal and Reset primitives are tested. The testing thread does not
* trigger a state change.
*
* <h2>Conditions</h2>
* None.
*
* <h2>Test Steps</h2>
* - The function chSemWait() is invoked, the Semaphore counter is tested
* for correct value after the call.
* - The function chSemSignal() is invoked, the Semaphore counter is tested
* for correct value after the call.
* - The function chSemReset() is invoked, the Semaphore counter is tested
* for correct value after the call.
* .
*/
static void test_001_000_setup(void) {
chSemObjectInit(&sem1, 1);
}
static void test_001_000_teardown(void) {
chSemReset(&sem1, 0);
}
static void test_001_000_execute(void) {
/* The function chSemWait() is invoked, the Semaphore counter is tested
for correct value after the call.*/
test_set_step(1);
{
chSemWait(&sem1);
test_assert_lock(chSemGetCounterI(&sem1) == 0,
"wrong counter value");
}
/* The function chSemSignal() is invoked, the Semaphore counter is tested
for correct value after the call.*/
test_set_step(2);
{
chSemSignal(&sem1);
test_assert_lock(chSemGetCounterI(&sem1) == 1,
"wrong counter value");
}
/* The function chSemReset() is invoked, the Semaphore counter is tested
for correct value after the call.*/
test_set_step(3);
{
chSemReset(&sem1, 2);
test_assert_lock(chSemGetCounterI(&sem1) == 2,
"wrong counter value");
}
}
static const testcase_t test_001_000 = {
"Brief description",
test_001_000_setup,
test_001_000_teardown,
test_001_000_execute
};
#endif /* TRUE */
#if TRUE || defined(__DOXYGEN__)
/**
* @page test_001_000 Semaphores timeout
*
* <h2>Description</h2>
* Timeouts on semaphores are tested.
*
* <h2>Conditions</h2>
* None.
*
* <h2>Test Steps</h2>
* - The function chSemWaitTimeout() is invoked, after return the system
* time, the counter and the returned message are tested.
* .
*/
static void test_001_001_setup(void) {
chSemObjectInit(&sem1, 0);
}
static void test_001_001_teardown(void) {
chSemReset(&sem1, 0);
}
static void test_001_001_execute(void) {
systime_t time;
msg_t msg;
/* The function chSemWaitTimeout() is invoked, after return the system
time, the counter and the returned message are tested.*/
test_set_step(1);
{
time = chVTGetSystemTimeX();
msg = chSemWaitTimeout(&sem1, 100);
test_assert_time_window(time + 100,
time + 100 + 1,
"out of time window");
test_assert_lock(chSemGetCounterI(&sem1) == 0,
"wrong counter value");
test_assert(MSG_TIMEOUT == msg,
"wrong timeout message");
}
}
static const testcase_t test_001_001 = {
"Brief description",
test_001_001_setup,
test_001_001_teardown,
test_001_001_execute
};
#endif /* TRUE */
/****************************************************************************
* Exported data.
****************************************************************************/
/**
* @brief Sequence brief description.
*/
const testcase_t * const test_sequence_001[] = {
#if TRUE || defined(__DOXYGEN__)
&test_001_000,
#endif
#if TRUE || defined(__DOXYGEN__)
&test_001_001,
#endif
NULL
};

8
test/nil/test_sequence_000.h → test/nil/test_sequence_002.h
View File

@ -14,9 +14,9 @@
limitations under the License. limitations under the License.
*/ */
#ifndef _TEST_SEQUENCE_000_H_ #ifndef _TEST_SEQUENCE_001_H_
#define _TEST_SEQUENCE_000_H_ #define _TEST_SEQUENCE_001_H_
extern const testcase_t * const test_sequence_000[]; extern const testcase_t * const test_sequence_001[];
#endif /* _TEST_SEQUENCE_000_H_ */ #endif /* _TEST_SEQUENCE_001_H_ */