sptests/spchain/init.c

0001 /* SPDX-License-Identifier: BSD-2-Clause */
0002
0003 /*
0004  *  COPYRIGHT (c) 1989-2012.
0005  *  On-Line Applications Research Corporation (OAR).
0006  *
0007  * Redistribution and use in source and binary forms, with or without
0008  * modification, are permitted provided that the following conditions
0009  * are met:
0010  * 1. Redistributions of source code must retain the above copyright
0011  *    notice, this list of conditions and the following disclaimer.
0012  * 2. Redistributions in binary form must reproduce the above copyright
0013  *    notice, this list of conditions and the following disclaimer in the
0014  *    documentation and/or other materials provided with the distribution.
0015  *
0016  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
0017  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
0018  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
0019  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
0020  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
0021  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
0022  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
0023  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
0024  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
0025  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
0026  * POSSIBILITY OF SUCH DAMAGE.
0027  */
0028
0029 #ifdef HAVE_CONFIG_H
0030 #include "config.h"
0031 #endif
0032
0033 #include <tmacros.h>
0034 #include <rtems/chain.h>
0035
0036 const char rtems_test_name[] = "SPCHAIN";
0037
0038 static void test_chain_init_one(void)
0039 {
0040   Chain_Control chain;
0041   Chain_Node    node;
0042
0043   puts( "INIT - Verify _Chain_Initialize_one" );
0044
0045   _Chain_Initialize_node( &node );
0046   _Chain_Initialize_one( &chain, &node );
0047   rtems_test_assert( !_Chain_Is_empty( &chain ) );
0048   rtems_test_assert( !_Chain_Is_node_off_chain( &node ) );
0049   rtems_test_assert( _Chain_Is_first( &node ) );
0050   rtems_test_assert( _Chain_Is_last( &node ) );
0051   rtems_test_assert( _Chain_First( &chain ) == &node );
0052   rtems_test_assert( _Chain_Last( &chain ) == &node );
0053   rtems_test_assert( _Chain_Next( &node ) == _Chain_Tail( &chain ) );
0054   rtems_test_assert( _Chain_Previous( &node ) == _Chain_Head( &chain ) );
0055
0056   _Chain_Extract_unprotected( &node );
0057   rtems_test_assert( _Chain_Is_empty( &chain ) );
0058 }
0059
0060 static void update_registry_and_extract(
0061   Chain_Iterator_registry *reg,
0062   Chain_Node *n
0063 )
0064 {
0065   _Chain_Iterator_registry_update( reg, n );
0066   _Chain_Extract_unprotected( n );
0067 }
0068
0069 static Chain_Iterator_registry static_reg =
0070   CHAIN_ITERATOR_REGISTRY_INITIALIZER( static_reg );
0071
0072 static void test_chain_iterator( void )
0073 {
0074   Chain_Control chain;
0075   Chain_Iterator_registry reg;
0076   Chain_Iterator fit;
0077   Chain_Iterator bit;
0078   Chain_Node a;
0079   Chain_Node b;
0080   Chain_Node c;
0081
0082   puts( "INIT - Verify Chain_Iterator" );
0083
0084   rtems_test_assert( _Chain_Is_empty( &static_reg.Iterators ));
0085
0086   _Chain_Initialize_empty( &chain );
0087   _Chain_Initialize_node( &a );
0088   _Chain_Initialize_node( &b );
0089   _Chain_Initialize_node( &c );
0090   _Chain_Iterator_registry_initialize( &reg );
0091   _Chain_Iterator_initialize( &chain, &reg, &fit, CHAIN_ITERATOR_FORWARD );
0092   _Chain_Iterator_initialize( &chain, &reg, &bit, CHAIN_ITERATOR_BACKWARD );
0093
0094   rtems_test_assert( _Chain_Iterator_next( &fit ) == _Chain_Tail( &chain ));
0095   rtems_test_assert( _Chain_Iterator_next( &bit ) == _Chain_Head( &chain ));
0096
0097   _Chain_Iterator_set_position( &fit, _Chain_Head( &chain ) );
0098   _Chain_Iterator_set_position( &bit, _Chain_Tail( &chain ) );
0099   rtems_test_assert( _Chain_Iterator_next( &fit ) == _Chain_Tail( &chain ));
0100   rtems_test_assert( _Chain_Iterator_next( &bit ) == _Chain_Head( &chain ));
0101
0102   _Chain_Append_unprotected( &chain, &a );
0103   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0104   rtems_test_assert( _Chain_Iterator_next( &bit ) == &a );
0105
0106   _Chain_Append_unprotected( &chain, &b );
0107   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0108   rtems_test_assert( _Chain_Iterator_next( &bit ) == &b );
0109
0110   _Chain_Append_unprotected( &chain, &c );
0111   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0112   rtems_test_assert( _Chain_Iterator_next( &bit ) == &c );
0113
0114   update_registry_and_extract( &reg, &b );
0115   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0116   rtems_test_assert( _Chain_Iterator_next( &bit ) == &c );
0117
0118   _Chain_Insert_unprotected( &a, &b );
0119   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0120   rtems_test_assert( _Chain_Iterator_next( &bit ) == &c );
0121
0122   update_registry_and_extract( &reg, &c );
0123   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0124   rtems_test_assert( _Chain_Iterator_next( &bit ) == &b );
0125
0126   _Chain_Append_unprotected( &chain, &c );
0127   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0128   rtems_test_assert( _Chain_Iterator_next( &bit ) == &c );
0129
0130   update_registry_and_extract( &reg, &a );
0131   rtems_test_assert( _Chain_Iterator_next( &fit ) == &b );
0132   rtems_test_assert( _Chain_Iterator_next( &bit ) == &c );
0133
0134   _Chain_Prepend_unprotected( &chain, &a );
0135   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0136   rtems_test_assert( _Chain_Iterator_next( &bit ) == &c );
0137
0138   update_registry_and_extract( &reg, &a );
0139   rtems_test_assert( _Chain_Iterator_next( &fit ) == &b );
0140   rtems_test_assert( _Chain_Iterator_next( &bit ) == &c );
0141
0142   update_registry_and_extract( &reg, &b );
0143   rtems_test_assert( _Chain_Iterator_next( &fit ) == &c );
0144   rtems_test_assert( _Chain_Iterator_next( &bit ) == &c );
0145
0146   update_registry_and_extract( &reg, &c );
0147   rtems_test_assert( _Chain_Iterator_next( &fit ) == _Chain_Tail( &chain ));
0148   rtems_test_assert( _Chain_Iterator_next( &bit ) == _Chain_Head( &chain ));
0149
0150   _Chain_Append_unprotected( &chain, &a );
0151   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0152   rtems_test_assert( _Chain_Iterator_next( &bit ) == &a );
0153
0154   _Chain_Append_unprotected( &chain, &b );
0155   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0156   rtems_test_assert( _Chain_Iterator_next( &bit ) == &b );
0157
0158   _Chain_Append_unprotected( &chain, &c );
0159   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0160   rtems_test_assert( _Chain_Iterator_next( &bit ) == &c );
0161
0162   update_registry_and_extract( &reg, &c );
0163   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0164   rtems_test_assert( _Chain_Iterator_next( &bit ) == &b );
0165
0166   update_registry_and_extract( &reg, &b );
0167   rtems_test_assert( _Chain_Iterator_next( &fit ) == &a );
0168   rtems_test_assert( _Chain_Iterator_next( &bit ) == &a );
0169
0170   update_registry_and_extract( &reg, &a );
0171   rtems_test_assert( _Chain_Iterator_next( &fit ) == _Chain_Tail( &chain ));
0172   rtems_test_assert( _Chain_Iterator_next( &bit ) == _Chain_Head( &chain ));
0173
0174   rtems_test_assert( !_Chain_Is_empty( &reg.Iterators ));
0175   _Chain_Iterator_destroy( &fit );
0176   rtems_test_assert( !_Chain_Is_empty( &reg.Iterators ));
0177   _Chain_Iterator_destroy( &bit );
0178   rtems_test_assert( _Chain_Is_empty( &reg.Iterators ));
0179 }
0180
0181 /* forward declarations to avoid warnings */
0182 rtems_task Init(rtems_task_argument argument);
0183
0184 #define EVENT RTEMS_EVENT_13
0185 #define TIMEOUT 1
0186
0187 typedef struct {
0188   rtems_chain_node Node;
0189   int              id;
0190 } test_node;
0191
0192 static rtems_chain_control one_node_chain;
0193
0194 static rtems_chain_node node_of_one_node_chain =
0195   RTEMS_CHAIN_NODE_INITIALIZER_ONE_NODE_CHAIN( &one_node_chain );
0196
0197 static rtems_chain_control one_node_chain =
0198   RTEMS_CHAIN_INITIALIZER_ONE_NODE( &node_of_one_node_chain );
0199
0200 static void test_chain_control_initializer(void)
0201 {
0202   rtems_chain_control chain = RTEMS_CHAIN_INITIALIZER_EMPTY( chain );
0203
0204   puts( "INIT - Verify rtems_chain_control initializer" );
0205
0206   rtems_test_assert( rtems_chain_is_empty( &chain ) );
0207
0208   rtems_test_assert( rtems_chain_has_only_one_node( &one_node_chain ) );
0209   rtems_test_assert(
0210     rtems_chain_immutable_first( &one_node_chain ) == &node_of_one_node_chain
0211   );
0212   rtems_test_assert(
0213     rtems_chain_immutable_last( &one_node_chain ) == &node_of_one_node_chain
0214   );
0215   rtems_test_assert(
0216     rtems_chain_immutable_head( &one_node_chain )
0217       == rtems_chain_immutable_previous( &node_of_one_node_chain )
0218   );
0219   rtems_test_assert(
0220     rtems_chain_immutable_tail( &one_node_chain )
0221       == rtems_chain_immutable_next( &node_of_one_node_chain )
0222   );
0223 }
0224
0225 static void test_chain_control_layout(void)
0226 {
0227   Chain_Control chain;
0228
0229   puts( "INIT - Verify rtems_chain_control layout" );
0230
0231   rtems_test_assert(
0232     sizeof(Chain_Control)
0233       == sizeof(Chain_Node) + sizeof(Chain_Node *)
0234   );
0235   rtems_test_assert(
0236     sizeof(Chain_Control)
0237       == 3 * sizeof(Chain_Node *)
0238   );
0239   rtems_test_assert(
0240     _Chain_Previous( _Chain_Head( &chain ) )
0241       == _Chain_Next( _Chain_Tail( &chain ) )
0242   );
0243
0244 #if !defined( RTEMS_SMP )
0245   rtems_test_assert(
0246     sizeof(Chain_Control)
0247       == sizeof(rtems_chain_control)
0248   );
0249 #endif
0250 }
0251
0252 static void test_chain_get_with_wait(void)
0253 {
0254   rtems_status_code sc = RTEMS_SUCCESSFUL;
0255   rtems_chain_control chain;
0256   rtems_chain_node *p = (rtems_chain_node *) 1;
0257
0258   puts( "INIT - Verify rtems_chain_get_with_wait" );
0259   rtems_chain_initialize_empty( &chain );
0260   sc = rtems_chain_get_with_wait( &chain, EVENT, TIMEOUT, &p );
0261   rtems_test_assert( sc == RTEMS_TIMEOUT );
0262   rtems_test_assert( p == NULL );
0263 }
0264
0265 static void test_chain_first_and_last(void)
0266 {
0267   rtems_chain_control   chain;
0268   rtems_chain_node      node1, node2;
0269   rtems_chain_node     *cnode;
0270
0271   rtems_chain_initialize_empty( &chain );
0272   rtems_chain_initialize_node( &node1 );
0273   rtems_chain_initialize_node( &node2 );
0274   rtems_chain_append( &chain, &node1 );
0275   rtems_chain_insert( &node1, &node2 );
0276
0277   puts( "INIT - Verify rtems_chain_is_first" );
0278   cnode = rtems_chain_first(&chain);
0279   rtems_test_assert( rtems_chain_is_first( cnode ) );
0280
0281   puts( "INIT - Verify rtems_chain_is_last" );
0282   cnode = rtems_chain_last(&chain);
0283   rtems_test_assert( rtems_chain_is_last( cnode ) );
0284
0285   cnode = rtems_chain_get_first_unprotected( &chain );
0286   rtems_test_assert( cnode == &node1 );
0287   cnode = rtems_chain_first( &chain );
0288   rtems_test_assert( cnode == &node2 );
0289   cnode = rtems_chain_last( &chain );
0290   rtems_test_assert( cnode == &node2 );
0291 }
0292
0293 static void test_chain_with_notification(void)
0294 {
0295   rtems_status_code sc = RTEMS_SUCCESSFUL;
0296   rtems_chain_control chain;
0297   rtems_chain_node a;
0298   rtems_chain_node b;
0299   rtems_chain_node *p = (rtems_chain_node *) 1;
0300   rtems_event_set out = 0;
0301
0302   puts( "INIT - Verify rtems_chain_append_with_notification" );
0303   rtems_chain_initialize_empty( &chain );
0304   rtems_chain_initialize_node( &a );
0305   sc = rtems_chain_append_with_notification(
0306     &chain,
0307     &a,
0308     rtems_task_self(),
0309     EVENT
0310   );
0311   rtems_test_assert( sc == RTEMS_SUCCESSFUL );
0312   sc = rtems_chain_get_with_wait( &chain, EVENT, TIMEOUT, &p );
0313   rtems_test_assert( sc == RTEMS_SUCCESSFUL );
0314   rtems_test_assert( p == &a );
0315
0316   rtems_chain_initialize_empty( &chain );
0317   rtems_chain_initialize_node( &a );
0318   rtems_chain_initialize_node( &b );
0319
0320   rtems_chain_append( &chain, &b );
0321   sc = rtems_chain_append_with_notification(
0322     &chain,
0323     &a,
0324     rtems_task_self(),
0325     EVENT
0326   );
0327   rtems_test_assert( sc == RTEMS_SUCCESSFUL );
0328   rtems_test_assert( p == &a );
0329
0330   puts( "INIT - Verify rtems_chain_prepend_with_notification" );
0331   rtems_chain_initialize_empty( &chain );
0332   rtems_chain_initialize_node( &a );
0333   rtems_chain_initialize_node( &b );
0334   sc = rtems_chain_prepend_with_notification(
0335     &chain,
0336     &a,
0337     rtems_task_self(),
0338     EVENT
0339   );
0340   rtems_test_assert( sc == RTEMS_SUCCESSFUL );
0341   sc = rtems_chain_get_with_wait( &chain, EVENT, TIMEOUT, &p );
0342   rtems_test_assert( sc == RTEMS_SUCCESSFUL );
0343   rtems_test_assert( p == &a );
0344
0345   rtems_chain_prepend( &chain, &b );
0346   sc = rtems_chain_prepend_with_notification(
0347     &chain,
0348     &a,
0349     rtems_task_self(),
0350     EVENT
0351   );
0352   rtems_test_assert( sc == RTEMS_SUCCESSFUL );
0353   rtems_test_assert( p == &a );
0354
0355   puts( "INIT - Verify rtems_chain_get_with_notification" );
0356   rtems_chain_initialize_empty( &chain );
0357   rtems_chain_initialize_node( &a );
0358   rtems_chain_initialize_node( &b );
0359
0360   rtems_chain_append( &chain, &b );
0361   rtems_chain_append( &chain, &a );
0362
0363   sc = rtems_chain_get_with_notification(&chain, rtems_task_self(), EVENT, &p);
0364   rtems_test_assert( sc == RTEMS_SUCCESSFUL );
0365   rtems_test_assert( p == &b );
0366
0367   sc = rtems_chain_get_with_notification(&chain, rtems_task_self(), EVENT, &p);
0368   rtems_test_assert( sc == RTEMS_SUCCESSFUL );
0369   rtems_test_assert( p == &a );
0370   sc = rtems_event_receive(
0371     EVENT,
0372     RTEMS_EVENT_ALL | RTEMS_WAIT,
0373     TIMEOUT,
0374     &out
0375   );
0376   rtems_test_assert( sc == RTEMS_SUCCESSFUL );
0377   rtems_test_assert( out == EVENT );
0378 }
0379
0380 static void test_chain_with_empty_check(void)
0381 {
0382   rtems_chain_control chain;
0383   rtems_chain_node a;
0384   rtems_chain_node b;
0385   rtems_chain_node c;
0386   rtems_chain_node *p;
0387   bool empty;
0388
0389   puts( "INIT - Verify rtems_chain_append_with_empty_check" );
0390   rtems_chain_initialize_empty( &chain );
0391   rtems_chain_initialize_node( &a );
0392   rtems_chain_initialize_node( &b );
0393   empty = rtems_chain_append_with_empty_check( &chain, &a );
0394   rtems_test_assert( empty );
0395   empty = rtems_chain_append_with_empty_check( &chain, &b );
0396   rtems_test_assert( !empty );
0397
0398   puts( "INIT - Verify rtems_chain_prepend_with_empty_check" );
0399   rtems_chain_initialize_empty( &chain );
0400   rtems_chain_initialize_node( &a );
0401   rtems_chain_initialize_node( &b );
0402   rtems_chain_initialize_node( &c );
0403   empty = rtems_chain_prepend_with_empty_check( &chain, &a );
0404   rtems_test_assert( empty );
0405   empty = rtems_chain_prepend_with_empty_check( &chain, &b );
0406   rtems_test_assert( !empty );
0407   empty = rtems_chain_prepend_with_empty_check( &chain, &c );
0408   rtems_test_assert( !empty );
0409
0410   puts( "INIT - Verify rtems_chain_get_with_empty_check" );
0411   rtems_chain_initialize_empty( &chain );
0412   rtems_chain_initialize_node( &a );
0413   rtems_chain_initialize_node( &b );
0414   empty = rtems_chain_get_with_empty_check( &chain, &p );
0415   rtems_test_assert( empty );
0416
0417   rtems_chain_append( &chain, &a );
0418   rtems_chain_append( &chain, &b );
0419   empty = rtems_chain_get_with_empty_check( &chain, &p );
0420   rtems_test_assert( !empty );
0421   rtems_test_assert( p == &a );
0422   empty = rtems_chain_get_with_empty_check( &chain, &p );
0423   rtems_test_assert( empty );
0424   rtems_test_assert( p == &b );
0425 }
0426
0427 static void test_chain_node_count(void)
0428 {
0429   rtems_chain_control chain;
0430   rtems_chain_node nodes[3];
0431   size_t count;
0432   size_t i;
0433
0434   puts( "INIT - Verify rtems_chain_node_count_unprotected" );
0435
0436   rtems_chain_initialize_empty( &chain );
0437   count = rtems_chain_node_count_unprotected( &chain );
0438   rtems_test_assert( count == 0 );
0439
0440   for (i = 0; i < RTEMS_ARRAY_SIZE( nodes ); ++i) {
0441     rtems_chain_initialize_node( &nodes[ i ] );
0442     rtems_chain_append_unprotected( &chain, &nodes[i] );
0443     count = rtems_chain_node_count_unprotected( &chain );
0444     rtems_test_assert( count == i + 1 );
0445   }
0446 }
0447
0448 static bool test_order(
0449   const void       *key,
0450   const Chain_Node *left,
0451   const Chain_Node *right
0452 )
0453 {
0454   rtems_test_assert( key == left );
0455
0456   return (uintptr_t) left < (uintptr_t) right;
0457 }
0458
0459 static void insert_ordered( Chain_Control *chain, Chain_Node *node )
0460 {
0461   _Chain_Insert_ordered_unprotected( chain, node, node, test_order );
0462 }
0463
0464 static void test_chain_insert_ordered( void )
0465 {
0466   Chain_Control chain = CHAIN_INITIALIZER_EMPTY(chain);
0467   Chain_Node nodes[5];
0468   const Chain_Node *tail;
0469   const Chain_Node *node;
0470   size_t n = RTEMS_ARRAY_SIZE( nodes );
0471   size_t i;
0472
0473   puts( "INIT - Verify _Chain_Insert_ordered_unprotected" );
0474
0475   for ( i = 0; i < n; ++i ) {
0476     _Chain_Initialize_node( &nodes[ i ] );
0477   }
0478
0479   insert_ordered( &chain, &nodes[4] );
0480   insert_ordered( &chain, &nodes[2] );
0481   insert_ordered( &chain, &nodes[0] );
0482   insert_ordered( &chain, &nodes[3] );
0483   insert_ordered( &chain, &nodes[1] );
0484
0485   tail = _Chain_Immutable_tail( &chain );
0486   node = _Chain_Immutable_first( &chain );
0487   i = 0;
0488   while ( node != tail && i < n ) {
0489     rtems_test_assert( node == &nodes[ i ] );
0490     ++i;
0491     node = _Chain_Immutable_next( node );
0492   }
0493
0494   rtems_test_assert( i == n );
0495 }
0496
0497 rtems_task Init(
0498   rtems_task_argument ignored
0499 )
0500 {
0501   rtems_chain_control  chain1;
0502   rtems_chain_node    *p;
0503   test_node            node1, node2;
0504   int                  id;
0505
0506   TEST_BEGIN();
0507
0508   puts( "Init - Initialize chain empty" );
0509   rtems_chain_initialize_empty( &chain1 );
0510   rtems_chain_initialize_node( &node1.Node );
0511   rtems_chain_initialize_node( &node2.Node );
0512
0513   /* verify that the chain append and insert work */
0514   puts( "INIT - Verify rtems_chain_insert" );
0515   node1.id = 1;
0516   node2.id = 2;
0517   rtems_chain_append( &chain1, &node1.Node );
0518   rtems_chain_insert( &node1.Node, &node2.Node );
0519
0520   for ( p = rtems_chain_first(&chain1), id = 1 ;
0521         !rtems_chain_is_tail(&chain1, p) ;
0522         p = p->next , id++ ) {
0523      test_node *t = (test_node *)p;
0524      if ( id > 2 ) {
0525        puts( "INIT - TOO MANY NODES ON CHAIN" );
0526        rtems_test_exit(0);
0527      }
0528      if ( t->id != id ) {
0529        puts( "INIT - ERROR ON CHAIN ID MISMATCH" );
0530        rtems_test_exit(0);
0531      }
0532   }
0533
0534   test_chain_init_one();
0535   test_chain_first_and_last();
0536   test_chain_with_empty_check();
0537   test_chain_with_notification();
0538   test_chain_get_with_wait();
0539   test_chain_control_layout();
0540   test_chain_control_initializer();
0541   test_chain_node_count();
0542   test_chain_insert_ordered();
0543   test_chain_iterator();
0544
0545   TEST_END();
0546   rtems_test_exit(0);
0547 }
0548
0549 /* configuration information */
0550
0551 #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
0552 #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
0553
0554 #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
0555
0556 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE
0557 #define CONFIGURE_MAXIMUM_TASKS 1
0558
0559 #define CONFIGURE_INIT
0560 #include <rtems/confdefs.h>
0561
0562 /* global variables */