test/class/opal

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
main
   1 /*
   2  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
   3  *                         University Research and Technology
   4  *                         Corporation.  All rights reserved.
   5  * Copyright (c) 2004-2005 The University of Tennessee and The University
   6  *                         of Tennessee Research Foundation.  All rights
   7  *                         reserved.
   8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
   9  *                         University of Stuttgart.  All rights reserved.
  10  * Copyright (c) 2004-2005 The Regents of the University of California.
  11  *                         All rights reserved.
  12  * Copyright (c) 2008-2014 Cisco Systems, Inc.  All rights reserved.
  13  * $COPYRIGHT$
  14  *
  15  * Additional copyrights may follow
  16  *
  17  * $HEADER$
  18  */
  19 
  20 #include "opal_config.h"
  21 #include <assert.h>
  22 
  23 #include "support.h"
  24 #include "opal/class/opal_list.h"
  25 #include "opal/runtime/opal.h"
  26 #include "opal/constants.h"
  27 
  28 /*
  29  * Data type used for testing
  30  */
  31 typedef struct test_data {
  32     /* link list data structure */
  33     opal_list_item_t ll_element;
  34     /* test data */
  35     size_t data;
  36 } test_data_t;
  37 
  38 OBJ_CLASS_INSTANCE(test_data_t,
  39                    opal_list_item_t,
  40                    NULL, NULL);
  41 
  42 int main(int argc, char **argv)
  43 {
  44     /* local variables */
  45     opal_list_t list, x;
  46     size_t indx,i,list_size, tmp_size_1, tmp_size_2,size_elements;
  47     int error_cnt, rc;
  48     test_data_t *elements, *ele;
  49     opal_list_item_t *item;
  50 
  51     rc = opal_init_util(&argc, &argv);
  52     test_verify_int(OPAL_SUCCESS, rc);
  53     if (OPAL_SUCCESS != rc) {
  54         test_finalize();
  55         exit(1);
  56     }
  57 
  58     test_init("opal_list_t");
  59 
  60     /* initialize list */
  61     OBJ_CONSTRUCT(&list, opal_list_t);
  62     OBJ_CONSTRUCT(&x, opal_list_t);
  63 
  64     /* check length of list */
  65     list_size=opal_list_get_size(&list);
  66     if( 0 == list_size ) {
  67         test_success();
  68     } else {
  69         test_failure(" opal_list_get_size");
  70     }
  71 
  72     /* check for empty */
  73     if (opal_list_is_empty(&list)) {
  74         test_success();
  75     } else {
  76         test_failure(" opal_list_is_empty(empty list)");
  77     }
  78 
  79     /* create test elements */
  80     size_elements=4;
  81     elements=(test_data_t *)malloc(sizeof(test_data_t)*size_elements);
  82     assert(elements);
  83     for(i=0 ; i < size_elements ; i++) {
  84         OBJ_CONSTRUCT(elements + i, test_data_t);
  85         (elements+i)->data=i;
  86     }
  87 
  88     /* populate list */
  89     for(i=0 ; i < size_elements ; i++) {
  90         opal_list_append(&list,(opal_list_item_t *)(elements+i));
  91     }
  92     list_size=opal_list_get_size(&list);
  93     if( list_size == size_elements ) {
  94         test_success();
  95     } else {
  96         test_failure(" populating list");
  97     }
  98 
  99     /* checking for empty on non-empty list */
 100     if (!opal_list_is_empty(&list)) {
 101         test_success();
 102     } else {
 103         test_failure(" opal_list_is_empty(non-empty list)");
 104     }
 105 
 106     /* check that list is ordered as expected */
 107     i=0;
 108     error_cnt=0;
 109     for(ele = (test_data_t *) opal_list_get_first(&list);
 110             ele != (test_data_t *) opal_list_get_end(&list);
 111             ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
 112         if( ele->data != i )
 113             error_cnt++;
 114         i++;
 115     }
 116     if( 0 == error_cnt ) {
 117         test_success();
 118     } else {
 119         test_failure(" error in list order ");
 120     }
 121 
 122     /* check opal_list_get_first */
 123     ele = (test_data_t *)NULL;
 124     ele = (test_data_t *) opal_list_get_first(&list);
 125     assert(ele);
 126     if( 0 == ele->data ) {
 127         test_success();
 128     } else {
 129         test_failure(" error in opal_list_get_first");
 130     }
 131     i=0;
 132     for(ele = (test_data_t *) opal_list_get_first(&list);
 133             ele != (test_data_t *) opal_list_get_end(&list);
 134             ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
 135         i++;
 136     }
 137     if( size_elements == i ) {
 138         test_success();
 139     } else {
 140         test_failure(" error in opal_list_get_first - list size changed ");
 141     }
 142 
 143     /* check opal_list_get_last */
 144     ele = (test_data_t *)NULL;
 145     ele = (test_data_t *) opal_list_get_last(&list);
 146     assert(ele);
 147     if( (size_elements-1) == ele->data ) {
 148         test_success();
 149     } else {
 150         test_failure(" error in opal_list_get_last");
 151     }
 152     i=0;
 153     for(ele = (test_data_t *) opal_list_get_first(&list);
 154             ele != (test_data_t *) opal_list_get_end(&list);
 155             ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
 156         i++;
 157     }
 158     if( size_elements == i ) {
 159         test_success();
 160     } else {
 161         test_failure(" error in opal_list_get_first - list size changed ");
 162     }
 163 
 164     /* check opal_list_remove_first */
 165     ele = (test_data_t *)NULL;
 166     ele = (test_data_t *) opal_list_remove_first(&list);
 167     assert(ele);
 168     if( 0 == ele->data ) {
 169         test_success();
 170     } else {
 171         test_failure(" error in opal_list_remove_first");
 172     }
 173     i=0;
 174     for(ele = (test_data_t *) opal_list_get_first(&list);
 175             ele != (test_data_t *) opal_list_get_end(&list);
 176             ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
 177         i++;
 178     }
 179     if( (size_elements-1) == i ) {
 180         test_success();
 181     } else {
 182         test_failure(" error in opal_list_remove_first - list size changed ");
 183     }
 184 
 185     /* test opal_list_prepend */
 186     opal_list_prepend(&list,(opal_list_item_t *)elements);
 187     ele = (test_data_t *)NULL;
 188     ele = (test_data_t *) opal_list_get_first(&list);
 189     assert(ele);
 190     if( 0 == ele->data ) {
 191         test_success();
 192     } else {
 193         test_failure(" error in opal_list_prepend");
 194     }
 195     i=0;
 196     for(ele = (test_data_t *) opal_list_get_first(&list);
 197             ele != (test_data_t *) opal_list_get_end(&list);
 198             ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
 199         i++;
 200     }
 201     if( size_elements == i ) {
 202         test_success();
 203     } else {
 204         test_failure(" error in opal_list_prepend - list size changed ");
 205     }
 206 
 207     /* check opal_list_remove_last */
 208     ele = (test_data_t *)NULL;
 209     ele = (test_data_t *) opal_list_remove_last(&list);
 210     assert(ele);
 211     if( (size_elements-1) == ele->data ) {
 212         test_success();
 213     } else {
 214         test_failure(" error in opal_list_remove_last");
 215     }
 216     i=0;
 217     for(ele = (test_data_t *) opal_list_get_first(&list);
 218             ele != (test_data_t *) opal_list_get_end(&list);
 219             ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
 220         i++;
 221     }
 222     if( (size_elements-1) == i ) {
 223         test_success();
 224     } else {
 225         test_failure(" error in opal_list_remove_last - list size changed ");
 226     }
 227 
 228     /* test opal_list_append */
 229     opal_list_append(&list,(opal_list_item_t *)(elements+size_elements-1));
 230     ele = (test_data_t *)NULL;
 231     ele = (test_data_t *) opal_list_get_last(&list);
 232     assert(ele);
 233     if( (size_elements-1) == ele->data ) {
 234         test_success();
 235     } else {
 236         test_failure(" error in opal_list_append");
 237     }
 238     i=0;
 239     for(ele = (test_data_t *) opal_list_get_first(&list);
 240             ele != (test_data_t *) opal_list_get_end(&list);
 241             ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
 242         i++;
 243     }
 244     if( size_elements == i ) {
 245         test_success();
 246     } else {
 247         test_failure(" error in opal_list_append - list size changed ");
 248     }
 249 
 250     /* remove element from list */
 251     indx=size_elements/2;
 252     if( 0 == indx )
 253         indx=1;
 254     assert(2 <= size_elements);
 255     ele = (test_data_t *)NULL;
 256     ele = (test_data_t *)
 257         opal_list_remove_item(&list,(opal_list_item_t *)(elements+indx));
 258     assert(ele);
 259     if( (indx-1) == ele->data ) {
 260         test_success();
 261     } else {
 262         test_failure(" error in opal_list_remove - previous");
 263     }
 264     ele=(test_data_t *)(((opal_list_item_t *)ele)->opal_list_next);
 265     if( (indx+1) == ele->data ) {
 266         test_success();
 267     } else {
 268         test_failure(" error in opal_list_remove - next");
 269     }
 270     i=0;
 271     for(ele = (test_data_t *) opal_list_get_first(&list);
 272             ele != (test_data_t *) opal_list_get_end(&list);
 273             ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
 274         i++;
 275     }
 276     if( (size_elements-1) == i ) {
 277         test_success();
 278     } else {
 279         test_failure(" error in opal_list_remove - list size changed incorrectly");
 280     }
 281 
 282     /* test the insert function */
 283     i=opal_list_insert(&list,(opal_list_item_t *)(elements+indx),indx);
 284     if( 1 == i ) {
 285         test_success();
 286     } else {
 287         test_failure(" error in opal_list_remove_item \n");
 288     }
 289 
 290     i=0;
 291     for(ele = (test_data_t *) opal_list_get_first(&list);
 292             ele != (test_data_t *) opal_list_get_end(&list);
 293             ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
 294         i++;
 295     }
 296     if( size_elements == i ) {
 297         test_success();
 298     } else {
 299         test_failure(" error in opal_list_insert - incorrect list length");
 300     }
 301     i=0;
 302     error_cnt=0;
 303     for(ele = (test_data_t *) opal_list_get_first(&list);
 304             ele != (test_data_t *) opal_list_get_end(&list);
 305             ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
 306         if( ele->data != i )
 307             error_cnt++;
 308         i++;
 309     }
 310     if( 0 == error_cnt ) {
 311         test_success();
 312     } else {
 313         test_failure(" error in list order - opal_list_remove_item ");
 314     }
 315 
 316     /* test the splice and join functions  */
 317     list_size = opal_list_get_size(&list);
 318     for (i = 0, item = opal_list_get_first(&list) ;
 319          i < list_size / 2 ; ++i, item = opal_list_get_next(item)) {
 320     }
 321     opal_list_splice(&x, opal_list_get_end(&x),
 322                      &list, item, opal_list_get_end(&list));
 323     tmp_size_1 = opal_list_get_size(&list);
 324     tmp_size_2 = opal_list_get_size(&x);
 325     if (tmp_size_1 != i) {
 326         test_failure(" error in splice (size of list)");
 327     } else if (tmp_size_2 != list_size - tmp_size_1) {
 328         test_failure(" error in splice (size of x)");
 329     } else {
 330         test_success();
 331     }
 332 
 333     opal_list_join(&list, opal_list_get_end(&list), &x);
 334     tmp_size_1 = opal_list_get_size(&list);
 335     tmp_size_2 = opal_list_get_size(&x);
 336     if (tmp_size_1 != list_size) {
 337         test_failure(" error in join (size of list)");
 338     } else if (tmp_size_2 != 0) {
 339         test_failure(" error in join (size of x)");
 340     } else {
 341         test_success();
 342     }
 343 
 344     if (NULL != elements) free(elements);
 345 
 346     opal_finalize_util ();
 347 
 348     return test_finalize();
 349 }
/* [<][>][^][v][top][bottom][index][help] */
root/test/class/opal_list.c

DEFINITIONS
