test_yc_sglnklst.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_sglnklst( sglnklst* self )
{
    sglnklst_iterator begin, end;
    begin = sglnklst_begin( self );
    end = sglnklst_end();

    while( begin != end )
    {
        print_int( sglnklst_itr_deref(begin) );
        sglnklst_itr_inc( &begin );
    }

    printf( "\n" );
}

void test_sglnklst(void)
{
    sglnklst sli;

    sglnklst_init( &sli, sizeof(int), NULL, NULL,
                destroy_int, pool_alloc, pool_free );

    while( 1 )
    {
        int choice = 0;

        printf( "\n\n" );
        printf( "  1: test sglnklst_init_copy\n" );
        printf( "  2: test sglnklst_assign_copy\n" );
        printf( "  3: test sglnklst_init_move\n" );
        printf( "  4: test sglnklst_assign_move\n" );
        printf( "  5: test sglnklst_index\n" );
        printf( "  6: test sglnklst_at\n" );
        printf( "  7: test sglnklst_size\n" );
        printf( "  8: test sglnklst_splice_after_range\n" );
        printf( "  9: test sglnklst_splice_after_node\n" );
        printf( " 10: test sglnklst_splice_after_sglnklst\n" );
        printf( " 11: test sglnklst_erase_after_pos\n" );
        printf( " 12: test sglnklst_erase_after_range\n" );
        printf( " 13: test sglnklst_insert_after_node\n" );
        printf( " 14: test sglnklst_insert_after_value\n" );
        printf( " 15: test sglnklst_insert_after_array\n" );
        printf( " 16: test sglnklst_reverse\n" );
        printf( " 17: test sglnklst_resize\n" );
        printf( " 18: test sglnklst_replace_after_fill\n" );
        printf( " 19: test sglnklst_replace_after_array\n" );
        printf( " 20: test sglnklst_max_size\n" );
        printf( " 21: test sglnklst_empty\n" );
        printf( " 22: test sglnklst_begin\n" );
        printf( " 23: test sglnklst_front\n" );
        printf( " 24: test sglnklst_back\n" );
        printf( " 25: test sglnklst_pop_back\n" );
        printf( " 26: test sglnklst_push_back\n" );
        printf( " 27: test sglnklst_pop_front\n" );
        printf( " 28: test sglnklst_push_front\n" );
        printf( " 29: test sglnklst_remove\n" );
        printf( " 30: test sglnklst_unique\n" );
        printf( " 31: test sglnklst_merge\n" );
        printf( " 32: test sglnklst_sort\n" );
        printf( " 33: print sglnklst\n" );
        printf( "  0: exit\n\n\n" );

        scanf( "%d", &choice );

        switch( choice )
        {
            case 0:
                goto EXIT;
            case 1:
            {
                sglnklst sli1;
                sglnklst_init_copy( &sli1, &sli );
                printf( "src: " );
                print_sglnklst( &sli );
                printf( "dst: " );
                print_sglnklst( &sli1 );
                sglnklst_destroy( &sli );
                sglnklst_init_copy( &sli, &sli1 );
                sglnklst_destroy( &sli1 );
                break;
            }
            case 2:
            {
                sglnklst sli1;
                sglnklst_init( &sli1, sizeof(int), NULL, NULL,
                               destroy_int, pool_alloc, pool_dealloc );
                sglnklst_insert_after_array( &sli1, &(sli1.m_header), arr, 20 );
                printf( "before: " );
                print_sglnklst( &sli1 );
                sglnklst_assign_copy( &sli1, &sli );
                printf( "after: " );
                print_sglnklst( &sli1 );
                sglnklst_destroy( &sli );
                sglnklst_assign_copy( &sli, &sli1 );
                sglnklst_destroy( &sli1 );
                break;
            }
            case 3:
            {
                sglnklst sli1;
                sglnklst_init_move( &sli1, &sli );
                printf( "src: " );
                print_sglnklst( &sli );
                printf( "dst: " );
                print_sglnklst( &sli1 );
                sglnklst_destroy( &sli1 );
                break;
            }
            case 4:
            {
                sglnklst sli1;
                sglnklst_init( &sli1, sizeof(int), NULL, NULL,
                               destroy_int, pool_alloc, pool_dealloc );
                sglnklst_insert_after_array( &sli1, &(sli1.m_header), arr, 20 );
                printf( "before src: " );
                print_sglnklst( &sli );
                printf( "before dst: " );
                print_sglnklst( &sli1 );
                sglnklst_assign_move( &sli1, &sli );
                printf( "after src: " );
                print_sglnklst( &sli );
                printf( "after dst: " );
                print_sglnklst( &sli1 );
                sglnklst_destroy( &sli1 );
                break;
            }
            case 5:
            {
                size_t index = 0;
                printf( "please input index:\n" );
                scanf( "%u", &index );
                printf( "sglnklst[%u]: %d\n", index, *((int*)sglnklst_index(&sli, index)) );
                break;
            }
            case 6:
            {
                size_t index = 0;
                int* p = NULL;
                printf( "please input index:\n" );
                scanf( "%u", &index );
                p = (int*)sglnklst_at( &sli, index );
                if( p )
                    printf( "sglnklst[%u]: %d\n", index, *p );
                else
                    printf( "out of range!\n" );
                break;
            }
            case 7:
            {
                printf( "size of sglnklst: %u\n", sglnklst_size(&sli) );
                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_sglnklst( &sli );
                sglnklst_erase_after_pos( &sli, sglnklst_itr_add(&(sli.m_header), pos) );
                printf( "after: " );
                print_sglnklst( &sli );
                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_sglnklst( &sli );
                sglnklst_erase_after_range( &sli, sglnklst_itr_add(&(sli.m_header), first),
                                   sglnklst_itr_add(sli.m_header.next, last) );
                printf( "after: " );
                print_sglnklst( &sli );
                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 );
                sglnklst_insert_after_node( &sli, sglnklst_itr_add(&(sli.m_header), pos), &val );
                print_sglnklst( &sli );
                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 = sglnklst_insert_after_value( &sli, sglnklst_itr_add(&(sli.m_header), pos),
                                            &val, count );
                printf( "insert node = %u\n", count );
                break;
            }
            case 15:
            {
                size_t pos;
                printf( "please input index:\n" );
                scanf( "%d", &pos );
                pos = sglnklst_insert_after_array( &sli, sglnklst_itr_add(&(sli.m_header), pos),
                                                   arr, 30 );
                printf( "insert node = %u\n", pos );
                break;
            }
            case 16:
            {
                printf( "before: " );
                print_sglnklst( &sli );
                sglnklst_reverse( &sli );
                printf( "after: " );
                print_sglnklst( &sli );
                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 );
                sglnklst_resize( &sli, len, &val );
                print_sglnklst( &sli );
                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 );
                sglnklst_replace_after_fill( &sli,
                                             sglnklst_itr_add(&(sli.m_header), first),
                                             sglnklst_itr_add(&(sli.m_header), last),
                                             &val, len );
                print_sglnklst( &sli );
                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 );
                sglnklst_replace_after_array( &sli,
                                              sglnklst_itr_add(&(sli.m_header), first),
                                              sglnklst_itr_add(&(sli.m_header), last),
                                              arr, 30 );
                print_sglnklst( &sli );
                break;
            }
            case 20:
            {
                printf( "max size of sglnklst: %u\n", sglnklst_max_size() );
                break;
            }
            case 21:
            {
                printf( "sglnklst %s!\n", sglnklst_empty(&sli) ? "is empty" : "isn't empty" );
                break;
            }
            case 22:
            {
                printf( "address of begin: %p\n", sglnklst_begin(&sli) );
                break;
            }
            case 23:
            {
                printf( "front of sglnklst: %d\n", *((int*)sglnklst_front(&sli)) );
                break;
            }
            case 24:
            {
                printf( "front of sglnklst: %d\n", *((int*)sglnklst_back(&sli)) );
                break;
            }
            case 25:
            {
                sglnklst_pop_back( &sli );
                break;
            }
            case 26:
            {
                int val = 0;
                printf( "please input an integer:\n" );
                scanf( "%d", &val );
                sglnklst_push_back( &sli, &val );
                break;
            }
            case 27:
            {
                sglnklst_pop_front( &sli );
                break;
            }
            case 28:
            {
                int val = 0;
                printf( "please input an integer:\n" );
                scanf( "%d", &val );
                sglnklst_push_front( &sli, &val );
                break;
            }
            case 29:
            {
                int remove;
                printf( "before: " );
                print_sglnklst( &sli );
                printf( "please input remove value:\n" );
                scanf( "%d", &remove );
                sglnklst_remove( &sli, &remove, cmp_int );
                printf( "after: " );
                print_sglnklst( &sli );
                break;
            }
            case 30:
            {
                printf( "before: " );
                print_sglnklst( &sli );
                sglnklst_unique( &sli, cmp_int );
                printf( "after: " );
                print_sglnklst( &sli );
                break;
            }
            case 31:
            {
                break;
            }
            case 32:
            {
                printf( "before: " );
                print_sglnklst( &sli );
                sglnklst_sort( &sli, 32, cmp_int );
                printf( "after: " );
                print_sglnklst( &sli );
                break;
            }
            case 33:
            {
                print_sglnklst( &sli );
                break;
            }
            default:
                break;
        }

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

EXIT:
    printf( "destroy sglnklst:\n" );
    sglnklst_destroy( &sli );
    printf( "\n\n\n" );
}