Changeset b1274bd9 in rtems


Ignore:
Timestamp:
Nov 30, 2009, 3:33:25 AM (9 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, master
Children:
3495c57
Parents:
44b06ca
Message:

Whitespace removal.

Location:
testsuites
Files:
116 edited

Legend:

Unmodified
Added
Removed
  • testsuites/libtests/block06/init.c

    r44b06ca rb1274bd9  
    341341  char name[6];
    342342  sprintf (name, "bdt%d", task);
    343  
     343
    344344  tc->die    = false;
    345345  tc->name   = strdup (name); /* leaks */
     
    367367        bdd->watch_count = 0;
    368368    }
    369    
     369
    370370    if (bdd->watch_count == 0)
    371371    {
     
    376376    }
    377377  }
    378  
     378
    379379  return true;
    380380}
     
    386386  bool result = true;
    387387  int  b;
    388  
     388
    389389  /*
    390390   * Perform the requested action.
     
    394394    case BDBUF_DISK_NOOP:
    395395      break;
    396      
     396
    397397    case BDBUF_DISK_WAIT:
    398398      if (bdd->waiting)
     
    446446   */
    447447  bdbuf_disk_ioctl_watcher (bdd, buffer_count);
    448  
     448
    449449  return true;
    450450}
     
    465465
    466466  errno = 0;
    467  
     467
    468468  if (!bdbuf_disk_lock (bdd))
    469469  {
     
    506506            bdbuf_disk_ioctl_leave (bdd, r->bufnum);
    507507            break;
    508            
     508
    509509          case RTEMS_BLKDEV_REQ_WRITE:
    510510            if (!bdbuf_disk_ioctl_process (bdd, r))
     
    513513            bdbuf_disk_ioctl_leave (bdd, r->bufnum);
    514514            break;
    515            
     515
    516516          default:
    517517            errno = EBADRQC;
     
    545545{
    546546  rtems_status_code sc;
    547  
     547
    548548  bdbuf_test_printf ("disk io init: ");
    549549  sc = rtems_disk_io_initialize ();
    550550  if (!bdbuf_test_print_sc (sc, true))
    551551    return sc;
    552  
     552
    553553  for (minor = 0; minor < BDBUF_DISKS; minor++)
    554554  {
     
    561561
    562562    bdd->name = strdup (name);
    563    
     563
    564564    bdbuf_test_printf ("disk init: %s\n", bdd->name);
    565565    bdbuf_test_printf ("disk lock: ");
     
    583583      return sc;
    584584    }
    585    
     585
    586586  }
    587587  return RTEMS_SUCCESSFUL;
     
    608608{
    609609  rtems_status_code sc;
    610  
     610
    611611  /*
    612612   * Register the disk driver.
     
    617617                                 &bdbuf_disk_io_ops,
    618618                                 major);
    619  
     619
    620620  return sc == RTEMS_SUCCESSFUL;
    621621}
     
    630630  bdbuf_test_printf ("creating task: %s: priority: %d: ",
    631631                     tc->name, priority);
    632  
     632
    633633  sc = rtems_task_create (rtems_build_name (tc->name[0], tc->name[1],
    634634                                            tc->name[2], tc->name[3]),
     
    640640  if (!bdbuf_test_print_sc (sc, true))
    641641    return false;
    642  
     642
    643643  bdbuf_test_printf ("starting task: %s: ", tc->name);
    644  
     644
    645645  sc = rtems_task_start (tc->task, entry_point, (rtems_task_argument) tc);
    646646
     
    660660  int                 i;
    661661  rtems_bdbuf_buffer* bd;
    662  
     662
    663663  /*
    664664   * Set task control's passed to false to handle a timeout.
     
    678678      break;
    679679    }
    680        
     680
    681681    bdbuf_test_printf ("%s: rtems_bdbuf_release[0]: ", tc->name);
    682682    sc = rtems_bdbuf_release (bd);
     
    687687    }
    688688  }
    689        
     689
    690690  tc->passed = passed;
    691691  tc->test = 0;
     
    705705  rtems_bdbuf_buffer* bd;
    706706  rtems_chain_control buffers;
    707  
     707
    708708  /*
    709709   * Set task control's passed to false to handle a timeout.
     
    711711  tc->passed = false;
    712712  passed = true;
    713        
     713
    714714  /*
    715715   * Get the blocks 0 -> 4 and hold them.
    716716   */
    717717  rtems_chain_initialize_empty (&buffers);
    718        
     718
    719719  for (i = 0; (i < 5) && passed; i++)
    720720  {
     
    733733   */
    734734  bdbuf_send_wait_event (tc->name, "wake master", tc->master);
    735                
     735
    736736  if (passed)
    737737  {
     
    766766    }
    767767  }
    768        
     768
    769769  tc->passed = passed;
    770770  tc->test = 0;
     
    781781  rtems_bdbuf_buffer* bd;
    782782  dev_t               device;
    783  
     783
    784784  /*
    785785   * Set task control's passed to false to handle a timeout.
     
    848848  rtems_chain_control buffers;
    849849  size_t              num = bdbuf_test_buffer_count ();
    850  
     850
    851851  /*
    852852   * Set task control's passed to false to handle a timeout.
     
    854854  tc->passed = false;
    855855  passed = true;
    856        
     856
    857857  /*
    858858   * Clear any disk settings.
     
    860860  bdbuf_clear_disk_driver_watch (tc);
    861861  bdbuf_set_disk_driver_action (tc, BDBUF_DISK_NOOP);
    862  
     862
    863863  /*
    864864   * Get the blocks 0 -> 4 and hold them.
    865865   */
    866866  rtems_chain_initialize_empty (&buffers);
    867        
     867
    868868  for (i = 0; (i < num) && passed; i++)
    869869  {
     
    882882   */
    883883  bdbuf_send_wait_event (tc->name, "wake master", tc->master);
    884                
     884
    885885  if (passed)
    886886  {
     
    894894     */
    895895    bdbuf_test_printf ("%s: rtems_bdbuf_release_modified[0]: unblocks task 1\n",
    896                        tc->name);   
     896                       tc->name);
    897897    bd = (rtems_bdbuf_buffer*) rtems_chain_get (&buffers);
    898898    sc = rtems_bdbuf_release_modified (bd);
     
    923923
    924924          bdbuf_set_disk_driver_watch (tc, num / 2);
    925        
     925
    926926          for (i = 0; (i < (num / 2)) && passed; i++)
    927927          {
     
    949949    }
    950950  }
    951        
     951
    952952  tc->passed = passed;
    953953  tc->test = 0;
     
    968968  rtems_bdbuf_buffer* bd;
    969969  rtems_chain_control buffers;
    970  
     970
    971971  /*
    972972   * Set task control's passed to false to handle a timeout.
     
    974974  tc->passed = false;
    975975  passed = true;
    976        
     976
    977977  /*
    978978   * Clear any disk settings.
     
    980980  bdbuf_clear_disk_driver_watch (tc);
    981981  bdbuf_set_disk_driver_action (tc, BDBUF_DISK_NOOP);
    982  
     982
    983983  /*
    984984   * Get the blocks 0 -> 4 and hold them.
    985985   */
    986986  rtems_chain_initialize_empty (&buffers);
    987        
     987
    988988  for (i = 0; (i < 5) && passed; i++)
    989989  {
     
    10141014    passed = bdbuf_test_print_sc (rtems_bdbuf_sync (bd), true);
    10151015  }
    1016        
     1016
    10171017  tc->passed = passed;
    10181018  tc->test = 0;
     
    10281028  rtems_chain_control buffers;
    10291029  dev_t               device;
    1030  
     1030
    10311031  /*
    10321032   * Set task control's passed to false to handle a timeout.
     
    10341034  tc->passed = false;
    10351035  passed = true;
    1036        
     1036
    10371037  /*
    10381038   * Clear any disk settings.
     
    10421042
    10431043  device = rtems_filesystem_make_dev_t (tc->major, tc->minor);
    1044  
     1044
    10451045  /*
    10461046   * Get the blocks 0 -> 4 and hold them.
    10471047   */
    10481048  rtems_chain_initialize_empty (&buffers);
    1049        
     1049
    10501050  for (i = 0; (i < 5) && passed; i++)
    10511051  {
     
    10751075    passed = bdbuf_test_print_sc (rtems_bdbuf_syncdev (device), true);
    10761076  }
    1077        
     1077
    10781078  tc->passed = passed;
    10791079  tc->test = 0;
     
    10911091  rtems_chain_node*   pnode;
    10921092  dev_t               device;
    1093  
     1093
    10941094  /*
    10951095   * Set task control's passed to false to handle a timeout.
     
    10971097  tc->passed = false;
    10981098  passed = true;
    1099        
     1099
    11001100  /*
    11011101   * Clear any disk settings.
     
    11051105
    11061106  device = rtems_filesystem_make_dev_t (tc->major, tc->minor);
    1107  
     1107
    11081108  /*
    11091109   * Get the blocks 0 -> 4 and hold them.
    11101110   */
    11111111  rtems_chain_initialize_empty (&buffers);
    1112        
     1112
    11131113  for (i = 0; (i < 5) && passed; i++)
    11141114  {
     
    11531153     */
    11541154    bdbuf_set_disk_driver_action (tc, BDBUF_DISK_BLOCKS_INORDER);
    1155    
     1155
    11561156    bdbuf_test_printf ("%s: rtems_bdbuf_syncdev[%d:%d]: checking order\n",
    11571157                       tc->name, i,
     
    11741174{
    11751175  bdbuf_task_control* tc = (bdbuf_task_control*) arg;
    1176  
     1176
    11771177  while (!tc->die)
    11781178  {
     
    11891189        bdbuf_tests_task_0_test_1 (tc);
    11901190        break;
    1191        
     1191
    11921192      case 2:
    11931193        bdbuf_tests_task_0_test_2 (tc);
     
    12471247  int                 i;
    12481248  rtems_bdbuf_buffer* bd;
    1249  
     1249
    12501250  /*
    12511251   * Set task control's passed to false to handle a timeout.
     
    12571257  {
    12581258    dev_t device = rtems_filesystem_make_dev_t (tc->major, tc->minor);
    1259    
     1259
    12601260    bdbuf_test_printf ("%s: rtems_bdbuf_get[%d]: blocking ...\n", tc->name, i);
    12611261    sc = rtems_bdbuf_get (device, i, &bd);
     
    12811281      bdbuf_send_wait_event (tc->name, "wake master", tc->master);
    12821282  }
    1283        
     1283
    12841284  tc->passed = passed;
    12851285  tc->test = 0;
     
    13461346{
    13471347  bdbuf_task_control* tc = (bdbuf_task_control*) arg;
    1348  
     1348
    13491349  while (!tc->die)
    13501350  {
     
    13861386  bdbuf_tests_task_2
    13871387};
    1388  
     1388
    13891389#define BDBUF_TESTS_PRI_HIGH (30)
    13901390
     
    14041404
    14051405    finished = true;
    1406    
     1406
    14071407    for (t = 0; t < BDBUF_TEST_TASKS; t++)
    14081408      if (tasks[t].test)
     
    14141414    if (finished)
    14151415      break;
    1416    
     1416
    14171417    bdbuf_sleep (250);
    14181418    time++;
     
    14311431      }
    14321432  }
    1433  
     1433
    14341434  return finished;
    14351435}
     
    14471447  /*
    14481448   * Use pool 0.
    1449    */ 
     1449   */
    14501450  tasks[0].minor = 0;
    1451  
     1451
    14521452  bdbuf_send_wait_event ("master", "wake task 0", tasks[0].task);
    14531453
     
    14661466{
    14671467  int i;
    1468  
     1468
    14691469  tasks[0].test = 2;
    14701470  tasks[1].test = 2;
     
    14941494   */
    14951495  bdbuf_send_wait_event ("master", "wake task 2", tasks[2].task);
    1496  
     1496
    14971497  for (i = 0; i < 5; i++)
    14981498  {
     
    15011501     */
    15021502    bdbuf_send_wait_event ("master", "wake task 0", tasks[0].task);
    1503    
     1503
    15041504    /*
    15051505     * Wait until task 2 has the buffer.
     
    15081508      return false;
    15091509  }
    1510  
     1510
    15111511  /*
    15121512   * Wait for the tests to finish.
     
    15351535   */
    15361536  bdbuf_send_wait_event ("master", "wake task 0", tasks[0].task);
    1537  
     1537
    15381538  return bdbuf_tests_finished (tasks);
    15391539}
     
    15811581   */
    15821582  bdbuf_send_wait_event ("master", "wake task 0", tasks[0].task);
    1583  
     1583
    15841584  return bdbuf_tests_finished (tasks);
    15851585}
     
    16271627   */
    16281628  bdbuf_send_wait_event ("master", "wake task 0", tasks[0].task);
    1629  
     1629
    16301630  return bdbuf_tests_finished (tasks);
    16311631}
     
    17131713  bdbuf_test  test;
    17141714} bdbuf_test_ident;
    1715  
     1715
    17161716/**
    17171717 * Table of tests.
     
    17761776                                                &old_priority),
    17771777                       true);
    1778  
     1778
    17791779  /*
    17801780   * This sets up the buffer pools.
     
    17961796   * Start the test tasks used to test the threading parts
    17971797   * of the bdbuf code.
    1798    */ 
     1798   */
    17991799  for (t = 0; t < BDBUF_TEST_TASKS; t++)
    18001800  {
     
    18021802                             rtems_task_self (),
    18031803                             major);
    1804  
     1804
    18051805    if (!bdbuf_tests_create_task (&tasks[t],
    18061806                                  BDBUF_TESTS_PRI_HIGH - t,
  • testsuites/libtests/bspcmdline01/init.c

    r44b06ca rb1274bd9  
    3939
    4040  bsp_boot_cmdline = NULL;
    41  
     41
    4242  puts( "rtems_bsp_cmdline_get_param - bsp_boot_cmdline=NULL - returns NULL" );
    4343  p = rtems_bsp_cmdline_get_param( "name", result, 5 );
     
    8484    else
    8585      printf( "rtems_bsp_cmdline_get_param_raw(%s) returned NULL\n", param );
    86    
     86
    8787    assert( p );
    8888  }
  • testsuites/libtests/bspcmdline01/test.c

    r44b06ca rb1274bd9  
    4343
    4444  bsp_boot_cmdline = NULL;
    45  
     45
    4646  puts( "bsp_cmdline_get_param - bsp_boot_cmdline=NULL - returns NULL" );
    4747  p = bsp_cmdline_get_param( "name", result, 5 );
     
    8787    else
    8888      printf( "bsp_cmdline_get_param_raw(%s) returned NULL\n", param );
    89    
     89
    9090    assert( p );
    9191  }
     
    117117void test_cmdline(void)
    118118{
    119    
     119
    120120  puts( "\n\n*** TEST OF PARSING BOOT COMMAND STRING ***" );
    121121
  • testsuites/libtests/heapwalk/init.c

    r44b06ca rb1274bd9  
    205205
    206206  puts( "Test the main loop" );
    207  
     207
    208208  puts( "\tset the blocksize so, that the next block is outside the heap" );
    209209  test_heap_init_custom();
     
    271271  Heap_Block *secound_free_block = NULL;
    272272  void *p1 = NULL;
    273  
     273
    274274  puts( "test the _Heap_Walk_check_free_block() function" );
    275275
  • testsuites/libtests/malloctest/init.c

    r44b06ca rb1274bd9  
    140140  /*
    141141   * Another odd case.  What we are trying to do from Sergei
    142    * 
     142   *
    143143   * 32-bit CPU when CPU_ALIGNMENT = 4 (most targets have 8) with the
    144144   * code like this:
     
    166166  test_free( p3 );
    167167  test_free( p1 );
    168  
     168
    169169  /*
    170    *  To tackle a special case of resizing a block in order to cover the 
     170   *  To tackle a special case of resizing a block in order to cover the
    171171   *  code in heapresizeblock.c
    172172   *
    173    *  Re-initialise the heap, so that the blocks created from now on 
     173   *  Re-initialise the heap, so that the blocks created from now on
    174174   *  are contiguous.
    175175   */
    176   test_heap_default_init(); 
     176  test_heap_default_init();
    177177  puts( "Heap Initialized" );
    178178  p1 = _Heap_Allocate( &TestHeap, 400 );
     
    183183  rtems_test_assert( rsc == HEAP_RESIZE_SUCCESSFUL );
    184184  test_free( p1 );
    185   test_free( p2 ); 
     185  test_free( p2 );
    186186}
    187187
     
    507507  /* Force the page size to a small enough value */
    508508  TestHeap.page_size = page_size;
    509  
     509
    510510  alignment = first_page_begin - sizeof(uintptr_t);
    511511  p1 = test_alloc( alloc_size, alignment, boundary, NULL );
    512  
     512
    513513  first_page_begin = ((uintptr_t) TestHeap.first_block ) + HEAP_BLOCK_HEADER_SIZE;
    514514  alignment = first_page_begin + sizeof(uintptr_t);
    515515  p1 = test_alloc( alloc_size, alignment, boundary, NULL );
    516516
    517   first_page_begin = ((uintptr_t) TestHeap.first_block ) 
     517  first_page_begin = ((uintptr_t) TestHeap.first_block )
    518518          + HEAP_BLOCK_HEADER_SIZE;
    519519  alignment = first_page_begin;
    520520  p1 = test_alloc_simple( alloc_size, alignment, boundary );
    521  
     521
    522522  puts( "\tallocate last block with different boundarys" );
    523523  page_size = TEST_DEFAULT_PAGE_SIZE;
    524524  test_heap_init( page_size );
    525   previous_last_block_begin = ((uintptr_t) TestHeap.last_block ) 
     525  previous_last_block_begin = ((uintptr_t) TestHeap.last_block )
    526526          - TestHeap.min_block_size;
    527527  previous_last_page_begin = previous_last_block_begin
     
    531531  boundary = 0;
    532532  p1 = test_alloc( alloc_size, alignment, boundary, (void *) (previous_last_page_begin + sizeof(uintptr_t)));
    533  
     533
    534534  test_heap_init( page_size );
    535535  boundary = ((uintptr_t) TestHeap.last_block );
     
    562562  boundary = (uintptr_t) TestHeap.last_block;
    563563  p1 = test_alloc( alloc_size, alignment, boundary, NULL );
    564  
     564
    565565  alloc_size = 0;
    566566  p1 = test_alloc( alloc_size, alignment, boundary, NULL );
    567  
     567
    568568  alloc_size = 1;
    569569  alignment = sizeof(uintptr_t);
    570570  boundary = 0;
    571571  p1 = test_alloc_simple( alloc_size, alignment, boundary );
    572    
     572
    573573  puts( "\ttry to create a block, which is not possible because of the alignment and boundary" );
    574574
     
    598598  int alloc_variant,
    599599  uintptr_t alloc_begin,
    600   uintptr_t alloc_size 
     600  uintptr_t alloc_size
    601601)
    602602{
     
    604604  void *p2 = NULL;
    605605  void *p3 = NULL;
    606  
     606
    607607  uintptr_t size_fresh_heap = 0;
    608608  uintptr_t pages_per_default_block = 0;
     
    612612
    613613  test_heap_init( TEST_DEFAULT_PAGE_SIZE );
    614  
     614
    615615  size_fresh_heap = _Heap_Get_size( &TestHeap );
    616616  exp_free_pages = size_fresh_heap / TestHeap.page_size;
     
    619619  p2 = test_create_used_block();
    620620  p3 = test_create_used_block();
    621  
    622   pages_per_default_block = _Heap_Block_size( 
    623     _Heap_Block_of_alloc_area( (uintptr_t) p1, TestHeap.page_size ) 
     621
     622  pages_per_default_block = _Heap_Block_size(
     623    _Heap_Block_of_alloc_area( (uintptr_t) p1, TestHeap.page_size )
    624624  ) / TestHeap.page_size;
    625625
     
    641641
    642642  test_check_alloc_simple( (void *) alloc_begin, alloc_size, 0, 0 );
    643  
     643
    644644  /* check statistics */
    645645  switch( free_variant ) {
     
    647647      exp_free_pages = exp_free_pages - 2 * pages_per_default_block;
    648648      exp_used_blocks = 2;
    649      
     649
    650650      switch( alloc_variant ) {
    651651        case 1:
     
    673673      exp_free_pages = exp_free_pages - 2 * pages_per_default_block;
    674674      exp_used_blocks = 2;
    675      
     675
    676676      switch( alloc_variant ) {
    677677        case 1:
     
    699699      exp_free_pages = exp_free_pages - pages_per_default_block;
    700700      exp_used_blocks = 2;
    701      
     701
    702702      switch( alloc_variant ) {
    703703        case 1:
     
    726726      exp_free_pages = exp_free_pages - 3 * pages_per_default_block;
    727727      exp_used_blocks = 3;
    728      
     728
    729729      switch( alloc_variant ) {
    730730        case 1:
     
    768768  alloc_size = 0;
    769769  test_block_alloc( variant, 0, alloc_begin, alloc_size );
    770  
     770
    771771  puts( "\tallocate block full space");
    772772  alloc_begin = alloc_box_begin;
     
    779779  alloc_size = 0;
    780780  test_block_alloc( variant, 2, alloc_begin, alloc_size );
    781  
     781
    782782  puts( "\tallocate block at the end");
    783783  alloc_begin = alloc_box_end - TEST_DEFAULT_PAGE_SIZE;
     
    854854  uintptr_t old_size = 0;
    855855  uintptr_t new_size = 0;
    856  
     856
    857857  Heap_Resize_status status = _Heap_Resize_block(
    858858    &TestHeap,
     
    912912
    913913  puts( "\tdecrease size");
    914  
     914
    915915  puts( "\t\tdecrease a block with two pages to one page" );
    916916  test_heap_init( TEST_DEFAULT_PAGE_SIZE );
     
    932932  /*
    933933   * Easier to hit extend with a dedicated heap.
    934    * 
     934   *
    935935   */
    936936  _Heap_Initialize( &TestHeap, TestHeapMemory, 512, 0 );
     
    955955  p1 = malloc( 512 );
    956956  s2 = malloc_free_space();
    957   puts( "malloc_free_space - check malloc space drops after malloc" ); 
     957  puts( "malloc_free_space - check malloc space drops after malloc" );
    958958  rtems_test_assert( s1 );
    959959  rtems_test_assert( s2 );
  • testsuites/libtests/malloctest/task1.c

    r44b06ca rb1274bd9  
    1515
    1616#include "system.h"
    17 #include <rtems/malloc.h> 
     17#include <rtems/malloc.h>
    1818#include <string.h>
    1919#include <stdlib.h>
  • testsuites/libtests/monitor02/init.c

    r44b06ca rb1274bd9  
    2424/*
    2525 * HACK: API visibility violation
    26  * rtems_shell_main_monitor should better be declared in rtems/shell.h 
     26 * rtems_shell_main_monitor should better be declared in rtems/shell.h
    2727 */
    2828extern int rtems_shell_main_monitor(int argc, char **argv);
     
    4242  char               *argv[MAX_ARGS];
    4343  char               tmp[256];
    44  
     44
    4545  puts( "\n*** START OF MONITOR02 ***\n");
    46  
     46
    4747  for (i=0; i < MAX_ARGS && Commands[i] ; i++) {
    48     strcpy( tmp, Commands[i] ); 
     48    strcpy( tmp, Commands[i] );
    4949    if (!rtems_shell_make_args(tmp, &argc, argv, MAX_ARGS) ) {
    5050      printf( "===> %s\n", Commands[i] );
  • testsuites/libtests/termios01/init.c

    r44b06ca rb1274bd9  
    423423  /*
    424424   * Test character size
    425    */ 
     425   */
    426426  puts(
    427427    "\n"
     
    445445  /*
    446446   * Test parity
    447    */ 
     447   */
    448448  puts(
    449449    "\n"
     
    469469  /*
    470470   * Test stop bits
    471    */ 
     471   */
    472472  puts(
    473473    "\n"
  • testsuites/libtests/termios01/termios_testdriver.h

    r44b06ca rb1274bd9  
    4545 *  @param[in] arg is the parameters to this call
    4646 *
    47  *  @return This method returns RTEMS_SUCCESSFUL when 
     47 *  @return This method returns RTEMS_SUCCESSFUL when
    4848 *          the device driver is successfully initialized.
    4949 */
     
    5353  void                      *arg
    5454);
    55  
     55
    5656/**
    5757 *  @brief Console Open Entry Point
     
    6464 *  @param[in] arg is the parameters to this call
    6565 *
    66  *  @return This method returns RTEMS_SUCCESSFUL when 
     66 *  @return This method returns RTEMS_SUCCESSFUL when
    6767 *          the device driver is successfully opened.
    6868 */
     
    8383 *  @param[in] arg is the parameters to this call
    8484 *
    85  *  @return This method returns RTEMS_SUCCESSFUL when 
     85 *  @return This method returns RTEMS_SUCCESSFUL when
    8686 *          the device is successfully closed.
    8787 */
     
    102102 *  @param[in] arg is the parameters to this call
    103103 *
    104  *  @return This method returns RTEMS_SUCCESSFUL when 
     104 *  @return This method returns RTEMS_SUCCESSFUL when
    105105 *          the device is successfully read from.
    106106 */
     
    121121 *  @param[in] arg is the parameters to this call
    122122 *
    123  *  @return This method returns RTEMS_SUCCESSFUL when 
     123 *  @return This method returns RTEMS_SUCCESSFUL when
    124124 *          the device is successfully written.
    125125 */
     
    140140 *  @param[in] arg is the parameters to this call
    141141 *
    142  *  @return This method returns RTEMS_SUCCESSFUL when 
     142 *  @return This method returns RTEMS_SUCCESSFUL when
    143143 *          the device driver IO control operation is
    144144 *          successfully performed.
  • testsuites/libtests/tztest/init.c

    r44b06ca rb1274bd9  
    1 /* 
     1/*
    22 *  This routine is the initialization task of test to exercise some
    33 *  timezone functionality.
     
    4646
    4747  puts( "\n\n*** TIMEZONE TEST ***" );
    48  
     48
    4949  build_time( &time, 3, 14, 2007, 15, 9, 26, 5 );
    5050  status = rtems_clock_set( &time );
  • testsuites/psxtests/psx01/init.c

    r44b06ca rb1274bd9  
    7474  rtems_test_assert( status == -1 );
    7575  rtems_test_assert( errno == ESRCH );
    76  
     76
    7777  puts( "Init: sched_rr_get_interval -- EINVAL (invalid interval pointer)" );
    7878  status = sched_rr_get_interval( getpid(), NULL );
    7979  rtems_test_assert( status == -1 );
    8080  rtems_test_assert( errno == EINVAL );
    81  
     81
    8282  /* print the round robin time quantum */
    8383
  • testsuites/psxtests/psx05/init.c

    r44b06ca rb1274bd9  
    596596  priority = sched_get_priority_max( SCHED_FIFO );
    597597  priority = (priority == 254) ? 200 : 13;
    598  
     598
    599599  printf( "Init: pthread_mutex_setprioceiling - new ceiling = %d\n", priority );
    600600  status = pthread_mutex_setprioceiling( &Mutex2_id, priority, &old_ceiling );
     
    670670  if( status )
    671671    printf( "status mutex destroy:%d\n", status );
    672  
     672
    673673  status = pthread_mutexattr_init( &attr );
    674674  if( status )
     
    680680    printf( "status recursive mutex :%d\n", status );
    681681  assert( !status );
    682  
     682
    683683  puts( "*** END OF POSIX TEST 5 ***" );
    684684  rtems_test_exit( 0 );
  • testsuites/psxtests/psx07/init.c

    r44b06ca rb1274bd9  
    126126  status = pthread_attr_init( &attr );
    127127  posix_service_failed( status, "pthread_attr_init");
    128  
     128
    129129  attr.stacksize = rtems_configuration_get_work_space_size() * 10;
    130130  puts( "Init - pthread_create - EAGAIN (stacksize too large)" );
     
    193193  puts( "Init - pthread_create - ENOTSUP (unsupported system contention scope)" );
    194194  status = pthread_create( &Task_id, &attr, Task_1, NULL );
    195   fatal_directive_check_status_only( status, ENOTSUP, 
     195  fatal_directive_check_status_only( status, ENOTSUP,
    196196    "unsupported system contention scope" );
    197197
  • testsuites/psxtests/psx07/task.c

    r44b06ca rb1274bd9  
    4747
    4848  /*
    49    *  Consume time so the cpu budget callout will run. 
     49   *  Consume time so the cpu budget callout will run.
    5050   *
    5151   *  DO NOT BLOCK!!!
     
    5757    } while (start == now);
    5858    start = time(&start);
    59    
     59
    6060    printf( "Time elapsed Task_2: %2d (seconds)\n", i++ );
    6161  }
  • testsuites/psxtests/psx09/init.c

    r44b06ca rb1274bd9  
    175175
    176176    now = time( &now );
    177     if ( now - start > 3 ) 
     177    if ( now - start > 3 )
    178178      break;
    179179
  • testsuites/psxtests/psx14/init.c

    r44b06ca rb1274bd9  
    3232  status = rtems_object_set_name( pthread_self(), "Justin" );
    3333  directive_failed( status, "rtems_object_set_name" );
    34  
     34
    3535  ptr = rtems_object_get_name( pthread_self(), 128, name );
    3636  printf( "rtems_object_get_name returned (%s) for init thread\n", ptr );
     
    4040  status = rtems_object_set_name( pthread_self(), "Jordan" );
    4141  directive_failed( status, "rtems_object_set_name" );
    42  
     42
    4343  ptr = rtems_object_get_name( pthread_self(), 128, name );
    4444  printf( "rtems_object_get_name returned (%s) for init thread\n", ptr );
     
    5353     rtems_object_get_api_name(OBJECTS_POSIX_API) );
    5454
    55   printf("rtems_object_get_api_class_name(POSIX_API, POSIX_KEYS) = %s\n", 
     55  printf("rtems_object_get_api_class_name(POSIX_API, POSIX_KEYS) = %s\n",
    5656    rtems_object_get_api_class_name( OBJECTS_POSIX_API, OBJECTS_POSIX_KEYS)
    5757  );
  • testsuites/psxtests/psxautoinit01/init.c

    r44b06ca rb1274bd9  
    3535  sc = pthread_mutex_lock( &mutex2 );
    3636  fatal_posix_service_status( sc, EINVAL, "mutex lock EINVAL" );
    37  
     37
    3838  puts( "Init - pthread_mutex_unlock - OK" );
    3939  sc = pthread_mutex_unlock( &mutex1 );
     
    5454  sc = pthread_mutex_getprioceiling( &mutex2, &prioceiling );
    5555  fatal_posix_service_status( sc, EINVAL, "mutex getprioceiling EINVAL" );
    56  
     56
    5757  puts( "Init - pthread_mutex_destroy - OK" );
    5858  sc = pthread_mutex_destroy( &mutex1 );
  • testsuites/psxtests/psxautoinit02/init.c

    r44b06ca rb1274bd9  
    3333  sc = pthread_cond_broadcast( &cond2 );
    3434  fatal_posix_service_status( sc, EINVAL, "cond lock EINVAL" );
    35  
     35
    3636  puts( "Init - pthread_cond_destroy - OK" );
    3737  sc = pthread_cond_destroy( &cond1 );
  • testsuites/psxtests/psxbarrier01/test.c

    r44b06ca rb1274bd9  
    8787  /*************** NOT INITIALIZED CHECKS *****************/
    8888  /* cheat visibility */
    89   attr.is_initialized = 0; 
     89  attr.is_initialized = 0;
    9090  puts( "pthread_barrierattr_setpshared( &attr, shared ) -- EINVAL" );
    9191  status = pthread_barrierattr_setpshared( &attr, PTHREAD_PROCESS_SHARED );
  • testsuites/psxtests/psxcancel/init.c

    r44b06ca rb1274bd9  
    3232  int i=0;
    3333  int type,state;
    34  
     34
    3535  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &type);
    3636  pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &state);
  • testsuites/psxtests/psxcleanup/psxcleanup.c

    r44b06ca rb1274bd9  
    156156  pthread_mutexattr_t mutexattr;    /* mutex attributes */
    157157  pthread_condattr_t  condattr;     /* condition attributes */
    158  
     158
    159159  if (pthread_mutexattr_init (&mutexattr) != 0) {
    160160    perror ("Error in mutex attribute init\n");
     
    251251
    252252  /*************** ERROR CASES  ***************/
    253   puts("Call pthread_cleanup_push with NULL handler"); 
     253  puts("Call pthread_cleanup_push with NULL handler");
    254254  pthread_cleanup_push(NULL, NULL);
    255255
    256   puts("Call pthread_cleanup_pop with no push"); 
    257   pthread_cleanup_pop(1);
    258  
     256  puts("Call pthread_cleanup_pop with no push");
     257  pthread_cleanup_pop(1);
     258
    259259  /*************** END OF TEST *****************/
    260260  puts( "*** END OF POSIX CLEANUP TEST ***\n" );
  • testsuites/psxtests/psxcleanup/system.h

    r44b06ca rb1274bd9  
    6262TEST_EXTERN pthread_t        Task_id;
    6363
    64 #undef TEST_EXTERN 
     64#undef TEST_EXTERN
    6565/* end of include file */
  • testsuites/psxtests/psxcleanup01/init.c

    r44b06ca rb1274bd9  
    3232  puts( "Init - pthread_cleanup_pop - do not execute" );
    3333  pthread_cleanup_pop(0);
    34  
     34
    3535  puts( "*** END OF POSIX CLEANUP TEST 01 ***\n" );
    3636  rtems_test_exit(0);
  • testsuites/psxtests/psxclock/init.c

    r44b06ca rb1274bd9  
    1818void check_enosys(int status)
    1919{
    20   if ( (status == -1) && (errno == ENOSYS) ) 
     20  if ( (status == -1) && (errno == ENOSYS) )
    2121    return;
    2222  puts( "ERROR -- did not return ENOSYS as expected" );
     
    107107  remaining = sleep( 3 );
    108108  rtems_test_assert( !remaining );
    109  
     109
    110110  /* print new times to make sure it has changed and we can get the realtime */
    111111  sc = clock_gettime( CLOCK_PROCESS_CPUTIME, &tv );
     
    212212  sc = nanosleep( &delay_request, NULL );
    213213  assert( !sc );
    214  
     214
    215215  /* print the current real time again */
    216216  sc = clock_gettime( CLOCK_REALTIME, &tv );
  • testsuites/psxtests/psxcond01/init.c

    r44b06ca rb1274bd9  
    5555  sc = pthread_create( &Thread, NULL, BlockingThread, NULL );
    5656  fatal_posix_service_status( sc, 0, "Thread create ok" );
    57  
     57
    5858  puts( "Init - sleep to let BlockingThread run" );
    5959  sleep(1);
  • testsuites/psxtests/psxenosys/init.c

    r44b06ca rb1274bd9  
    3939void check_enosys(int status)
    4040{
    41   if ( (status == -1) && (errno == ENOSYS) ) 
     41  if ( (status == -1) && (errno == ENOSYS) )
    4242    return;
    4343  puts( "ERROR -- did not return ENOSYS as expected" );
  • testsuites/psxtests/psxfatal_support/init.c

    r44b06ca rb1274bd9  
    143143      printk( "ERROR==> Fatal Extension is internal set to FALSE expected TRUE\n" );
    144144  }
    145  
     145
    146146  if ( error !=  FATAL_ERROR_EXPECTED_ERROR ) {
    147147    printk( "ERROR==> Fatal Error Expected (");
  • testsuites/psxtests/psxkey01/init.c

    r44b06ca rb1274bd9  
    4444
    4545  Allocate_majority_of_workspace(84);
    46  
     46
    4747  puts("Init: pthread_key_create - ENOMEM (Workspace not available)");
    4848  empty_line();
    4949  status = pthread_key_create( &Key_id[0], Key_destructor );
    5050  fatal_directive_check_status_only( status, ENOMEM, "no workspace available" );
    51    
     51
    5252  puts( "*** END OF POSIX KEY 01 TEST ***" );
    5353  rtems_test_exit( 0 );
  • testsuites/psxtests/psxkey02/init.c

    r44b06ca rb1274bd9  
    2828
    2929  puts( "\n\n*** TEST KEY 02 ***" );
    30  
     30
    3131  puts( "Init - rtems_workspace_get_information - OK" );
    3232  sb = rtems_workspace_get_information( &start );
     
    6464  puts( "Init - pthread_key_create - ENOMEM" );
    6565  while (1) {
    66    
     66
    6767    sb = rtems_workspace_allocate( to_alloc, &alloced );
    6868    assert( sb );
    69    
     69
    7070    sc = pthread_key_create( &key, NULL );
    7171
  • testsuites/psxtests/psxkey03/init.c

    r44b06ca rb1274bd9  
    3232  sc = pthread_setspecific( Key, key_value );
    3333  assert( !sc );
    34  
     34
    3535  puts( "Test_Thread - pthread_exit to run key destructors - OK" );
    3636  return NULL;
     
    4646
    4747  puts( "\n\n*** TEST KEY 03 ***" );
    48  
     48
    4949  /*
    5050   *  Key with NULL destructor
     
    5252  puts( "Init - pthread_key_create with NULL destructor - OK" );
    5353  sc = pthread_key_create( &Key, NULL );
    54   assert( !sc ); 
     54  assert( !sc );
    5555
    5656  puts( "Init - pthread_create - OK" );
     
    7474  puts( "Init - pthread_key_create with non-NULL destructor - OK" );
    7575  sc = pthread_key_create( &Key, destructor );
    76   assert( !sc ); 
     76  assert( !sc );
    7777
    7878  puts( "Init - pthread_create - OK" );
  • testsuites/psxtests/psxmsgq01/init.c

    r44b06ca rb1274bd9  
    105105char *Build_Queue_Name( int i ) {
    106106
    107   static char Queue_Name[PATH_MAX + 2]; 
     107  static char Queue_Name[PATH_MAX + 2];
    108108
    109109  sprintf(Queue_Name,"mq%d", i+1 );
     
    12491249  verify_mq_receive();
    12501250  verify_mq_send();
    1251  
     1251
    12521252  puts( "*** END OF POSIX MESSAGE QUEUE TEST ***" );
    12531253  rtems_test_exit( 0 );
  • testsuites/psxtests/psxmsgq02/init.c

    r44b06ca rb1274bd9  
    4646
    4747  Allocate_majority_of_workspace(NAME_MAX);
    48  
     48
    4949  attr.mq_maxmsg  = MAXMSG;
    5050  attr.mq_msgsize = MSGSIZE;
    5151  puts("Init: mq_open - Workspace not available - ENOMEM");
    5252  mq = mq_open( Get_Longest_Name(), O_CREAT, 0x777, &attr );
    53   fatal_posix_service_status_errno(mq, ENOMEM, "no workspace available"); 
     53  fatal_posix_service_status_errno(mq, ENOMEM, "no workspace available");
    5454
    5555  puts( "*** END OF POSIX MESSAGE QUEUE 02 TEST ***" );
  • testsuites/psxtests/psxmsgq03/init.c

    r44b06ca rb1274bd9  
    9999    rtems_test_exit( 0 );
    100100  }
    101  
     101
    102102  puts( "Init - mq_send from ISR returned correct status" );
    103103
  • testsuites/psxtests/psxmsgq04/init.c

    r44b06ca rb1274bd9  
    9393    sb = rtems_workspace_allocate( to_alloc, &alloced );
    9494    assert( sb );
    95    
     95
    9696    second_Queue = mq_open(name,O_CREAT | O_RDWR, 0x777, &attr );
    9797
  • testsuites/psxtests/psxmutexattr01/init.c

    r44b06ca rb1274bd9  
    8585    sc = pthread_mutexattr_settype( &attr, TypesToCheck[i].type );
    8686    rtems_test_assert( sc == TypesToCheck[i].status );
    87    
     87
    8888    type = -2;
    8989
  • testsuites/psxtests/psxrdwrv/test.c

    r44b06ca rb1274bd9  
    5454 * Fill the test buffer.
    5555 *
    56  * Returns: TRUE if buffer filled 
     56 * Returns: TRUE if buffer filled
    5757 *          FALSE if buffer failed to fill
    5858 *
     
    8989  int           rc;
    9090
    91  
     91
    9292  /*
    9393   * Setup the iovec
     
    217217  if ( (rc != -1) || (errno != EINVAL) ) {
    218218    printf( "writev error 2: %d=%s\n", errno, strerror(errno) );
    219     fclose(fp); 
     219    fclose(fp);
    220220    return FALSE;
    221221  }
     
    226226  if ( (rc != -1) || (errno != EINVAL) ) {
    227227    printf( "readv error 2: %d=%s\n", errno, strerror(errno) );
    228     fclose(fp); 
     228    fclose(fp);
    229229    return FALSE;
    230230  }
     
    235235  if ( (rc != -1) || (errno != EINVAL) ) {
    236236    printf( "writev error 3: %d=%s\n", errno, strerror(errno) );
    237     fclose(fp); 
     237    fclose(fp);
    238238    return FALSE;
    239239  }
     
    244244  if ( (rc != -1) || (errno != EINVAL) ) {
    245245    printf( "readv error 3: %d=%s\n", errno, strerror(errno) );
    246     fclose(fp); 
     246    fclose(fp);
    247247    return FALSE;
    248248  }
     
    253253  if ( (rc != -1) || (errno != EINVAL) ) {
    254254    printf( "writev error 4: %d=%s\n", errno, strerror(errno) );
    255     fclose(fp); 
     255    fclose(fp);
    256256    return FALSE;
    257257  }
     
    262262  if ( (rc != -1) || (errno != EINVAL) ) {
    263263    printf( "readv error 4: %d=%s\n", errno, strerror(errno) );
    264     fclose(fp); 
     264    fclose(fp);
    265265    return FALSE;
    266266  }
     
    275275  if ( (rc != -1) || (errno != EINVAL) ) {
    276276    printf( "writev error 5: %d=%s\n", errno, strerror(errno) );
    277     fclose(fp); 
     277    fclose(fp);
    278278    return FALSE;
    279279  }
     
    288288  if ( (rc != -1) || (errno != EINVAL) ) {
    289289    printf( "readv error 5: %d=%s\n", errno, strerror(errno) );
    290     fclose(fp); 
     290    fclose(fp);
    291291    return FALSE;
    292292  }
     
    301301  if ( (rc != -1) || (errno != EINVAL) ) {
    302302    printf( "writev error 6: %d=%s\n", errno, strerror(errno) );
    303     fclose(fp); 
     303    fclose(fp);
    304304    return FALSE;
    305305  }
     
    314314  if ( (rc != -1) || (errno != EINVAL) ) {
    315315    printf( "readv error 6: %d=%s\n", errno, strerror(errno) );
    316     fclose(fp); 
     316    fclose(fp);
    317317    return FALSE;
    318318  }
     
    329329  if ( (rc != -1) || (errno != EINVAL) ) {
    330330    printf( "writev error 7: %d=%s\n", errno, strerror(errno) );
    331     fclose(fp); 
     331    fclose(fp);
    332332    return FALSE;
    333333  }
     
    342342  if ( (rc != -1) || (errno != EINVAL) ) {
    343343    printf( "readv error 7: %d=%s\n", errno, strerror(errno) );
    344     fclose(fp); 
     344    fclose(fp);
    345345    return FALSE;
    346346  }
     
    355355  if ( (rc != 0) ) {
    356356    printf( "writev error 8: %d=%s\n", errno, strerror(errno) );
    357     fclose(fp); 
     357    fclose(fp);
    358358    return FALSE;
    359359  }
     
    368368  if ( (rc != 0) ) {
    369369    printf( "readv error 8: %d=%s\n", errno, strerror(errno) );
    370     fclose(fp); 
     370    fclose(fp);
    371371    return FALSE;
    372372  }
  • testsuites/psxtests/psxrwlock01/test.c

    r44b06ca rb1274bd9  
    111111  /*************** NOT INITIALIZED CHECKS *****************/
    112112  /* cheat visibility */
    113   attr.is_initialized = 0; 
     113  attr.is_initialized = 0;
    114114  puts( "pthread_rwlockattr_setpshared( &attr, shared ) -- EINVAL" );
    115115  status = pthread_rwlockattr_setpshared( &attr, PTHREAD_PROCESS_SHARED );
     
    339339
    340340  sleep(2);
    341  
     341
    342342  /*************** CREATE THREADS AND LET THEM OBTAIN WRITE LOCK *************/
    343343  puts( "pthread_rwlock_trywrlock(RWLock) -- OK" );
     
    368368  status = clock_gettime( CLOCK_REALTIME, &abstime );
    369369  assert( !status );
    370  
     370
    371371  abstime.tv_sec += 1;
    372372  puts( "pthread_rwlock_timedwrlock( &RWLock, &abstime) -- OK" );
     
    422422  status = pthread_rwlock_unlock( &rwlock );
    423423  assert( status == 0 );
    424  
     424
    425425  puts( "pthread_rwlock_unlock ( &rwlock ) -- OK" );
    426426  status = pthread_rwlock_unlock( &rwlock );
  • testsuites/psxtests/psxsem01/init.c

    r44b06ca rb1274bd9  
    178178
    179179  puts( "Init: sem_open - sem1 SUCCESSFUL" );
    180   n_sem1 = sem_open( "sem1",O_CREAT, 0777, 1 ); 
     180  n_sem1 = sem_open( "sem1",O_CREAT, 0777, 1 );
    181181  assert( n_sem1 != SEM_FAILED );
    182182
  • testsuites/psxtests/psxsignal01/init.c

    r44b06ca rb1274bd9  
    187187    1,
    188188    Signal_duringISR_TSR,
    189     NULL 
     189    NULL
    190190  );
    191191  sleep(5);
     
    202202    10,
    203203    Signal_duringISR_TSR,
    204     NULL 
     204    NULL
    205205  );
    206206  do {
     
    216216
    217217  Signal_occurred = 0;
    218  
     218
    219219  puts("*** Validate unexpected program termination ***");
    220220  puts( "*** END OF POSIX TEST SIGNAL ***" );
  • testsuites/psxtests/psxsignal02/init.c

    r44b06ca rb1274bd9  
    7171  "Sleeps"
    7272};
    73  
     73
    7474
    7575typedef struct {
     
    9696
    9797  Install_Signal_Handler( test->name );
    98  
     98
    9999  printf( "%s - %s\n", test->name, Actions[test->action] );
    100100  switch ( test->action ) {
  • testsuites/psxtests/psxsignal03/init.c

    r44b06ca rb1274bd9  
    110110  sc = pthread_sigmask( SIG_UNBLOCK, &mask, NULL );
    111111  assert( !sc );
    112  
     112
    113113  /* build wait mask */
    114114  sc = sigemptyset( &wait_mask );
     
    128128  printf( "%s - siginfo.si_code=%d\n", name, info.si_code );
    129129  /* FIXME: Instead of casting to (uintptr_t) and using PRIxPTR, we
    130    * likely should use %p. However, this would render this test's 
    131    * behavior non-deterministic, because %p's behavior is 
     130   * likely should use %p. However, this would render this test's
     131   * behavior non-deterministic, because %p's behavior is
    132132   * "implementation defined" */
    133133  printf( "%s - siginfo.si_value=0x%08" PRIxPTR "\n", name, (uintptr_t) info.si_value.sival_ptr );
  • testsuites/psxtests/psxspin02/test.c

    r44b06ca rb1274bd9  
    8282
    8383  sleep(1);
    84  
     84
    8585  puts( "pthread_spin_unlock( &Spinlock ) -- OK" );
    8686  status = pthread_spin_unlock( &Spinlock );
  • testsuites/psxtests/psxstack01/init.c

    r44b06ca rb1274bd9  
    5959  Stack_High = Stack_Low + PTHREAD_MINIMUM_STACK_SIZE;
    6060
    61   puts( "Init - Initialize thread attribute for user provided stack" ); 
     61  puts( "Init - Initialize thread attribute for user provided stack" );
    6262  sc = pthread_attr_init( &attr );
    6363  assert( !sc );
  • testsuites/psxtests/psxsysconf/init.c

    r44b06ca rb1274bd9  
    3030  fatal_posix_service_status_errno( sc, EINVAL, "bad conf name" );
    3131
    32 #if UNUSED 
    33 /* FIXME: This test doesn't make sense. 
     32#if UNUSED
     33/* FIXME: This test doesn't make sense.
    3434 * On targets with sizeof(int) < sizeof(long), compilation will fail,
    3535 * On targets with sizeof(int) == sizeof(long) the call is valid.
  • testsuites/psxtests/psxtime/test.c

    r44b06ca rb1274bd9  
    106106  rtems_time_of_day  tod;
    107107  rtems_interval     ticks;
    108  
     108
    109109  the_tod = &Dates[0];
    110110
     
    152152
    153153  /*
    154    * spin until over 1/2 of the way to the 
     154   * spin until over 1/2 of the way to the
    155155   */
    156156  ticks = rtems_clock_get_ticks_per_second();
  • testsuites/psxtests/psxtimer01/psxtimer.c

    r44b06ca rb1274bd9  
    8282  }
    8383}
    84  
     84
    8585/* task A  */
    8686void * task_a (void *arg)
     
    126126    timergetdata.it_interval.tv_sec, timergetdata.it_interval.tv_nsec
    127127  );
    128    
     128
    129129
    130130   /* periodic activity */
     
    189189     perror ("Error in timer setting\n");
    190190     rtems_test_exit(0);
    191    }     
     191   }
    192192
    193193   /* periodic activity */
     
    197197       rtems_test_exit(0);
    198198     }
    199  
     199
    200200     if (timer_gettime(timer_id, &timerdata) == -1) {
    201201       perror ("Error in timer_gettime\n");
     
    209209      */
    210210     if ( !_Timespec_Equal_to( &timerdata.it_value, &my_period) ){
    211        printf( "NOT EQUAL %d:%d != %d:%d\n", 
     211       printf( "NOT EQUAL %d:%d != %d:%d\n",
    212212          timerdata.it_value.tv_sec,
    213213          timerdata.it_value.tv_nsec,
     
    221221     pthread_mutex_lock (&data.mutex);
    222222     clock = time(NULL);
    223      printf("Executing task B with count = %2i %s", 
    224        params->count, ctime(&clock) 
     223     printf("Executing task B with count = %2i %s",
     224       params->count, ctime(&clock)
    225225     );
    226226     data.updated = TRUE;
     
    293293     }
    294294     clock = time(NULL);
    295      printf("Executing task C with count = %2i %s", 
    296        params->count, ctime(&clock) 
     295     printf("Executing task C with count = %2i %s",
     296       params->count, ctime(&clock)
    297297     );
    298298
     
    302302       overruns = timer_getoverrun( timer_id );
    303303       printf( "task C: timer_getoverrun - overruns=%d\n", overruns );
    304      
     304
    305305       if (timer_gettime(timer_id, &timergetdata) == -1) {
    306306         perror ("Error in timer setting\n");
  • testsuites/psxtests/psxtimer02/psxtimer.c

    r44b06ca rb1274bd9  
    4242  timer_t           timer1;
    4343  struct itimerspec itimer;
    44  
     44
    4545  /*
    4646   *  If these are not filled in correctly, we don't pass its error checking.
  • testsuites/psxtests/psxusleep/init.c

    r44b06ca rb1274bd9  
    4747  remaining = usleep( 3 * 1000000 );
    4848  rtems_test_assert( !remaining );
    49  
     49
    5050  sc = clock_gettime( CLOCK_REALTIME, &tv );
    5151  rtems_test_assert( !sc );
  • testsuites/samples/capture/init.c

    r44b06ca rb1274bd9  
    5656  rtems_monitor_init (0);
    5757  rtems_capture_cli_init (0);
    58  
     58
    5959  setup_tasks_to_watch ();
    6060
  • testsuites/samples/capture/test1.c

    r44b06ca rb1274bd9  
    3232capture_wait (uint32_t period)
    3333{
    34   rtems_task_wake_after (RTEMS_MICROSECONDS_TO_TICKS (period * 1000)); 
     34  rtems_task_wake_after (RTEMS_MICROSECONDS_TO_TICKS (period * 1000));
    3535}
    3636
     
    5353  sc = rtems_semaphore_obtain (mutex, RTEMS_WAIT, 0);
    5454
    55   if (sc != RTEMS_SUCCESSFUL) 
     55  if (sc != RTEMS_SUCCESSFUL)
    5656    fprintf (stdout, "error: CT1a: mutex obtain: %s\n",
    5757             rtems_status_text (sc));
     
    6161  sc = rtems_semaphore_release (mutex);
    6262
    63   if (sc != RTEMS_SUCCESSFUL) 
     63  if (sc != RTEMS_SUCCESSFUL)
    6464    fprintf (stdout, "error: CT1a: mutex release: %s\n",
    6565             rtems_status_text (sc));
    6666
    6767  capture_CT1a_deleted = 1;
    68  
     68
    6969  rtems_task_delete (RTEMS_SELF);
    7070}
     
    7777  while (!capture_CT1c_deleted)
    7878    i++;
    79  
     79
    8080  capture_CT1b_deleted = 1;
    8181
     
    9191  sc = rtems_semaphore_obtain (mutex, RTEMS_WAIT, 0);
    9292
    93   if (sc != RTEMS_SUCCESSFUL) 
     93  if (sc != RTEMS_SUCCESSFUL)
    9494    fprintf (stdout, "error: CT1c: mutex obtain: %s\n",
    9595             rtems_status_text (sc));
     
    9999  sc = rtems_semaphore_release (mutex);
    100100
    101   if (sc != RTEMS_SUCCESSFUL) 
     101  if (sc != RTEMS_SUCCESSFUL)
    102102    fprintf (stdout, "error: CT1c: mutex release: %s\n",
    103103             rtems_status_text (sc));
    104104
    105105  capture_CT1c_deleted = 1;
    106  
     106
    107107  rtems_task_delete (RTEMS_SELF);
    108108}
     
    123123  capture_CT1b_deleted = 0;
    124124  capture_CT1c_deleted = 0;
    125  
     125
    126126  name = rtems_build_name('C', 'T', 'm', '1');
    127127
    128128  sc = rtems_semaphore_create (name, 1,
    129                                RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | 
     129                               RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
    130130                               RTEMS_INHERIT_PRIORITY,
    131131                               0, &mutex);
    132  
    133   if (sc != RTEMS_SUCCESSFUL) 
     132
     133  if (sc != RTEMS_SUCCESSFUL)
    134134  {
    135135    fprintf (stdout, "error: Test 1: cannot mutex: %s\n",
     
    139139
    140140  name = rtems_build_name('C', 'T', '1', 'a');
    141  
     141
    142142  sc = rtems_task_create (name, 102, 2 * 1024,
    143143                          RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
    144144                          RTEMS_PREEMPT | RTEMS_TIMESLICE | RTEMS_NO_ASR,
    145145                          &id[0]);
    146  
    147   if (sc != RTEMS_SUCCESSFUL) 
     146
     147  if (sc != RTEMS_SUCCESSFUL)
    148148  {
    149149    fprintf (stdout, "error: Test 1: cannot create CT1a: %s\n",
     
    167167
    168168  name = rtems_build_name('C', 'T', '1', 'b');
    169  
     169
    170170  sc = rtems_task_create (name, 101, 2 * 1024,
    171171                          RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
    172172                          RTEMS_PREEMPT | RTEMS_TIMESLICE | RTEMS_NO_ASR,
    173173                          &id[1]);
    174  
    175   if (sc != RTEMS_SUCCESSFUL) 
     174
     175  if (sc != RTEMS_SUCCESSFUL)
    176176  {
    177177    fprintf (stdout, "error: Test 1: cannot create CT1b: %s\n",
     
    197197
    198198  name = rtems_build_name('C', 'T', '1', 'c');
    199  
     199
    200200  sc = rtems_task_create (name, 100, 2 * 1024,
    201201                          RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
    202202                          RTEMS_PREEMPT | RTEMS_TIMESLICE | RTEMS_NO_ASR,
    203203                          &id[2]);
    204  
    205   if (sc != RTEMS_SUCCESSFUL) 
     204
     205  if (sc != RTEMS_SUCCESSFUL)
    206206  {
    207207    fprintf (stdout, "error: Test 1: cannot create CT1c: %s\n",
     
    242242    rtems_task_delete (id[0]);
    243243  }
    244  
     244
    245245  sc = rtems_semaphore_delete (mutex);
    246246  if (sc != RTEMS_SUCCESSFUL)
  • testsuites/samples/fileio/init.c

    r44b06ca rb1274bd9  
    161161
    162162  writeScript(
    163     "/scripts/js", 
     163    "/scripts/js",
    164164    "#! joel\n"
    165165    "\n"
     
    171171
    172172  writeScript(
    173     "/scripts/j1", 
     173    "/scripts/j1",
    174174    "#! joel -s 20480 -t JESS\n"
    175175    "stackuse\n"
     
    177177
    178178  rtems_shell_write_file(
    179     "/scripts/j2", 
     179    "/scripts/j2",
    180180    "echo j2 TEST FILE\n"
    181181    "echo j2   SHOULD BE non-executable AND\n"
     
    702702
    703703  status = rtems_task_create(
    704     Task_name, 1, RTEMS_MINIMUM_STACK_SIZE * 2, 
     704    Task_name, 1, RTEMS_MINIMUM_STACK_SIZE * 2,
    705705    RTEMS_DEFAULT_MODES ,
    706706    RTEMS_FLOATING_POINT | RTEMS_DEFAULT_ATTRIBUTES, &Task_id
     
    739739  "userecho"                 /* alias */
    740740};
    741  
     741
    742742
    743743#define CONFIGURE_SHELL_USER_COMMANDS &Shell_USERCMD_Command
  • testsuites/samples/minimum/init.c

    r44b06ca rb1274bd9  
    1 /*  Minimum Size Application Initialization 
     1/*  Minimum Size Application Initialization
    22 *
    33 *  COPYRIGHT (c) 1989-2008.
     
    2121  /* Real application would call idle loop functionality */
    2222
    23   /* but in this case, just return and fall into a fatal error */ 
     23  /* but in this case, just return and fall into a fatal error */
    2424}
    2525
  • testsuites/samples/nsecs/init.c

    r44b06ca rb1274bd9  
    1 /* 
     1/*
    22 *  Nanoseconds accuracy timestamp test
    33 */
     
    3030  ctime_r(&t, b);
    3131  b[ strlen(b) - 1] = '\0';
    32   return b; 
     32  return b;
    3333}
    3434
     
    118118    int j, max = (index * 10000);
    119119    rtems_clock_get_uptime( &start );
    120       for (j=0 ; j<max ; j++ ) 
     120      for (j=0 ; j<max ; j++ )
    121121        dummy_function_empty_body_to_force_call();
    122122    rtems_clock_get_uptime( &stop );
  • testsuites/sptests/sp01/task1.c

    r44b06ca rb1274bd9  
    3535  /*
    3636   * Use TOD_MILLISECONDS_TO_TICKS not RTEMS_MILLISECONDS_TO_TICKS to
    37    * test C implementation in SuperCore -- not macro version used 
     37   * test C implementation in SuperCore -- not macro version used
    3838   * everywhere else.
    3939   */
  • testsuites/sptests/sp07/tcreate.c

    r44b06ca rb1274bd9  
    3232    name = Task_name[ task_number( created_task->Object.id ) ];
    3333/*
    34  * FIXME: There should be a public function to 
     34 * FIXME: There should be a public function to
    3535 * convert numeric rtems_names into char arrays
    3636 * c.f. rtems_name_to_characters() in rtems/rtems/support.inl
  • testsuites/sptests/sp07/tdelete.c

    r44b06ca rb1274bd9  
    4242    name = Task_name[ task_number( deleted_task->Object.id ) ];
    4343/*
    44  * FIXME: There should be a public function to 
     44 * FIXME: There should be a public function to
    4545 * convert numeric rtems_names into char arrays
    4646 * c.f. rtems_name_to_characters() in rtems/rtems/support.inl
  • testsuites/sptests/sp07/trestart.c

    r44b06ca rb1274bd9  
    3232    name = Task_name[ task_number( restarted_task->Object.id ) ];
    3333/*
    34  * FIXME: There should be a public function to 
     34 * FIXME: There should be a public function to
    3535 * convert numeric rtems_names into char arrays
    3636 * c.f. rtems_name_to_characters() in rtems/rtems/support.inl
  • testsuites/sptests/sp07/tstart.c

    r44b06ca rb1274bd9  
    3232    name = Task_name[ task_number( started_task->Object.id ) ];
    3333/*
    34  * FIXME: There should be a public function to 
     34 * FIXME: There should be a public function to
    3535 * convert numeric rtems_names into char arrays
    3636 * c.f. rtems_name_to_characters() in rtems/rtems/support.inl
  • testsuites/sptests/sp09/screen01.c

    r44b06ca rb1274bd9  
    116116
    117117  puts( "TA1 - rtems_object_get_classic_name - bad ID" );
    118   status = rtems_object_get_classic_name( 
     118  status = rtems_object_get_classic_name(
    119119    rtems_build_id( OBJECTS_ITRON_API, OBJECTS_ITRON_TASKS, 1, 1 ),
    120120    &task_name
  • testsuites/sptests/sp09/screen03.c

    r44b06ca rb1274bd9  
    7272    skipUnsatisfied = true;
    7373  #endif
    74  
     74
    7575  if ( skipUnsatisfied ) {
    7676    puts(
  • testsuites/sptests/sp09/screen04.c

    r44b06ca rb1274bd9  
    101101  directive_failed( status, "clock_get_tod_timeval OK" );
    102102
    103   seconds = tv.tv_sec; 
     103  seconds = tv.tv_sec;
    104104  printf( "TA1 - current time - %s\n", ctime(&seconds) );
    105105
  • testsuites/sptests/sp09/screen05.c

    r44b06ca rb1274bd9  
    122122    Semaphore_name[ 1 ],
    123123    1,
    124     RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY_CEILING | 
     124    RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY_CEILING |
    125125      RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY,
    126126    10,
  • testsuites/sptests/sp09/screen14.c

    r44b06ca rb1274bd9  
    121121  /* bad id */
    122122  build_time( &time, 12, 31, 1994, 9, 0, 0, 0 );
    123   status = rtems_timer_fire_when( 
     123  status = rtems_timer_fire_when(
    124124    rtems_build_id( 1, 1, 1, 256 ),
    125125    &time,
     
    160160  );
    161161  puts( "TA1 - rtems_timer_fire_when - RTEMS_INVALID_ADDRESS" );
    162  
    163   /* invalid time -- before RTEMS epoch */ 
     162
     163  /* invalid time -- before RTEMS epoch */
    164164  build_time( &time, 2, 5, 1987, 8, 30, 45, 0 );
    165165  status = rtems_timer_fire_when( Timer_id[ 1 ], &time, Delayed_routine, NULL );
  • testsuites/sptests/sp10/init.c

    r44b06ca rb1274bd9  
    2626  is_set = rtems_debug_is_enabled( 0x1 );
    2727  rtems_test_assert(is_set == false);
    28  
     28
    2929  puts( "Init - rtems_debug_enable - set 0x1" );
    3030  rtems_debug_enable(0x1);
     
    3434  is_set = rtems_debug_is_enabled( 0x1 );
    3535  rtems_test_assert(is_set == true);
    36  
     36
    3737  puts( "Init - rtems_debug_disable - clear 0x1" );
    3838  rtems_debug_disable(0x1);
     
    4242  is_set = rtems_debug_is_enabled( 0x1 );
    4343  rtems_test_assert(is_set == false);
    44  
     44
    4545  puts( "*** END OF TEST 10 ***" );
    4646  rtems_test_exit(0);
  • testsuites/sptests/sp12/pritask.c

    r44b06ca rb1274bd9  
    5353
    5454  /* special case of setting priority while holding a resource */
    55   { 
     55  {
    5656    rtems_task_priority priority;
    5757    rtems_task_priority old_priority;
  • testsuites/sptests/sp16/task5.c

    r44b06ca rb1274bd9  
    4747  /*
    4848   * Use TOD_MICROSECONDS_TO_TICKS not RTEMS_MICROSECONDS_TO_TICKS to
    49    * test C implementation in SuperCore -- not macro version used 
     49   * test C implementation in SuperCore -- not macro version used
    5050   * everywhere else.
    5151   */
  • testsuites/sptests/sp18/init.c

    r44b06ca rb1274bd9  
    2424
    2525  puts( "\n\n*** TEST 18 ***" );
    26  
     26
    2727  puts( "Init - rtems_workspace_get_information - OK" );
    2828  sb = rtems_workspace_get_information( &start );
     
    4242  puts( "Init - rtems_task_create - Unsatisfied on Extensions" );
    4343  while (1) {
    44    
     44
    4545    sc = rtems_task_create(
    4646      rtems_build_name( 'T', 'E', 'S', 'T' ),
  • testsuites/sptests/sp27/init.c

    r44b06ca rb1274bd9  
    112112{
    113113  puts( "\n\n*** TEST " TEST_NAME " ***" );
    114   puts( "Testing " TEST_SEMAPHORE_TYPE " semaphore flush" ); 
     114  puts( "Testing " TEST_SEMAPHORE_TYPE " semaphore flush" );
    115115  doTest();
    116116  puts( "*** END OF TEST " TEST_NAME " ***" );
  • testsuites/sptests/sp28/init.c

    r44b06ca rb1274bd9  
    219219  sc = rtems_task_variable_get( RTEMS_SELF, (void **)&taskvar1, &value );
    220220  directive_failed( sc, "get multiple #2" );
    221  
     221
    222222  /*
    223223   *  Delete task variables in various spots on the chain
     
    318318
    319319  rtems_task_wake_after( 100 );
    320  
     320
    321321  if ( test_dtor_ran != 1 ) {
    322322    printf( "Test dtor ran %" PRIu32 " times not 1 times as expected\n", test_dtor_ran );
     
    365365
    366366  rtems_task_wake_after( 100 );
    367  
     367
    368368  if ( test_dtor_ran != 2 ) {
    369369    printf( "Test dtor ran %" PRIu32 " times not 2 times as expected\n", test_dtor_ran );
  • testsuites/sptests/sp33/init.c

    r44b06ca rb1274bd9  
    194194  }
    195195
    196   puts( "Delay to let Waiters block" ); 
     196  puts( "Delay to let Waiters block" );
    197197  status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
    198198  directive_failed(status, "rtems_task_wake_after");
     
    208208  }
    209209
    210   puts( "Delay to let Waiters print a message" ); 
     210  puts( "Delay to let Waiters print a message" );
    211211  status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
    212212  directive_failed(status, "rtems_task_wake_after");
     
    231231  }
    232232
    233   puts( "Delay to let Waiters block" ); 
     233  puts( "Delay to let Waiters block" );
    234234  status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
    235235  directive_failed(status, "rtems_task_wake_after");
     
    239239  directive_failed(status, "rtems_barrier_delete");
    240240
    241   puts( "Delay to let Waiters print a message" ); 
     241  puts( "Delay to let Waiters print a message" );
    242242  status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
    243243  directive_failed(status, "rtems_task_wake_after");
     
    269269  }
    270270
    271   puts( "Delay to let task wait on barrier" ); 
     271  puts( "Delay to let task wait on barrier" );
    272272  status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
    273273  directive_failed(status, "rtems_task_wake_after");
  • testsuites/sptests/sp34/changepri.c

    r44b06ca rb1274bd9  
    4646    unsigned char c[4];
    4747  } TempName;
    48  
     48
    4949  #if defined(TEST_ON_RTEMS_45)
    5050    TempName.u = *(uint32_t *)_Thread_Executing->Object.name;
     
    9696rtems_task Init(rtems_task_argument ignored)
    9797{
    98   rtems_status_code   status;   
     98  rtems_status_code   status;
    9999  int                 i;
    100  
     100
    101101  puts( "\n\n*** TEST 34 ***" );
    102102
     
    105105    rtems_build_name ('S', 'E', 'M', '1'),           /* name */
    106106    0,                                               /* initial count = 0 */
    107     RTEMS_LOCAL                   | 
    108     RTEMS_COUNTING_SEMAPHORE      | 
     107    RTEMS_LOCAL                   |
     108    RTEMS_COUNTING_SEMAPHORE      |
    109109    RTEMS_PRIORITY,
    110110    0,
    111111    &Semaphore);                                    /* *id */
    112112  directive_failed( status, "rtems_semaphore_create" );
    113  
     113
    114114  /* Create and start all tasks in the test */
    115115
     
    123123      &Blockers[i]);                                     /* Assigned ID */
    124124    directive_failed( status, "rtems_task_create (BLKn)" );
    125  
     125
    126126    printf( "Blockers[%d] Id = 0x%08" PRIxrtems_id "\n", i, Blockers[i] );
    127127    status = rtems_task_start(
  • testsuites/sptests/sp35/priinv.c

    r44b06ca rb1274bd9  
    104104#define NofMediumTask_C 3
    105105
    106 /* RTEMS identifiers */                                               
     106/* RTEMS identifiers */
    107107rtems_id  TaMedium[NofMediumTask_C]; /* Medium-prio tasks accessing */
    108108                                     /*    the common local HW */
     
    192192#endif
    193193  printf("LocalHwSim_Exec begins...\n");
    194  
     194
    195195  while(1) {
    196196    if (StartHw) {
     
    239239{
    240240  rtems_status_code     Sts;
    241    
     241
    242242  rtems_task_priority   EnterPrio;   /* Statistics log */
    243243  rtems_task_priority   AccessPrio;  /*      :         */
     
    292292      puts( "*** END OF TEST 35 ***" );
    293293      exit(0);
    294     } 
     294    }
    295295  #endif
    296296  return;
     
    300300{
    301301  rtems_status_code     Sts;
    302    
     302
    303303  rtems_task_priority   EnterPrio;   /* Statistics log */
    304304  rtems_task_priority   AccessPrio;  /*      :         */
     
    357357rtems_task Init(rtems_task_argument ignored)
    358358{
    359   rtems_status_code status;   
     359  rtems_status_code status;
    360360#if defined(TEST_USE_ISR)
    361   rtems_isr_entry   DummyIsr; 
     361  rtems_isr_entry   DummyIsr;
    362362#endif
    363363  int i;
    364  
     364
    365365  puts( "\n\n*** TEST 35 ***" );
    366366
     
    369369    rtems_build_name ('S', 'Y', 'N', 'C'),           /* name */
    370370    0,                                               /* initial count = 0 */
    371     RTEMS_LOCAL                   | 
    372     RTEMS_SIMPLE_BINARY_SEMAPHORE | 
    373     RTEMS_NO_INHERIT_PRIORITY     | 
    374     RTEMS_NO_PRIORITY_CEILING     | 
     371    RTEMS_LOCAL                   |
     372    RTEMS_SIMPLE_BINARY_SEMAPHORE |
     373    RTEMS_NO_INHERIT_PRIORITY     |
     374    RTEMS_NO_PRIORITY_CEILING     |
    375375    RTEMS_FIFO,
    376376    0,
    377377    &LocalHwSync_S);                                 /* *id */
    378378  directive_failed( status, "rtems_semaphore_create (SYNC)" );
    379  
     379
    380380  printf( "Sync Mutex Id = 0x%08" PRIxrtems_id "\n", LocalHwSync_S );
    381  
     381
    382382  /* Create resource semaphore for exclusive access to the local HW */
    383383  status = rtems_semaphore_create(
     
    407407
    408408  printf( "Remote Mutex Id = 0x%08" PRIxrtems_id "\n", RemoteHwAccess_R );
    409  
     409
    410410#if defined(TEST_USE_ISR)
    411411  /* Install ISR for HW/SW synchronization, use ta 0x85 which is synchronous */
     
    414414#endif
    415415
    416  
     416
    417417  printf("Ending Init-task\n");
    418418  /* Create and start all tasks in the test */
  • testsuites/sptests/sp36/strict_order_mut.c

    r44b06ca rb1274bd9  
    7777  Mutex_name[2] = rtems_build_name( 'S','Y','N','C');
    7878
    79                                  
     79
    8080  Task_name[0] = rtems_build_name( 'T','0',' ',' ');
    8181  status = rtems_task_create(
     
    9090  printf("Create T0,priority is 4\n");
    9191
    92  
     92
    9393
    9494  status = rtems_task_start( Task_id[0],Task0, 0);
     
    103103{
    104104  rtems_status_code status;
    105  
    106  
     105
     106
    107107  status = rtems_semaphore_obtain(
    108108                                  Mutex_id[0],
     
    112112  directive_failed( status,"rtems_semaphore_obtain of S0\n");
    113113  printf("The current priority of T0 is %d\n",Get_current_pri());
    114  
     114
    115115  status = rtems_semaphore_obtain(
    116116                                  Mutex_id[1],
     
    132132  directive_failed( status,"rtems_semaphore_release of S1\n");
    133133  printf("The current priority of T0 is %d\n",Get_current_pri());
    134  
     134
    135135
    136136  Task_name[1] = rtems_build_name( 'T','1',' ',' ');
     
    145145  directive_failed( status , "rtems_task_create of T1\n");
    146146  printf("Create S1,priority is 1\n");
    147  
     147
    148148
    149149  status = rtems_task_start( Task_id[1],Task1, 0);
     
    155155  printf("T0 - rtems_semaphore_release - S0\n");
    156156  directive_failed( status, "rtems_semaphore_release of S0\n");
    157  
    158 }
    159  
     157
     158}
     159
    160160
    161161rtems_task Task1(rtems_task_argument ignored)
     
    195195             "holder_id=%d,holder's current priority=%d\n",node,
    196196             ((CORE_mutex_order_list *)node)->priority_before,p_mutex->holder_id,p_mutex->holder->current_priority);
    197       node = node->next;   
     197      node = node->next;
    198198    }
    199199  }
     
    201201    printf("the Chain is empty\n");
    202202}
    203 */ 
     203*/
  • testsuites/sptests/sp37/init.c

    r44b06ca rb1274bd9  
    6363  puts( "interrupt enable (use inline)" );
    6464  rtems_interrupt_enable( level );
    65  
     65
    6666  puts( "interrupt level attribute (use inline)" );
    6767  level_attribute = rtems_interrupt_level_attribute( level );
     
    169169    directive_failed( status, "timer_fire_after failed" );
    170170    return;
    171   } 
     171  }
    172172
    173173  blocked_task_status = 2;
     
    289289  puts( "interrupt enable (use body)" );
    290290  rtems_interrupt_enable( level );
    291  
     291
    292292  puts( "interrupt level attribute (use body)" );
    293293  level_attribute = rtems_interrupt_level_attribute( level );
     
    308308  status = rtems_task_wake_after( 100 );
    309309  directive_failed( status, "wake_after failed" );
    310  
     310
    311311  check_isr_worked( "inline", isr_in_progress_body );
    312312
  • testsuites/sptests/sp38/init.c

    r44b06ca rb1274bd9  
    9191  }
    9292
    93   puts( "Signal sent from ISR has been processed" ); 
     93  puts( "Signal sent from ISR has been processed" );
    9494  puts( "*** END OF TEST 38 ***" );
    9595  rtems_test_exit( 0 );
  • testsuites/sptests/sp39/init.c

    r44b06ca rb1274bd9  
    133133    "Event sent from ISR hitting synchronization point has %soccurred\n",
    134134    (( case_hit == TRUE ) ? "" : "NOT ")
    135   ); 
     135  );
    136136
    137137  /*
     
    168168      "point has %soccurred\n",
    169169    (( case_hit == TRUE ) ? "" : "NOT ")
    170   ); 
     170  );
    171171
    172172  puts( "*** END OF TEST 39 ***" );
  • testsuites/sptests/sp42/init.c

    r44b06ca rb1274bd9  
    6666
    6767  status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &tid );
    68   directive_failed( status, "rtems_task_ident" ); 
     68  directive_failed( status, "rtems_task_ident" );
    6969
    7070  task_index = task_number( tid ) - 1;
    7171
    7272  status = rtems_semaphore_obtain( Semaphore, RTEMS_DEFAULT_OPTIONS, 0 );
    73   directive_failed( status, "rtems_semaphore_obtain" ); 
     73  directive_failed( status, "rtems_semaphore_obtain" );
    7474
    7575  put_name( Task_name[ task_index ], FALSE );
     
    9494    &Semaphore
    9595  );
    96   directive_failed( status, "rtems_semaphore_create" ); 
     96  directive_failed( status, "rtems_semaphore_create" );
    9797
    9898  for (i=0 ; i< MAX_TASKS ; i++ ) {
    99    
     99
    100100    Task_name[ i ] = rtems_build_name(
    101101       'T',
     
    113113      &Task_id[ i ]
    114114    );
    115     directive_failed( status, "rtems_task_create" ); 
     115    directive_failed( status, "rtems_task_create" );
    116116
    117117    status = rtems_task_start(
    118118      Task_id[ i ], Locker_task, (rtems_task_argument)i );
    119     directive_failed( status, "rtems_task_start" ); 
     119    directive_failed( status, "rtems_task_start" );
    120120
    121121    status = rtems_task_wake_after( 10 );
    122     directive_failed( status, "rtems_task_wake_after" ); 
     122    directive_failed( status, "rtems_task_wake_after" );
    123123  }
    124124
     
    126126    if ( extract == FALSE ) {
    127127      status = rtems_semaphore_release( Semaphore );
    128       directive_failed( status, "rtems_semaphore_release" ); 
     128      directive_failed( status, "rtems_semaphore_release" );
    129129
    130130      status = rtems_task_wake_after( 100 );
    131       directive_failed( status, "rtems_task_wake_after" ); 
     131      directive_failed( status, "rtems_task_wake_after" );
    132132    } else {
    133133      status = rtems_task_delete( Task_id[ i ]  );
    134       directive_failed( status, "rtems_task_delete" ); 
     134      directive_failed( status, "rtems_task_delete" );
    135135    }
    136136  }
    137  
     137
    138138  /* one extra release for the initial state */
    139139  status = rtems_semaphore_release( Semaphore );
    140   directive_failed( status, "rtems_semaphore_release" ); 
     140  directive_failed( status, "rtems_semaphore_release" );
    141141
    142142  /* now delete the semaphore since no one is waiting and it is unlocked */
    143143  status = rtems_semaphore_delete( Semaphore );
    144   directive_failed( status, "rtems_semaphore_delete" ); 
     144  directive_failed( status, "rtems_semaphore_delete" );
    145145}
    146146
  • testsuites/sptests/sp43/init.c

    r44b06ca rb1274bd9  
    176176  puts( " - rtems_build_name for TEMP" );
    177177
    178  
     178
    179179  /*
    180180   * rtems_object_get_name - cases
     
    273273  tmpId = rtems_build_id( OBJECTS_CLASSIC_API, OBJECTS_RTEMS_TASKS, 1, 1 ),
    274274  assert( tmpId == main_task );
    275  
     275
    276276  puts( "rtems_object_id_get_api - OK" );
    277277  part = rtems_object_id_get_api( main_task );
     
    333333   */
    334334  rtems_test_pause();
    335  
     335
    336336  printf( "rtems_object_get_api_name(0) = %s\n", rtems_object_get_api_name(0) );
    337337  printf( "rtems_object_get_api_name(255) = %s\n",
     
    345345     rtems_object_get_api_name(OBJECTS_ITRON_API) );
    346346
    347   printf( "rtems_object_get_api_class_name(0, RTEMS_TASKS) = %s\n", 
     347  printf( "rtems_object_get_api_class_name(0, RTEMS_TASKS) = %s\n",
    348348    rtems_object_get_api_class_name( 0, OBJECTS_RTEMS_TASKS ) );
    349   printf( "rtems_object_get_api_class_name(CLASSIC_API, 0) = %s\n", 
     349  printf( "rtems_object_get_api_class_name(CLASSIC_API, 0) = %s\n",
    350350    rtems_object_get_api_class_name( OBJECTS_CLASSIC_API, 0 ) );
    351   printf("rtems_object_get_api_class_name(INTERNAL_API, MUTEXES) = %s\n", 
     351  printf("rtems_object_get_api_class_name(INTERNAL_API, MUTEXES) = %s\n",
    352352    rtems_object_get_api_class_name(
    353353       OBJECTS_INTERNAL_API, OBJECTS_INTERNAL_MUTEXES));
    354   printf("rtems_object_get_api_class_name(CLASSIC_API, RTEMS_BARRIERS) = %s\n", 
     354  printf("rtems_object_get_api_class_name(CLASSIC_API, RTEMS_BARRIERS) = %s\n",
    355355    rtems_object_get_api_class_name(
    356356       OBJECTS_CLASSIC_API, OBJECTS_RTEMS_BARRIERS));
     
    361361
    362362  rtems_test_pause();
    363  
     363
    364364  puts( "rtems_object_get_class_information - INVALID_ADDRESS" );
    365365  sc = rtems_object_get_class_information(
  • testsuites/sptests/sp44/init.c

    r44b06ca rb1274bd9  
    8080      printf("Task #%" PRIdrtems_task_argument "'s turn. Now setting turn to %" PRIdrtems_task_argument "\n", me, 1 - me);
    8181      turn = 1 - me;
    82  
     82
    8383      if ( ++iterations == 10 ) {
    8484        puts( "*** END OF SP44 TEST ***" );
  • testsuites/sptests/sp46/init.c

    r44b06ca rb1274bd9  
    4343    directive_failed(status, "rate_monotonic_period");
    4444    partial_loop = 0;
    45  
     45
    4646    start = rtems_clock_get_ticks_since_boot();
    4747    end   = start + 5;
  • testsuites/sptests/sp47/init.c

    r44b06ca rb1274bd9  
    4141    rtems_build_name('t', 's', 't', '0'),
    4242    100,
    43     RTEMS_MINIMUM_STACK_SIZE, 
     43    RTEMS_MINIMUM_STACK_SIZE,
    4444    RTEMS_NO_ASR,
    4545    RTEMS_DEFAULT_ATTRIBUTES,
  • testsuites/sptests/sp48/init.c

    r44b06ca rb1274bd9  
    3434      1,
    3535      RTEMS_DEFAULT_ATTRIBUTES,
    36       0, 
     36      0,
    3737      &Semaphores[i]
    3838    );
  • testsuites/sptests/sp50/init.c

    r44b06ca rb1274bd9  
    4141
    4242  sc = rtems_timer_initiate_server(
    43     1, 
     43    1,
    4444    RTEMS_MINIMUM_STACK_SIZE,
    4545    RTEMS_DEFAULT_ATTRIBUTES
     
    6464      sc = rtems_clock_get_uptime( &uptime );
    6565      directive_failed( sc, "rtems_clock_get_uptime" );
    66  
     66
    6767      printf( "Timer fired at %" PRItime_t "\n", uptime.tv_sec );
    6868    }
  • testsuites/sptests/sp57/init.c

    r44b06ca rb1274bd9  
    4949  status = rtems_task_start( task_id, Delay_task, 0 );
    5050  directive_failed( status, "rtems_task_start" );
    51  
     51
    5252  puts( "Init - rtems_task_wake_after - let delay task block - OK" );
    5353  status = rtems_task_wake_after( RTEMS_MILLISECONDS_TO_TICKS(1000) );
     
    5757  status = rtems_task_restart( task_id, 0 );
    5858  directive_failed( status, "rtems_task_restart" );
    59  
     59
    6060  puts( "*** END OF TEST 57 ***" );
    6161  rtems_test_exit(0);
  • testsuites/sptests/sp58/init.c

    r44b06ca rb1274bd9  
    3636  rtems_test_assert( ival_percentage == 0 );
    3737  rtems_test_assert( fval_percentage == 0 );
    38  
     38
    3939}
    4040
  • testsuites/sptests/sp59/init.c

    r44b06ca rb1274bd9  
    6868  status = rtems_task_start( task_id, Blocking_task, 0 );
    6969  directive_failed( status, "rtems_task_start" );
    70  
     70
    7171  puts( "Init - rtems_region_create - OK" );
    7272  status = rtems_region_create(
  • testsuites/sptests/sp60/init.c

    r44b06ca rb1274bd9  
    3939  sc = rtems_rate_monotonic_period(period1, RTEMS_MILLISECONDS_TO_TICKS(200) );
    4040  directive_failed( sc, "rtems_rate_monotonic_period" );
    41  
     41
    4242  puts( "Init - rtems_rate_monotonic_period - long period initiated" );
    4343  sc = rtems_rate_monotonic_period(period2, RTEMS_MILLISECONDS_TO_TICKS(1000) );
    4444  directive_failed( sc, "rtems_rate_monotonic_period" );
    45  
     45
    4646  puts( "Init - rtems_rate_monotonic_period - long period block" );
    4747  sc = rtems_rate_monotonic_period(period2, RTEMS_MILLISECONDS_TO_TICKS(1000) );
    4848  directive_failed( sc, "rtems_rate_monotonic_period" );
    49  
     49
    5050  puts( "Init - rtems_rate_monotonic_period - verify long period expired" );
    5151  sc = rtems_rate_monotonic_period(period1, RTEMS_PERIOD_STATUS );
    5252  fatal_directive_status(sc, RTEMS_TIMEOUT, "rtems_task_period status");
    53  
     53
    5454  puts( "*** END OF TEST 60 ***" );
    5555  rtems_test_exit(0);
  • testsuites/sptests/sp61/init.c

    r44b06ca rb1274bd9  
    2828  puts( "Init - restore System State and shutdown for real" );
    2929  _System_state_Set( SYSTEM_STATE_UP );
    30  
     30
    3131  puts( "*** END OF TEST 61 ***" );
    3232  rtems_test_exit(0);
  • testsuites/sptests/sp62/init.c

    r44b06ca rb1274bd9  
    3939  puts( "Blocker - Got memory after resize" );
    4040  case_hit = true;
    41  
     41
    4242  (void) rtems_task_delete( RTEMS_SELF );
    4343}
     
    5454
    5555  puts( "\n\n*** TEST 62 ***" );
    56  
     56
    5757  puts( "Init - rtems_task_create Blocker - OK" );
    5858  sc = rtems_task_create(
  • testsuites/sptests/sp63/init.c

    r44b06ca rb1274bd9  
    117117{
    118118  puts( "\n\n*** TEST 63 ***" );
    119  
     119
    120120  test_case_one();
    121121
  • testsuites/sptests/sp65/init.c

    r44b06ca rb1274bd9  
    3030  int                  status;
    3131  rtems_id             Mutex_id, Task_id;
    32  
     32
    3333  puts( "\n\n*** TEST " TEST_NAME " ***" );
    3434
     
    3737   *  attribute.
    3838   */
    39    
     39
    4040  puts( "Creating semaphore" );
    4141  status = rtems_semaphore_create(
     
    5151  status = rtems_semaphore_obtain( Mutex_id, RTEMS_DEFAULT_OPTIONS, 0 );
    5252  directive_failed( status, "rtems_semaphore_obtain" );
    53  
     53
    5454  puts( "Calling rtems_task_create" );
    55   status = rtems_task_create( rtems_build_name( 'T', 'A', 'S', '1' ), 
     55  status = rtems_task_create( rtems_build_name( 'T', 'A', 'S', '1' ),
    5656    TASK_PRIORITY,
    5757    RTEMS_MINIMUM_STACK_SIZE,
     
    6161  );
    6262  directive_failed( status, "rtems_task_create" );
    63  
     63
    6464  puts( "Calling rtems_task_start" );
    6565  status = rtems_task_start( Task_id, Task_1, (rtems_task_argument)&Mutex_id );
    6666  directive_failed( status, "rtems_task_start" );
    67  
     67
    6868  sleep(1);
    69  
     69
    7070  puts( "Calling semaphore release" );
    7171  status = rtems_semaphore_release( Mutex_id );
    7272  directive_failed( status, "rtems_semaphore_release" );
    73  
     73
    7474
    7575  puts( "*** END OF TEST 65 ***" );
  • testsuites/sptests/sp66/init.c

    r44b06ca rb1274bd9  
    2222  int                  status, ceiling, old_ceiling;
    2323  rtems_id             Mutex_id, Task_id;
    24  
     24
    2525  puts( "\n\n*** TEST 66 ***" );
    2626
     
    2929   *  attribute.
    3030   */
    31    
     31
    3232  puts( "Creating semaphore" );
    3333  status = rtems_semaphore_create(
     
    4343  status = rtems_semaphore_obtain( Mutex_id, RTEMS_DEFAULT_OPTIONS, 0 );
    4444  directive_failed( status, "rtems_semaphore_obtain" );
    45  
     45
    4646  puts( "Calling rtems_task_create" );
    47   status = rtems_task_create( rtems_build_name( 'T', 'A', 'S', '1' ), 
     47  status = rtems_task_create( rtems_build_name( 'T', 'A', 'S', '1' ),
    4848    2,
    4949    RTEMS_MINIMUM_STACK_SIZE,
     
    5353  );
    5454  directive_failed( status, "rtems_task_create" );
    55  
     55
    5656  puts( "Calling rtems_task_start" );
    5757  status = rtems_task_start( Task_id, Task_1, (rtems_task_argument)&Mutex_id );
    5858  directive_failed( status, "rtems_task_start" );
    59  
     59
    6060  sleep(1);
    61  
     61
    6262  puts( "Calling semaphore release" );
    6363  status = rtems_semaphore_release( Mutex_id );
    6464  directive_failed( status, "rtems_semaphore_release" );
    65  
     65
    6666  puts( "*** END OF TEST 66 ***" );
    6767
  • testsuites/sptests/spchain/init.c

    r44b06ca rb1274bd9  
    2222)
    2323{
    24   rtems_chain_control  chain1; 
     24  rtems_chain_control  chain1;
    2525  rtems_chain_node    *p;
    26   test_node            node1, node2; 
     26  test_node            node1, node2;
    2727  int                  id;
    2828
  • testsuites/sptests/spclockget/init.c

    r44b06ca rb1274bd9  
    3131  directive_failed( sc, "rtems_clock_get -- TOD" );
    3232  print_time( "Init - rtems_clock_get - ", &time, "\n" );
    33  
     33
    3434  sc = rtems_clock_get( RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH, &interval );
    3535  directive_failed( sc, "rtems_clock_get -- Seconds Since Epoch" );
    3636  printf( "Init - rtems_clock_get - Seconds Since Epoch = %" PRIdrtems_interval "\n", interval );
    37  
     37
    3838  sc = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &interval );
    3939  directive_failed( sc, "rtems_clock_get -- Ticks Since Boot" );
    4040  printf( "Init - rtems_clock_get - Ticks Since Boot = %" PRIdrtems_interval "\n", interval );
    41  
     41
    4242  sc = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_PER_SECOND, &interval );
    4343  directive_failed( sc, "rtems_clock_get -- Ticks Per Second" );
    4444  printf( "Init - rtems_clock_get - Ticks Per Second = %" PRIdrtems_interval "\n", interval );
    45  
     45
    4646  sc = rtems_clock_get( RTEMS_CLOCK_GET_TIME_VALUE, &timev );
    4747  directive_failed( sc, "rtems_clock_get -- Time Value" );
    4848  printf( "Init - rtems_clock_get - Time Value = %" PRItime_t "\n", timev.tv_sec );
    49  
     49
    5050  puts( "*** END OF TEST LEGACY RTEMS_CLOCK_GET ***" );
    5151  rtems_test_exit(0);
  • testsuites/sptests/spfatal03/testcase.h

    r44b06ca rb1274bd9  
    2020#define FATAL_ERROR_EXPECTED_SOURCE      INTERNAL_ERROR_CORE
    2121#define FATAL_ERROR_EXPECTED_IS_INTERNAL FALSE
    22 #define FATAL_ERROR_EXPECTED_ERROR       INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE 
     22#define FATAL_ERROR_EXPECTED_ERROR       INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE
    2323
    2424void force_error(void)
     
    4646  _Thread_Enable_dispatch();
    4747  puts("ERROR -- Obtain semaphore should not have returned");
    48  
     48
    4949  /* we will not run this far */
    5050}
  • testsuites/sptests/spfatal05/testcase.h

    r44b06ca rb1274bd9  
    6161    &id
    6262  );
    63   directive_failed( status, "rtems_task_create" ); 
     63  directive_failed( status, "rtems_task_create" );
    6464
    6565  status = rtems_task_start( id, EmptyTask, 0 );
     
    6868  status = rtems_task_wake_after( 10 );
    6969  directive_failed( status, "rtems_task_wake_after" );
    70  
     70
    7171  /* we will not run this far */
    7272}
  • testsuites/sptests/spfatal07/testcase.h

    r44b06ca rb1274bd9  
    4141void force_error()
    4242{
    43   #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) 
     43  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
    4444    Configuration.interrupt_stack_size = (STACK_MINIMUM_SIZE-1);
    4545    rtems_initialize_data_structures();
     
    5151    rtems_test_exit(0);
    5252  #endif
    53    
     53
    5454  /* we will not run this far */
    5555}
  • testsuites/sptests/spfatal08/testcase.h

    r44b06ca rb1274bd9  
    3535#define FATAL_ERROR_DESCRIPTION          "Core workspace too small"
    3636#define FATAL_ERROR_EXPECTED_SOURCE      INTERNAL_ERROR_CORE
    37 #define FATAL_ERROR_EXPECTED_IS_INTERNAL TRUE 
     37#define FATAL_ERROR_EXPECTED_IS_INTERNAL TRUE
    3838#define FATAL_ERROR_EXPECTED_ERROR       INTERNAL_ERROR_WORKSPACE_ALLOCATION
    3939
  • testsuites/sptests/spfatal09/testcase.h

    r44b06ca rb1274bd9  
    3434#define FATAL_ERROR_TEST_NAME            "9"
    3535#define FATAL_ERROR_DESCRIPTION          "Core invalid workspace address"
    36 #define FATAL_ERROR_EXPECTED_SOURCE      INTERNAL_ERROR_CORE 
     36#define FATAL_ERROR_EXPECTED_SOURCE      INTERNAL_ERROR_CORE
    3737#define FATAL_ERROR_EXPECTED_IS_INTERNAL TRUE
    3838#define FATAL_ERROR_EXPECTED_ERROR       INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
  • testsuites/sptests/spfatal10/testcase.h

    r44b06ca rb1274bd9  
    2020{
    2121  __assert_func( __FILE__, __LINE__, "Init", "forced" );
    22    
     22
    2323  /* we will not run this far */
    2424}
  • testsuites/sptests/spfatal11/testcase.h

    r44b06ca rb1274bd9  
    2020{
    2121  __assert_func( __FILE__, __LINE__, NULL, "forced" );
    22    
     22
    2323  /* we will not run this far */
    2424}
  • testsuites/sptests/spfatal_support/init.c

    r44b06ca rb1274bd9  
    142142      printk( "ERROR==> Fatal Extension is internal set to FALSE expected TRUE\n" );
    143143  }
    144  
     144
    145145  if ( error !=  FATAL_ERROR_EXPECTED_ERROR ) {
    146146    printk( "ERROR==> Fatal Error Expected (");
  • testsuites/sptests/spintrcritical01/init.c

    r44b06ca rb1274bd9  
    5959
    6060  sem = (Semaphore_Control *)_Objects_Get(
    61     &_Semaphore_Information, Semaphore, &location ); 
     61    &_Semaphore_Information, Semaphore, &location );
    6262  if ( location != OBJECTS_LOCAL ) {
    6363    puts( "Bad object lookup" );
     
    123123    puts( "Init - Case hit" );
    124124    puts( "*** END OF TEST INTERRUPT CRITICAL SECTION " TEST_NAME " ***" );
    125   } else 
     125  } else
    126126    puts( "Init - Case not hit - ran too long" );
    127127
  • testsuites/sptests/spintrcritical06/init.c

    r44b06ca rb1274bd9  
    4747
    4848  sem = (Semaphore_Control *)_Objects_Get(
    49     &_Semaphore_Information, Semaphore, &location ); 
     49    &_Semaphore_Information, Semaphore, &location );
    5050  if ( location != OBJECTS_LOCAL ) {
    5151    puts( "Bad object lookup" );
  • testsuites/sptests/spintrcritical08/init.c

    r44b06ca rb1274bd9  
    2424
    2525  period = (Rate_monotonic_Control *)_Objects_Get(
    26     &_Rate_monotonic_Information, Period, &location ); 
     26    &_Rate_monotonic_Information, Period, &location );
    2727  if ( location != OBJECTS_LOCAL ) {
    2828    puts( "Bad object lookup" );
     
    8080    puts( "Init - It appears the case has been hit" );
    8181    puts( "*** END OF TEST INTERRUPT CRITICAL SECTION 08 ***" );
    82   } else 
     82  } else
    8383    puts( "Init - Case not hit - ran too long" );
    8484  rtems_test_exit(0);
  • testsuites/sptests/spintrcritical09/init.c

    r44b06ca rb1274bd9  
    2424
    2525  sem = (Semaphore_Control *)_Objects_Get(
    26     &_Semaphore_Information, Semaphore, &location ); 
     26    &_Semaphore_Information, Semaphore, &location );
    2727  if ( location != OBJECTS_LOCAL ) {
    2828    puts( "Bad object lookup" );
     
    8080    puts( "Init - It appears the case has been hit" );
    8181    puts( "*** END OF TEST INTERRUPT CRITICAL SECTION 09 ***" );
    82   } else 
     82  } else
    8383    puts( "Init - Case not hit - ran too long" );
    8484
  • testsuites/sptests/spintrcritical16/init.c

    r44b06ca rb1274bd9  
    2727
    2828  sem = (Semaphore_Control *)_Objects_Get(
    29     &_Semaphore_Information, Semaphore, &location ); 
     29    &_Semaphore_Information, Semaphore, &location );
    3030  if ( location != OBJECTS_LOCAL ) {
    3131    puts( "Bad object lookup" );
     
    9292    puts( "Init - Case hit" );
    9393    puts( "*** END OF TEST INTERRUPT CRITICAL SECTION " TEST_NAME " ***" );
    94   } else 
     94  } else
    9595    puts( "Init - Case not hit - ran too long" );
    9696
  • testsuites/sptests/spintrcritical_support/intrcritical.c

    r44b06ca rb1274bd9  
    4242  if ( max > 0 ) {
    4343    Maximum_current = max - 1;
    44    
     44
    4545    return false;
    4646  } else {
  • testsuites/sptests/spnotepad01/init.c

    r44b06ca rb1274bd9  
    1 /* 
     1/*
    22 *  COPYRIGHT (c) 1989-2009.
    33 *  On-Line Applications Research Corporation (OAR).
  • testsuites/sptests/spobjgetnext/init.c

    r44b06ca rb1274bd9  
    1717
    1818/* prototypes */
    19 int scan_objects( 
     19int scan_objects(
    2020  Objects_Information *information,
    2121  Objects_Id           start
     
    2424#define MAX_SCAN 10
    2525
    26 int scan_objects( 
     26int scan_objects(
    2727  Objects_Information *information,
    2828  Objects_Id           start
     
    4545    );
    4646    if ( !o[i] )
    47       break; 
     47      break;
    4848    if ( location == OBJECTS_ERROR )
    4949      break;
     
    5555  }
    5656  return i;
    57 } 
     57}
    5858
    5959rtems_task Init(
  • testsuites/sptests/spprintk/init.c

    r44b06ca rb1274bd9  
    4545
    4646  /* string formats */
    47   printk( "%%s of Mary Had a Little Lamb -- (%s)\n", 
     47  printk( "%%s of Mary Had a Little Lamb -- (%s)\n",
    4848          "Mary Had a Little Lamb" );
    4949  printk( "%%s of NULL -- (%s)\n", NULL );
  • testsuites/sptests/spstkalloc/init.c

    r44b06ca rb1274bd9  
    3838)
    3939{
    40   rtems_status_code rc; 
     40  rtems_status_code rc;
    4141  rtems_id          taskId;
    4242  rtems_id          taskId1;
  • testsuites/sptests/spwkspace/init.c

    r44b06ca rb1274bd9  
    3434
    3535  puts( "rtems_workspace_allocate - null pointer" );
    36   retbool = rtems_workspace_allocate( 42, NULL ); 
     36  retbool = rtems_workspace_allocate( 42, NULL );
    3737  assert( retbool == false );
    3838
    3939  puts( "rtems_workspace_allocate - 0 bytes" );
    40   retbool = rtems_workspace_allocate( 0, &p1 ); 
     40  retbool = rtems_workspace_allocate( 0, &p1 );
    4141  assert( retbool == false );
    4242
    4343  puts( "rtems_workspace_allocate - too many bytes" );
    44   retbool = rtems_workspace_allocate( info.Free.largest * 2, &p1 ); 
     44  retbool = rtems_workspace_allocate( info.Free.largest * 2, &p1 );
    4545  assert( retbool == false );
    4646
    4747  puts( "rtems_workspace_allocate - 42 bytes" );
    48   retbool = rtems_workspace_allocate( 42, &p1 ); 
     48  retbool = rtems_workspace_allocate( 42, &p1 );
    4949  assert( retbool == true );
    5050  assert( p1 != NULL );
    5151
    5252  puts( "rtems_workspace_free - NULL" );
    53   retbool = rtems_workspace_free( NULL ); 
     53  retbool = rtems_workspace_free( NULL );
    5454  assert( retbool == false );
    5555
    5656  puts( "rtems_workspace_free - previous pointer to 42 bytes" );
    57   retbool = rtems_workspace_free( p1 ); 
     57  retbool = rtems_workspace_free( p1 );
    5858  assert( retbool == true );
    5959
  • testsuites/support/include/tmacros.h

    r44b06ca rb1274bd9  
    260260 * certain system types on different targets.
    261261 */
    262  
     262
    263263/* HACK: Presume time_t to be a "long" */
    264264/* HACK: There is no portable way to print time_t's */
  • testsuites/support/src/test_support.c

    r44b06ca rb1274bd9  
    2323static char  Longest_Name[PATH_MAX + 1];
    2424
    25 const char *Get_Too_Long_Name(void) 
     25const char *Get_Too_Long_Name(void)
    2626{
    2727  int i;
     
    4444
    4545void Allocate_majority_of_workspace( int smallest )
    46 { 
     46{
    4747  bool                   result;
    4848  Heap_Information_block info;
     
    5555
    5656  do {
    57     result = rtems_workspace_allocate( 
    58       info.Free.largest-16, 
    59       &temp 
     57    result = rtems_workspace_allocate(
     58      info.Free.largest-16,
     59      &temp
    6060    );
    6161    if ((!result) || (!temp))
  • testsuites/tmtests/tm08/task1.c

    r44b06ca rb1274bd9  
    106106    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
    107107      (void) rtems_task_set_priority(
    108         Test_task_id, 
     108        Test_task_id,
    109109        RTEMS_MAXIMUM_PRIORITY - 2u,
    110110        &old_priority
    111111      );
    112      
     112
    113113  end_time = benchmark_timer_read();
    114114
Note: See TracChangeset for help on using the changeset viewer.