{

schar* array;

int count;

int max_count;

int elem_size;

{

int elem_size = seq->elem_size;

if( from_idx == to_idx )

return;

assert( (from_idx > to_idx && !elem) || (from_idx < to_idx && elem) );

if( from_idx < seq->count )

{

memmove( seq->array + to_idx*elem_size, seq->array + from_idx*elem_size,

(seq->count - from_idx)*elem_size );

}

seq->count += to_idx - from_idx;

if( elem )

memcpy( seq->array + from_idx*elem_size, elem, (to_idx - from_idx)*elem_size );

{

int i, k, len = seq->count, elem_size = seq->elem_size;

schar *data = seq->array, t;

for( i = 0; i < len/2; i++ )

{

schar* a = data + i*elem_size;

schar* b = data + (len - i - 1)*elem_size;

for( k = 0; k < elem_size; k++ )

CV_SWAP( a[k], b[k], t );

}

{

schar* array;

int count, max_count;

int elem_size;

int* free_stack;

int free_count;

{

int i;

int elem_size = set_header->elem_size;

for( i = 0; i < set_header->max_count; i++ )

{

set_header->array[i*elem_size] = 0;

set_header->free_stack[i] = set_header->max_count - i - 1;

}

set_header->free_count = set_header->max_count;

set_header->count = 0;

{

int idx, idx2;

assert( set_header->free_count > 0 );

idx = set_header->free_stack[--set_header->free_count];

idx2 = idx * set_header->elem_size;

assert( set_header->array[idx2] == 0 );

set_header->array[idx2] = 1;

if( set_header->elem_size > 1 )

memcpy( set_header->array + idx2 + 1, elem, set_header->elem_size - 1 );

set_header->count = MAX( set_header->count, idx + 1 );

return idx;

{

assert( set_header->free_count < set_header->max_count &&

0 <= index && index < set_header->max_count );

assert( set_header->array[index * set_header->elem_size] == 1 );

set_header->free_stack[set_header->free_count++] = index;

set_header->array[index * set_header->elem_size] = 0;

{

char* matrix;

int edge_size;

int oriented;

CvTsSimpleSet* vtx;

{

int max_vtx_count = graph->vtx->max_count;

cvTsClearSimpleSet( graph->vtx );

memset( graph->matrix, 0, max_vtx_count * max_vtx_count * graph->edge_size );

{

if( *graph )

{

cvTsReleaseSimpleSet( &(graph[0]->vtx) );

cvFree( graph );

}

{

int i, max_vtx_count = graph->vtx->max_count;

int edge_size = graph->edge_size;

cvTsSimpleSetRemove( graph->vtx, index );

/* remove all the corresponding edges */

for( i = 0; i < max_vtx_count; i++ )

{

graph->matrix[(i*max_vtx_count + index)*edge_size] =

graph->matrix[(index*max_vtx_count + i)*edge_size] = 0;

}

{

int i, t, n = graph->oriented ? 1 : 2;

assert( cvTsSimpleSetFind( graph->vtx, idx1 ) &&

cvTsSimpleSetFind( graph->vtx, idx2 ));

for( i = 0; i < n; i++ )

{

int ofs = (idx1*graph->vtx->max_count + idx2)*graph->edge_size;

assert( graph->matrix[ofs] == 0 );

graph->matrix[ofs] = 1;

if( graph->edge_size > 1 )

memcpy( graph->matrix + ofs + 1, edge, graph->edge_size - 1 );

CV_SWAP( idx1, idx2, t );

}

{

int i, t, n = graph->oriented ? 1 : 2;

assert( cvTsSimpleSetFind( graph->vtx, idx1 ) &&

cvTsSimpleSetFind( graph->vtx, idx2 ));

for( i = 0; i < n; i++ )

{

int ofs = (idx1*graph->vtx->max_count + idx2)*graph->edge_size;

assert( graph->matrix[ofs] == 1 );

graph->matrix[ofs] = 0;

CV_SWAP( idx1, idx2, t );

}

{

int i, count = 0;

int edge_size = graph->edge_size;

int max_vtx_count = graph->vtx->max_count;

assert( cvTsSimpleGraphFindVertex( graph, index ) != 0 );

for( i = 0; i < max_vtx_count; i++ )

{

count += graph->matrix[(i*max_vtx_count + index)*edge_size] +

graph->matrix[(index*max_vtx_count + i)*edge_size];

}

if( !graph->oriented )

{

assert( count % 2 == 0 );

count /= 2;

}

return count;

{

Core_DynStructBaseTest();

virtual ~Core_DynStructBaseTest();

bool can_do_fast_forward();

void clear();

int read_params( CvFileStorage* fs );

void run_func(void);

void set_error_context( const char* condition,

const char* err_msg,

const char* file, int line );

int test_seq_block_consistence( int _struct_idx, CvSeq* seq, int total );

void update_progressbar();

int struct_count, max_struct_size, iterations, generations;

int min_log_storage_block_size, max_log_storage_block_size;

int min_log_elem_size, max_log_elem_size;

int gen, struct_idx, iter;

int test_progress;

int64 start_time;

double cpu_freq;

vector<void*> cxcore_struct;

vector<void*> simple_struct;

Ptr<CvMemStorage> storage;

{

struct_count = 2;

max_struct_size = 2000;

min_log_storage_block_size = 7;

max_log_storage_block_size = 12;

min_log_elem_size = 0;

max_log_elem_size = 8;

generations = 10;

iterations = max_struct_size*2;

gen = struct_idx = iter = -1;

test_progress = -1;

storage = 0;

{

int code = cvtest::BaseTest::read_params( fs );

double sqrt_scale = sqrt(ts->get_test_case_count_scale());

if( code < 0 )

return code;

struct_count = cvReadInt( find_param( fs, "struct_count" ), struct_count );

max_struct_size = cvReadInt( find_param( fs, "max_struct_size" ), max_struct_size );

generations = cvReadInt( find_param( fs, "generations" ), generations );

iterations = cvReadInt( find_param( fs, "iterations" ), iterations );

generations = cvRound(generations*sqrt_scale);

iterations = cvRound(iterations*sqrt_scale);

min_log_storage_block_size = cvReadInt( find_param( fs, "min_log_storage_block_size" ),

min_log_storage_block_size );

max_log_storage_block_size = cvReadInt( find_param( fs, "max_log_storage_block_size" ),

max_log_storage_block_size );

min_log_elem_size = cvReadInt( find_param( fs, "min_log_elem_size" ), min_log_elem_size );

max_log_elem_size = cvReadInt( find_param( fs, "max_log_elem_size" ), max_log_elem_size );

struct_count = cvtest::clipInt( struct_count, 1, 100 );

max_struct_size = cvtest::clipInt( max_struct_size, 1, 1<<20 );

generations = cvtest::clipInt( generations, 1, 100 );

iterations = cvtest::clipInt( iterations, 100, 1<<20 );

min_log_storage_block_size = cvtest::clipInt( min_log_storage_block_size, 7, 20 );

max_log_storage_block_size = cvtest::clipInt( max_log_storage_block_size,

min_log_storage_block_size, 20 );

min_log_elem_size = cvtest::clipInt( min_log_elem_size, 0, 8 );

max_log_elem_size = cvtest::clipInt( max_log_elem_size, min_log_elem_size, 10 );

return 0;

{

int64 t;

if( test_progress < 0 )

{

test_progress = 0;

cpu_freq = cv::getTickFrequency();

start_time = cv::getTickCount();

}

t = cv::getTickCount();

test_progress = update_progress( test_progress, 0, 0, (double)(t - start_time)/cpu_freq );

const char* err_msg,

const char* filename, int lineno )

{

ts->printf( cvtest::TS::LOG, "file %s, line %d: %s\n(\"%s\" failed).\n"

"generation = %d, struct_idx = %d, iter = %d\n",

filename, lineno, err_msg, condition, gen, struct_idx, iter );

ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );

{

int sum = 0;

struct_idx = _struct_idx;

CV_TS_SEQ_CHECK_CONDITION( seq != 0, "Null sequence pointer" );

if( seq->first )

{

CvSeqBlock* block = seq->first;

CvSeqBlock* prev_block = block->prev;

int delta_idx = seq->first->start_index;

for( ;; )

{

CV_TS_SEQ_CHECK_CONDITION( sum == block->start_index - delta_idx &&

block->count > 0 && block->prev == prev_block &&

prev_block->next == block,

"sequence blocks are inconsistent" );

sum += block->count;

prev_block = block;

block = block->next;

if( block == seq->first ) break;

}

CV_TS_SEQ_CHECK_CONDITION( block->prev->count * seq->elem_size +

block->prev->data <= seq->block_max,

"block->data or block_max pointer are incorrect" );

}

CV_TS_SEQ_CHECK_CONDITION( seq->total == sum && sum == total,

"total number of elements is incorrect" );

return 0;

{

Core_SeqBaseTest();

virtual ~Core_SeqBaseTest();

void clear();

void run( int );

int test_multi_create();

int test_get_seq_elem( int _struct_idx, int iters );

int test_get_seq_reading( int _struct_idx, int iters );

int test_seq_ops( int iters );

{

for( size_t i = 0; i < simple_struct.size(); i++ )

cvTsReleaseSimpleSeq( (CvTsSimpleSeq**)&simple_struct[i] );

Core_DynStructBaseTest::clear();

{

vector<CvSeqWriter> writer(struct_count);

vector<int> pos(struct_count);

vector<int> index(struct_count);

int cur_count, elem_size;

RNG& rng = ts->get_rng();

for( int i = 0; i < struct_count; i++ )

{

double t;

CvTsSimpleSeq* sseq;

pos[i] = -1;

index[i] = i;

t = cvtest::randReal(rng)*(max_log_elem_size - min_log_elem_size) + min_log_elem_size;

elem_size = cvRound( exp(t * CV_LOG2) );

elem_size = MIN( elem_size, (int)(storage->block_size - sizeof(void*) -

sizeof(CvSeqBlock) - sizeof(CvMemBlock)) );

cvTsReleaseSimpleSeq( (CvTsSimpleSeq**)&simple_struct[i] );

simple_struct[i] = sseq = cvTsCreateSimpleSeq( max_struct_size, elem_size );

cxcore_struct[i] = 0;

sseq->count = cvtest::randInt( rng ) % max_struct_size;

Mat m( 1, MAX(sseq->count,1)*elem_size, CV_8UC1, sseq->array );

cvtest::randUni( rng, m, Scalar::all(0), Scalar::all(256) );

}

for( cur_count = struct_count; cur_count > 0; cur_count-- )

{

for(;;)

{

int k = cvtest::randInt( rng ) % cur_count;

struct_idx = index[k];

CvTsSimpleSeq* sseq = (CvTsSimpleSeq*)simple_struct[struct_idx];

if( pos[struct_idx] < 0 )

{

int hdr_size = (cvtest::randInt(rng) % 10)*4 + sizeof(CvSeq);

hdr_size = MIN( hdr_size, (int)(storage->block_size - sizeof(CvMemBlock)) );

elem_size = sseq->elem_size;

if( cvtest::randInt(rng) % 2 )

{

cvStartWriteSeq( 0, hdr_size, elem_size, storage, &writer[struct_idx] );

}

else

{

CvSeq* s;

s = cvCreateSeq( 0, hdr_size, elem_size, storage );

cvStartAppendToSeq( s, &writer[struct_idx] );

}

cvSetSeqBlockSize( writer[struct_idx].seq, cvtest::randInt( rng ) % 10000 );

pos[struct_idx] = 0;

}

update_progressbar();

if( pos[struct_idx] == sseq->count )

{

cxcore_struct[struct_idx] = cvEndWriteSeq( &writer[struct_idx] );

/* del index */

for( ; k < cur_count-1; k++ )

index[k] = index[k+1];

break;

}

{

schar* el = cvTsSimpleSeqElem( sseq, pos[struct_idx] );

CV_WRITE_SEQ_ELEM_VAR( el, writer[struct_idx] );

}

pos[struct_idx]++;

}

}

return 0;

{

RNG& rng = ts->get_rng();

CvSeq* seq = (CvSeq*)cxcore_struct[_struct_idx];

CvTsSimpleSeq* sseq = (CvTsSimpleSeq*)simple_struct[_struct_idx];

struct_idx = _struct_idx;

assert( seq->total == sseq->count );

if( sseq->count == 0 )

return 0;

for( int i = 0; i < iters; i++ )

{

int idx = cvtest::randInt(rng) % (sseq->count*3) - sseq->count*3/2;

int idx0 = (unsigned)idx < (unsigned)(sseq->count) ? idx : idx < 0 ?

idx + sseq->count : idx - sseq->count;

int bad_range = (unsigned)idx0 >= (unsigned)(sseq->count);

schar* elem;

elem = cvGetSeqElem( seq, idx );

if( bad_range )

{

CV_TS_SEQ_CHECK_CONDITION( elem == 0,

"cvGetSeqElem doesn't "

"handle \"out of range\" properly" );

}

else

{

CV_TS_SEQ_CHECK_CONDITION( elem != 0 &&

!memcmp( elem, cvTsSimpleSeqElem(sseq, idx0), sseq->elem_size ),

"cvGetSeqElem returns wrong element" );

idx = cvSeqElemIdx(seq, elem );

CV_TS_SEQ_CHECK_CONDITION( idx >= 0 && idx == idx0,

"cvSeqElemIdx is incorrect" );

}

}

return 0;

{

const int max_val = 3*5 + 2;

CvSeq* seq = (CvSeq*)cxcore_struct[_struct_idx];

CvTsSimpleSeq* sseq = (CvTsSimpleSeq*)simple_struct[_struct_idx];

int total = seq->total;

RNG& rng = ts->get_rng();

CvSeqReader reader;

vector<schar> _elem(sseq->elem_size);

schar* elem = &_elem[0];

assert( total == sseq->count );

this->struct_idx = _struct_idx;

int pos = cvtest::randInt(rng) % 2;

cvStartReadSeq( seq, &reader, pos );

if( total == 0 )

{

CV_TS_SEQ_CHECK_CONDITION( reader.ptr == 0, "Empty sequence reader pointer is not NULL" );

return 0;

}

pos = pos ? seq->total - 1 : 0;

CV_TS_SEQ_CHECK_CONDITION( pos == cvGetSeqReaderPos(&reader),

"initial reader position is wrong" );

for( iter = 0; iter < iters; iter++ )

{

int op = cvtest::randInt(rng) % max_val;

if( op >= max_val - 2 )

{

int new_pos, new_pos0;

int bad_range;

int is_relative = op == max_val - 1;

new_pos = cvtest::randInt(rng) % (total*2) - total;

new_pos0 = new_pos + (is_relative ? pos : 0 );

if( new_pos0 < 0 ) new_pos0 += total;

if( new_pos0 >= total ) new_pos0 -= total;

bad_range = (unsigned)new_pos0 >= (unsigned)total;

cvSetSeqReaderPos( &reader, new_pos, is_relative );

if( !bad_range )

{

CV_TS_SEQ_CHECK_CONDITION( new_pos0 == cvGetSeqReaderPos( &reader ),

"cvset reader position doesn't work" );

pos = new_pos0;

}

else

{

CV_TS_SEQ_CHECK_CONDITION( pos == cvGetSeqReaderPos( &reader ),

"reader doesn't stay at the current position after wrong positioning" );

}

}

else

{

int direction = (op % 3) - 1;

memcpy( elem, reader.ptr, sseq->elem_size );

if( direction > 0 )

{

CV_NEXT_SEQ_ELEM( sseq->elem_size, reader );

}

else if( direction < 0 )

{

CV_PREV_SEQ_ELEM( sseq->elem_size, reader );

}

CV_TS_SEQ_CHECK_CONDITION( memcmp(elem, cvTsSimpleSeqElem(sseq, pos),

sseq->elem_size) == 0, "reading is incorrect" );

pos += direction;

if( -pos > 0 ) pos += total;

if( pos >= total ) pos -= total;

CV_TS_SEQ_CHECK_CONDITION( pos == cvGetSeqReaderPos( &reader ),

"reader doesn't move correctly after reading" );

}

}

return 0;

{

const int max_op = 14;

int max_elem_size = 0;

schar* elem2 = 0;

RNG& rng = ts->get_rng();

for( int i = 0; i < struct_count; i++ )

max_elem_size = MAX( max_elem_size, ((CvSeq*)cxcore_struct[i])->elem_size );

vector<schar> elem_buf(max_struct_size*max_elem_size);

schar* elem = (schar*)&elem_buf[0];

Mat elem_mat;

for( iter = 0; iter < iters; iter++ )

{

struct_idx = cvtest::randInt(rng) % struct_count;

int op = cvtest::randInt(rng) % max_op;

CvSeq* seq = (CvSeq*)cxcore_struct[struct_idx];

CvTsSimpleSeq* sseq = (CvTsSimpleSeq*)simple_struct[struct_idx];

int elem_size = sseq->elem_size;

int whence = 0, pos = 0, count = 0;

switch( op )

{

case 0:

case 1:

case 2: // push/pushfront/insert

if( sseq->count == sseq->max_count )

break;

elem_mat = Mat(1, elem_size, CV_8U, elem);

cvtest::randUni( rng, elem_mat, cvScalarAll(0), cvScalarAll(255) );

whence = op - 1;

if( whence < 0 )

{

pos = 0;

cvSeqPushFront( seq, elem );

}

else if( whence > 0 )

{

pos = sseq->count;

cvSeqPush( seq, elem );

}

else

{

pos = cvtest::randInt(rng) % (sseq->count + 1);

cvSeqInsert( seq, pos, elem );

}

cvTsSimpleSeqShiftAndCopy( sseq, pos, pos + 1, elem );

elem2 = cvGetSeqElem( seq, pos );

CV_TS_SEQ_CHECK_CONDITION( elem2 != 0, "The inserted element could not be retrieved" );

CV_TS_SEQ_CHECK_CONDITION( seq->total == sseq->count &&

memcmp(elem2, cvTsSimpleSeqElem(sseq,pos), elem_size) == 0,

"The inserted sequence element is wrong" );

break;

case 3:

case 4:

case 5: // pop/popfront/remove

if( sseq->count == 0 )

break;

whence = op - 4;

if( whence < 0 )

{

pos = 0;

cvSeqPopFront( seq, elem );

}

else if( whence > 0 )

{

pos = sseq->count-1;

cvSeqPop( seq, elem );

}

else

{

pos = cvtest::randInt(rng) % sseq->count;

cvSeqRemove( seq, pos );

}

if( whence != 0 )

CV_TS_SEQ_CHECK_CONDITION( seq->total == sseq->count - 1 &&

memcmp( elem, cvTsSimpleSeqElem(sseq,pos), elem_size) == 0,

"The popped sequence element isn't correct" );

cvTsSimpleSeqShiftAndCopy( sseq, pos + 1, pos );

if( sseq->count > 0 )

{

elem2 = cvGetSeqElem( seq, pos < sseq->count ? pos : -1 );

CV_TS_SEQ_CHECK_CONDITION( elem2 != 0, "GetSeqElem fails after removing the element" );

CV_TS_SEQ_CHECK_CONDITION( memcmp( elem2,

cvTsSimpleSeqElem(sseq, pos - (pos == sseq->count)), elem_size) == 0,

"The first shifted element is not correct after removing another element" );

}

else

{

CV_TS_SEQ_CHECK_CONDITION( seq->first == 0,

"The sequence doesn't become empty after the final remove" );

}

break;

case 6:

case 7:

case 8: // push [front] multi/insert slice

if( sseq->count == sseq->max_count )

break;

count = cvtest::randInt( rng ) % (sseq->max_count - sseq->count + 1);

elem_mat = Mat(1, MAX(count,1) * elem_size, CV_8U, elem);

cvtest::randUni( rng, elem_mat, cvScalarAll(0), cvScalarAll(255) );

whence = op - 7;

pos = whence < 0 ? 0 : whence > 0 ? sseq->count : (int)(cvtest::randInt(rng) % (sseq->count+1));

if( whence != 0 )

{

cvSeqPushMulti( seq, elem, count, whence < 0 );

}

else

{

CvSeq header;

CvSeqBlock block;

cvMakeSeqHeaderForArray( CV_SEQ_KIND_GENERIC, sizeof(CvSeq),

sseq->elem_size,

elem, count,

&header, &block );

cvSeqInsertSlice( seq, pos, &header );

}

cvTsSimpleSeqShiftAndCopy( sseq, pos, pos + count, elem );

if( sseq->count > 0 )

{

// choose the random element among the added

pos = count > 0 ? (int)(cvtest::randInt(rng) % count + pos) : MAX(pos-1,0);

elem2 = cvGetSeqElem( seq, pos );

CV_TS_SEQ_CHECK_CONDITION( elem2 != 0, "multi push operation doesn't add elements" );

CV_TS_SEQ_CHECK_CONDITION( seq->total == sseq->count &&

memcmp( elem2, cvTsSimpleSeqElem(sseq,pos), elem_size) == 0,

"One of the added elements is wrong" );

}

else

{

CV_TS_SEQ_CHECK_CONDITION( seq->total == 0 && seq->first == 0,

"Adding no elements to empty sequence fails" );

}

break;

case 9:

case 10:

case 11: // pop [front] multi

if( sseq->count == 0 )

break;

count = cvtest::randInt(rng) % (sseq->count+1);

whence = op - 10;

pos = whence < 0 ? 0 : whence > 0 ? sseq->count - count :

(int)(cvtest::randInt(rng) % (sseq->count - count + 1));

if( whence != 0 )

{

cvSeqPopMulti( seq, elem, count, whence < 0 );

if( count > 0 )

{

CV_TS_SEQ_CHECK_CONDITION( memcmp(elem,

cvTsSimpleSeqElem(sseq,pos), elem_size) == 0,

"The first (in the sequence order) removed element is wrong after popmulti" );

}

}

else

{

cvSeqRemoveSlice( seq, cvSlice(pos, pos + count) );

}

CV_TS_SEQ_CHECK_CONDITION( seq->total == sseq->count - count,

"The popmulti left a wrong number of elements in the sequence" );

cvTsSimpleSeqShiftAndCopy( sseq, pos + count, pos, 0 );

if( sseq->count > 0 )

{

pos = whence < 0 ? 0 : MIN( pos, sseq->count - 1 );

elem2 = cvGetSeqElem( seq, pos );

CV_TS_SEQ_CHECK_CONDITION( elem2 &&

memcmp( elem2, cvTsSimpleSeqElem(sseq,pos), elem_size) == 0,

"The last sequence element is wrong after POP" );

}

else

{

CV_TS_SEQ_CHECK_CONDITION( seq->total == 0 && seq->first == 0,

"The sequence doesn't become empty after final POP" );

}

break;

case 12: // seqslice

{

CvMemStoragePos storage_pos;

cvSaveMemStoragePos( storage, &storage_pos );

int copy_data = cvtest::randInt(rng) % 2;

count = cvtest::randInt(rng) % (seq->total + 1);

pos = cvtest::randInt(rng) % (seq->total - count + 1);

CvSeq* seq_slice = cvSeqSlice( seq, cvSlice(pos, pos + count), storage, copy_data );

CV_TS_SEQ_CHECK_CONDITION( seq_slice && seq_slice->total == count,

"cvSeqSlice returned incorrect slice" );

if( count > 0 )

{

int test_idx = cvtest::randInt(rng) % count;

elem2 = cvGetSeqElem( seq_slice, test_idx );

schar* elem3 = cvGetSeqElem( seq, pos + test_idx );

CV_TS_SEQ_CHECK_CONDITION( elem2 &&

memcmp( elem2, cvTsSimpleSeqElem(sseq,pos + test_idx), elem_size) == 0,

"The extracted slice elements are not correct" );

CV_TS_SEQ_CHECK_CONDITION( (elem2 == elem3) ^ copy_data,

"copy_data flag is handled incorrectly" );

}

cvRestoreMemStoragePos( storage, &storage_pos );

}

break;

case 13: // clear

cvTsClearSimpleSeq( sseq );

cvClearSeq( seq );

CV_TS_SEQ_CHECK_CONDITION( seq->total == 0 && seq->first == 0,

"The sequence doesn't become empty after clear" );

break;

default:

assert(0);

return -1;

}

if( test_seq_block_consistence(struct_idx, seq, sseq->count) < 0 )

return -1;

if( test_get_seq_elem(struct_idx, 7) < 0 )

return -1;

update_progressbar();

}

return 0;

{

try

{

RNG& rng = ts->get_rng();

int i;

double t;

clear();

test_progress = -1;

simple_struct.resize(struct_count, 0);

cxcore_struct.resize(struct_count, 0);

for( gen = 0; gen < generations; gen++ )

{

struct_idx = iter = -1;