//==========================================================================
//
//
//
//==========================================================================
SortNode * HWDrawList::SortSpriteList(SortNode * head)
{
SortNode * n;
int count;
unsigned i;
static TArray<SortNode*> sortspritelist;
SortNode * parent=head->parent;
sortspritelist.Clear();
for(count=0,n=head;n;n=n->next) sortspritelist.Push(n);
std::stable_sort(sortspritelist.begin(), sortspritelist.end(), [=](SortNode *a, SortNode *b)
{
return CompareSprites(a, b) < 0;
});
for(i=0;i<sortspritelist.Size();i++)
{
sortspritelist[i]->next=NULL;
if (parent) parent->equal=sortspritelist[i];
parent=sortspritelist[i];
}
return sortspritelist[0];
}
int main()
{
TArray<string, 3> A(3,3,3);
for(int i = 0; i < A.shape(0); ++i) {
for(int j = 0; j < A.shape(1); ++j) {
for(int k = 0; k < A.shape(2); ++k) {
ostringstream so;
so << i << "," << j << "," << k;
A(i,j,k) = so.str();
}
}
}
TArray<string, 3> B;
permute(A, {2,1,0}, B);
auto itrA = A.begin();
auto itrB = B.begin();
while (itrA != A.end() && itrB != B.end()) {
cout << *itrA << " -> " << *itrB << endl;
++itrA;
++itrB;
}
return 0;
}
//---------------------------------------------------------------------------------------------
// Crash when iterating an empty array.
//---------------------------------------------------------------------------------------------
TEST_F( TArrayTest, bug_IterateEmptyListTest ) {
TArray<float> arrayInstance;
bool ok = true;
try {
for( TArray<float>::Iterator it = arrayInstance.begin( ); it != arrayInstance.end( ); ++it );
} catch ( ... ) {
ok = false;
}
EXPECT_TRUE( ok );
}
TEST_F( TArrayTest, iterateTest ) {
TArray<float> arrayInstance;
createArray( ArrayData, ArraySize, arrayInstance );
size_t i( 0 );
for( TArray<float>::Iterator it = arrayInstance.begin( ); it != arrayInstance.end( ); ++it ) {
++i;
}
EXPECT_EQ( i, arrayInstance.size() );
}
TEST_F( TArrayTest, removeItTest) {
TArray<float> arrayInstance;
arrayInstance.add( 1.0f );
EXPECT_EQ( 1, arrayInstance.size() );
TArray<float>::Iterator it = arrayInstance.find( 1.0f );
EXPECT_NE( arrayInstance.end(), it );
arrayInstance.remove( it );
EXPECT_EQ( 0, arrayInstance.size() );
}
TEST_F( TArrayTest, findTest ) {
TArray<float> arrayInstance;
arrayInstance.add( 0.0f );
arrayInstance.add( 1.0f );
arrayInstance.add( 2.0f );
arrayInstance.add( 3.0f );
EXPECT_EQ( 4, arrayInstance.size() );
TArray<float>::Iterator it = arrayInstance.find( 1.0f );
EXPECT_NE( it, arrayInstance.end() );
EXPECT_EQ( *it, 1.0f );
}
TEST_F( TArrayTest, postIncIterateTest ) {
TArray<float> arrayInstance;
createArray( ArrayData, ArraySize, arrayInstance );
bool ok = true;
try {
size_t i=0;
for( TArray<float>::Iterator it = arrayInstance.begin( ); it != arrayInstance.end( ); it++ ) {
float tmp = *it;
EXPECT_EQ( tmp, ArrayData[ i ] );
++i;
}
} catch (...) {
ok = false;
}
EXPECT_TRUE( ok );
}
int main()
{
cout<<"TArray example: \n";
TArray<int> testArray;
testArray.push_back(10);
testArray.push_back(20);
testArray.push_front(1);
testArray.Clear();
for(TArray<int>::iterator it=testArray.begin();it!=testArray.end();it++)
cout<<*it<<endl;
cout<<"TBinaryTree example: \n";
TBinaryTree<int> tree;
tree.addElement(20);
tree.addElement(10);
tree.addElement(40);
tree.addElement(2);
tree.addElement(12);
tree.remove(10);
tree.displayPreOrder();
cout<<"TDeque example: \n";
TDeque<int> deque;
deque.push_back(10);
deque.push_front(20);
deque.push_front(30);
deque.push_back(3);
for(TDeque<int>::iterator it=deque.begin();it!=deque.end();it++)
cout<<*it<<endl;
cout<<"Show items without iterators:\n";
for(int i=0;i<deque.Size();i++)
cout<<deque[i]<<endl;
TList<int> list;
return 0;
}
TEST_F( TArrayTest, constructTest ) {
TArray<float> arrayInstance;
EXPECT_EQ( true, arrayInstance.isEmpty() );
EXPECT_EQ( 0U, arrayInstance.size() );
EXPECT_EQ( arrayInstance.begin(), arrayInstance.end() );
}
