test_yc_dblnklst.c

一个类STL的多平台可移植的算法容器库,主要用于嵌入式系统编程时的内存管理等方面

#ifdef _MSC_VER
    #pragma warning(disable:4127)
    #pragma warning(disable:4244)
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../../young/youngc.h"

#ifdef  __cplusplus
    using namespace youngc;
#endif

extern int arr[20];

extern void print_int( void* ptr );
extern void destroy_int( void* ptr );

void print_dblnklst( dblnklst* self )
{
    dblnklst_iterator begin, end;
    begin = dblnklst_begin( self );
    end = dblnklst_end( self );

    while( begin != end )
    {
        print_int( dblnklst_itr_deref(begin) );
        dblnklst_itr_inc( &begin );
    }

    putchar( '\n' );
}

void test_dblnklst( void )
{
    dblnklst dli;

    dblnklst_init( &dli, sizeof(int), NULL, NULL,
                   destroy_int, pool_alloc, pool_dealloc );

    while( 1 )
    {
        int choice = 0;

        printf( "\n\n" );
        printf( "  1: test dblnklst_init_copy\n" );
        printf( "  2: test dblnklst_assign_copy\n" );
        printf( "  3: test dblnklst_init_move\n" );
        printf( "  4: test dblnklst_assign_move\n" );
        printf( "  5: test dblnklst_index\n" );
        printf( "  6: test dblnklst_at\n" );
        printf( "  7: test dblnklst_size\n" );
        printf( "  8: test dblnklst_splice_range\n" );
        printf( "  9: test dblnklst_splice_node\n" );
        printf( " 10: test dblnklst_splice_dblnklst\n" );
        printf( " 11: test dblnklst_erase_pos\n" );
        printf( " 12: test dblnklst_erase_range\n" );
        printf( " 13: test dblnklst_insert_node\n" );
        printf( " 14: test dblnklst_insert_value\n" );
        printf( " 15: test dblnklst_insert_array\n" );
        printf( " 16: test dblnklst_reverse\n" );
        printf( " 17: test dblnklst_resize\n" );
        printf( " 18: test dblnklst_replace_fill\n" );
        printf( " 19: test dblnklst_replace_array\n" );
        printf( " 20: test dblnklst_max_size\n" );
        printf( " 21: test dblnklst_empty\n" );
        printf( " 22: test dblnklst_begin\n" );
        printf( " 23: test dblnklst_end\n" );
        printf( " 24: test dblnklst_front\n" );
        printf( " 25: test dblnklst_back\n" );
        printf( " 26: test dblnklst_pop_back\n" );
        printf( " 27: test dblnklst_pop_front\n" );
        printf( " 28: test dblnklst_push_back\n" );
        printf( " 29: test dblnklst_push_front\n" );
        printf( " 30: test dblnklst_remove\n" );
        printf( " 31: test dblnklst_unique\n" );
        printf( " 32: test dblnklst_merge\n" );
        printf( " 33: test dblnklst_sort\n" );
        printf( " 34: print dblnklst\n" );
        printf( "  0: exit\n\n\n" );

        scanf( "%d", &choice );

        switch( choice )
        {
            case 0:
                goto EXIT;
            case 1:
            {
                dblnklst dli1;
                dblnklst_init_copy( &dli1, &dli );
                printf( "src: " );
                print_dblnklst( &dli );
                printf( "dst: " );
                print_dblnklst( &dli1 );
                dblnklst_destroy( &dli );
                dblnklst_init_copy( &dli, &dli1 );
                dblnklst_destroy( &dli1 );
                break;
            }
            case 2:
            {
                dblnklst dli1;
                dblnklst_init( &dli1, sizeof(int), NULL, NULL,
                               destroy_int, pool_alloc, pool_dealloc );
                dblnklst_insert_array( &dli1, dblnklst_end(&dli1), arr, 20 );
                printf( "before: " );
                print_dblnklst( &dli1 );
                dblnklst_assign_copy( &dli1, &dli );
                printf( "after: " );
                print_dblnklst( &dli1 );
                dblnklst_destroy( &dli );
                dblnklst_assign_copy( &dli, &dli1 );
                dblnklst_destroy( &dli1 );
                break;
            }
            case 3:
            {
                dblnklst dli1;
                dblnklst_init_move( &dli1, &dli );
                printf( "src: " );
                print_dblnklst( &dli );
                printf( "dst: " );
                print_dblnklst( &dli1 );
                dblnklst_destroy( &dli1 );
                break;
            }
            case 4:
            {
                dblnklst dli1;
                dblnklst_init( &dli1, sizeof(int), NULL, NULL,
                            destroy_int, pool_alloc, pool_dealloc );
                dblnklst_insert_array( &dli1, dblnklst_end(&dli1), arr, 20 );
                printf( "before src: " );
                print_dblnklst( &dli );
                printf( "before dst: " );
                print_dblnklst( &dli1 );
                dblnklst_assign_move( &dli1, &dli );
                printf( "after src: " );
                print_dblnklst( &dli );
                printf( "after dst: " );
                print_dblnklst( &dli1 );
                dblnklst_destroy( &dli1 );
                break;
            }
            case 5:
            {
                size_t index = 0;
                printf( "please input index:\n" );
                scanf( "%u", &index );
                printf( "dblnklst[%u]: %d\n", index, *((int*)dblnklst_index(&dli, index)) );
                break;
            }
            case 6:
            {
                size_t index = 0;
                int* p = NULL;
                printf( "please input index:\n" );
                scanf( "%u", &index );
                p = (int*)dblnklst_at( &dli, index );
                if( p )
                    printf( "dblnklst[%u]: %d\n", index, *p );
                else
                    printf( "out of range!\n" );
                break;
            }
            case 7:
            {
                printf( "size of dblnklst: %u\n", dblnklst_size(&dli) );
                break;
            }
            case 8:
            {
                break;
            }
            case 9:
            {
                break;
            }
            case 10:
            {
                break;
            }
            case 11:
            {
                size_t pos;
                printf( "please input index:\n" );
                scanf( "%u", &pos );
                printf( "before: " );
                print_dblnklst( &dli );
                dblnklst_erase_pos( &dli, dblnklst_itr_add(dblnklst_begin(&dli), pos) );
                printf( "after: " );
                print_dblnklst( &dli );
                break;
            }
            case 12:
            {
                size_t first = 0, last = 0;
                printf( "please input first index:\n" );
                scanf( "%u", &first );
                printf( "please input last index:\n" );
                scanf( "%u", &last );
                printf( "before: " );
                print_dblnklst( &dli );
                dblnklst_erase_range( &dli, dblnklst_itr_add(dblnklst_begin(&dli), first),
                                   dblnklst_itr_add(dblnklst_begin(&dli), last) );
                printf( "after: " );
                print_dblnklst( &dli );
                break;
            }
            case 13:
            {
                size_t pos;
                int val;
                printf( "please input index:\n" );
                scanf( "%d", &pos );
                printf( "please input an integer:\n" );
                scanf( "%d", &val );
                dblnklst_insert_node( &dli, dblnklst_itr_add(dblnklst_begin(&dli), pos), &val );
                print_dblnklst( &dli );
                break;
            }
            case 14:
            {
                size_t count, pos;
                int val;
                printf( "please input index:\n" );
                scanf( "%d", &pos );
                printf( "please input insert count:\n" );
                scanf( "%u", &count );
                printf( "please input an integer:\n" );
                scanf( "%d", &val );
                count = dblnklst_insert_value( &dli, dblnklst_itr_add(dblnklst_begin(&dli), pos),
                                            &val, count );
                printf( "insert node = %u\n", count );
                break;
            }
            case 15:
            {
                size_t pos;
                printf( "please input index:\n" );
                scanf( "%d", &pos );
                pos = dblnklst_insert_array( &dli, dblnklst_itr_add(dblnklst_begin(&dli), pos),
                                             arr, 30 );
                printf( "insert node = %u\n", pos );
                break;
            }
            case 16:
            {
                printf( "before: " );
                print_dblnklst( &dli );
                dblnklst_reverse( &dli );
                printf( "after: " );
                print_dblnklst( &dli );
                break;
            }
            case 17:
            {
                size_t len;
                int val;
                printf( "please input new size:\n" );
                scanf( "%u", &len );
                printf( "please input an integer:\n" );
                scanf( "%d", &val );
                dblnklst_resize( &dli, len, &val );
                print_dblnklst( &dli );
                break;
            }
            case 18:
            {
                size_t len, first, last;
                int val;
                printf( "please input first index:\n" );
                scanf( "%d", &first );
                printf( "please input last index:\n" );
                scanf( "%d", &last );
                printf( "please input new count:\n" );
                scanf( "%u", &len );
                printf( "please input an integer:\n" );
                scanf( "%d", &val );
                dblnklst_replace_fill( &dli,
                                       dblnklst_itr_add(dblnklst_begin(&dli), first),
                                       dblnklst_itr_add(dblnklst_begin(&dli), last),
                                       &val, len );
                print_dblnklst( &dli );
                break;
            }
            case 19:
            {
                size_t first, last;
                printf( "please input first index:\n" );
                scanf( "%d", &first );
                printf( "please input last index:\n" );
                scanf( "%d", &last );
                dblnklst_replace_array( &dli,
                                        dblnklst_itr_add(dblnklst_begin(&dli), first),
                                        dblnklst_itr_add(dblnklst_begin(&dli), last),
                                        arr, 30 );
                print_dblnklst( &dli );
                break;
            }
            case 20:
            {
                printf( "max size of dblnklst: %u\n", dblnklst_max_size() );
                break;
            }
            case 21:
            {
                printf( "dblnklst %s!\n", dblnklst_empty(&dli) ? "is empty" : "isn't empty" );
                break;
            }
            case 22:
            {
                printf( "address of begin: %p\n", dblnklst_begin(&dli) );
                break;
            }
            case 23:
            {
                printf( "address of end: %p\n", dblnklst_end(&dli) );
                break;
            }
            case 24:
            {
                printf( "front of dblnklst: %d\n", *((int*)dblnklst_front(&dli)) );
                break;
            }
            case 25:
            {
                printf( "back of dblnklst: %d\n", *((int*)dblnklst_back(&dli)) );
                break;
            }
            case 26:
            {
                dblnklst_pop_back( &dli );
                break;
            }
            case 27:
            {
                dblnklst_pop_front( &dli );
                break;
            }
            case 28:
            {
                int val = 0;
                printf( "please input an integer:\n" );
                scanf( "%d", &val );
                dblnklst_push_back( &dli, &val );
                break;
            }
            case 29:
            {
                int val = 0;
                printf( "please input an integer:\n" );
                scanf( "%d", &val );
                dblnklst_push_front( &dli, &val );
                break;
            }
            case 30:
            {
                int remove;
                printf( "before: " );
                print_dblnklst( &dli );
                printf( "please input remove value:\n" );
                scanf( "%d", &remove );
                dblnklst_remove( &dli, &remove, cmp_int );
                printf( "after: " );
                print_dblnklst( &dli );
                break;
            }
            case 31:
            {
                printf( "before: " );
                print_dblnklst( &dli );
                dblnklst_unique( &dli, cmp_int );
                printf( "after: " );
                print_dblnklst( &dli );
                break;
            }
            case 32:
            {
                break;
            }
            case 33:
            {
                printf( "before: " );
                print_dblnklst( &dli );
                dblnklst_sort( &dli, 32, cmp_int );
                printf( "after: " );
                print_dblnklst( &dli );
                break;
            }
            case 34:
            {
                print_dblnklst( &dli );
                break;
            }
            default:
                break;
        }

        printf( "\npress any key to continue\n" );
        pool_print();
        getchar();
        getchar();
    }

EXIT:
    printf( "destroy dblnklst:\n" );
    dblnklst_destroy( &dli );
    printf( "\n\n\n" );
}