int UtcDaliVectorInt(void)
{
tet_infoline("Testing Dali::Vector<int>");
Vector< int > intvector;
DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
intvector.PushBack( 11 );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), intvector.Capacity(), TEST_LOCATION );
DALI_TEST_EQUALS( 11, intvector[ 0 ], TEST_LOCATION );
intvector.PushBack( 99 );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), intvector.Capacity(), TEST_LOCATION );
DALI_TEST_EQUALS( 99, intvector[ 1 ], TEST_LOCATION );
intvector.PushBack( 34 );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(6), intvector.Capacity(), TEST_LOCATION );
DALI_TEST_EQUALS( 11, intvector[ 0 ], TEST_LOCATION );
DALI_TEST_EQUALS( 99, intvector[ 1 ], TEST_LOCATION );
DALI_TEST_EQUALS( 34, intvector[ 2 ], TEST_LOCATION );
intvector.Clear();
DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(6), intvector.Capacity(), TEST_LOCATION );
intvector.PushBack( 123 );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( 123, intvector[ 0 ], TEST_LOCATION );
END_TEST;
}
// compute the points in the CFG reachable from the entry point.
void GetEntryReachable(BlockCFG *cfg)
{
// worklist items are reachable points whose outgoing edges have
// not been examined
Vector<PPoint> worklist;
PPoint entry = cfg->GetEntryPoint();
entry_reach_table->Insert(entry);
worklist.PushBack(entry);
while (!worklist.Empty()) {
PPoint back = worklist.Back();
worklist.PopBack();
const Vector<PEdge*>& outgoing = cfg->GetOutgoingEdges(back);
for (size_t oind = 0; oind < outgoing.Size(); oind++) {
PEdge *edge = outgoing[oind];
PPoint next = edge->GetTarget();
// already did this target
if (entry_reach_table->Lookup(next))
continue;
entry_reach_table->Insert(next);
worklist.PushBack(next);
}
}
}
int main()
{
Vector <Student>students;
Vector vector;
vector.PushBack(5);
vector.PushBack(3);
vector.PushBack(1);
vector.PushBack(8);
cout << "Is empty: " << vector.IsEmpty() << endl;
cout << "Size: " << vector.Size() << endl;
cout << "Vector elements: ";
for (int i = 0; i < vector.Size(); i++)
cout << vector.GetAt(i) << ", ";
cout << endl;
vector.Sort();
cout << "Increasing vector: ";
for (int i = 0; i < vector.Size(); i++)
cout << vector.GetAt(i) << ", ";
cout << endl;
cout << "Is sorted: " << vector.IsSorted() << endl;
vector.Sort(false);
cout << "Decreasing vector: ";
for (int i = 0; i < vector.Size(); i++)
cout << vector.GetAt(i) << ", ";
cout << endl;
cout << "Is sorted: " << vector.IsSorted() << endl;
return 0;
}
int UtcDaliVectorPushBack(void)
{
tet_infoline( "Testing Dali::Vector< int* >PushBack(Element)" );
Vector<unsigned int> vector;
DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, vector.Capacity(), TEST_LOCATION );
vector.Reserve( 2u );
DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( 2u, vector.Capacity(), TEST_LOCATION );
vector.PushBack( 0u );
vector.PushBack( 1u );
vector.PushBack( 2u );
DALI_TEST_EQUALS( 3u, vector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( 6u, vector.Capacity(), TEST_LOCATION );
vector.PushBack( 3u );
DALI_TEST_EQUALS( 4u, vector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( 6u, vector.Capacity(), TEST_LOCATION );
DALI_TEST_EQUALS( 0u, vector[0u], TEST_LOCATION );
DALI_TEST_EQUALS( 1u, vector[1u], TEST_LOCATION );
DALI_TEST_EQUALS( 2u, vector[2u], TEST_LOCATION );
DALI_TEST_EQUALS( 3u, vector[3u], TEST_LOCATION );
END_TEST;
}
int UtcDaliVectorIterate(void)
{
tet_infoline("Testing Dali::Vector<float>::Begin");
Vector< float > floatvector;
DALI_TEST_EQUALS( ZERO, floatvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, floatvector.Capacity(), TEST_LOCATION );
floatvector.PushBack( 0.9f );
floatvector.PushBack( 1.1f );
floatvector.PushBack( 1.2f );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), floatvector.Count(), TEST_LOCATION );
Vector< float >::Iterator iter = floatvector.Begin();
int index = 0;
for( ; iter != floatvector.End(); ++iter, ++index )
{
std::cout << "value " << *iter << std::endl;
DALI_TEST_EQUALS( *iter, floatvector[ index ], TEST_LOCATION );
}
DALI_TEST_EQUALS( 3, index, TEST_LOCATION );
iter = std::find( floatvector.Begin(), floatvector.End(), 1.1f );
DALI_TEST_EQUALS( 1.1f, *iter, TEST_LOCATION );
floatvector.Clear();
iter = std::find( floatvector.Begin(), floatvector.End(), 1.1f );
DALI_TEST_EQUALS( floatvector.End(), iter, TEST_LOCATION );
END_TEST;
}
int UtcDaliVectorPair(void)
{
tet_infoline("Testing Dali::Vector< std::pair< int, float > >");
Vector< std::pair< int, float > > pairvector;
DALI_TEST_EQUALS( ZERO, pairvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, pairvector.Capacity(), TEST_LOCATION );
pairvector.PushBack( std::make_pair( 5, 0.1f ) );
pairvector.PushBack( std::make_pair( 3, 0.2f ) );
pairvector.PushBack( std::make_pair( 4, 0.3f ) );
pairvector.PushBack( std::make_pair( 1, 0.4f ) );
pairvector.PushBack( std::make_pair( 2, 0.5f ) );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(5), pairvector.Count(), TEST_LOCATION );
Vector< std::pair< int, float > >::Iterator iter = pairvector.Begin();
int index = 0;
for( ; iter != pairvector.End(); ++iter, ++index )
{
std::cout << "pair " << (*iter).first << ":" << (*iter).second << std::endl;
DALI_TEST_EQUALS( (*iter).first, pairvector[ index ].first, TEST_LOCATION );
DALI_TEST_EQUALS( (*iter).second, pairvector[ index ].second, TEST_LOCATION );
}
END_TEST;
}
// marks the points in cfg which are isomorphic to points in the loop_cfg
// invoked by cfg at the specified edge. code in a syntactic loop body
// will be reflected in CFGs for both the loop and its parent if it may
// reach both the recursive loop edge and a loop exit point. this common
// code will be isomorphic between the two CFGs.
void GetLoopIsomorphicPoints(BlockCFG *cfg, PEdge *loop_edge,
BlockCFG *loop_cfg)
{
// mapping from points in cfg to isomorphic points in loop_cfg.
PPointListHash remapping;
// worklist items are isomorphic points whose outgoing edges have not
// been examined.
Vector<PPoint> worklist;
PPoint target = loop_edge->GetTarget();
remapping.Insert(target, loop_cfg->GetEntryPoint());
cfg->AddLoopIsomorphic(target);
worklist.PushBack(target);
while (!worklist.Empty()) {
PPoint cfg_point = worklist.Back();
worklist.PopBack();
PPoint loop_point = remapping.LookupSingle(cfg_point);
const Vector<PEdge*> &cfg_outgoing =
cfg->GetOutgoingEdges(cfg_point);
const Vector<PEdge*> &loop_outgoing =
loop_cfg->GetOutgoingEdges(loop_point);
for (size_t eind = 0; eind < cfg_outgoing.Size(); eind++) {
PEdge *edge = cfg_outgoing[eind];
PPoint target = edge->GetTarget();
// check for an existing remapping entry. some isomorphic points have
// multiple incoming edges. we don't need to check all such incoming
// edges; if any edge is isomorphic, they all will be.
if (remapping.Lookup(target, false))
continue;
// look for an equivalent outgoing edge from the loop.
PPoint loop_target = 0;
for (size_t lind = 0; lind < loop_outgoing.Size(); lind++) {
PEdge *loop_edge = loop_outgoing[lind];
if (PEdge::CompareInner(edge, loop_edge) == 0) {
loop_target = loop_edge->GetTarget();
break;
}
}
if (!loop_target) {
Assert(edge->IsAssume());
continue;
}
remapping.Insert(target, loop_target);
cfg->AddLoopIsomorphic(target);
worklist.PushBack(target);
}
}
}
int UtcDaliVectorInsert02(void)
{
tet_infoline("Testing Dali::Vector<char>::Insert(Iterator,Iterator,Iterator)");
Vector< char > vector;
DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, vector.Capacity(), TEST_LOCATION );
vector.PushBack( 1 );
vector.PushBack( 2 );
vector.PushBack( 3 );
vector.PushBack( 4 );
vector.PushBack( 5 );
Vector< char > vector2;
DALI_TEST_EQUALS( ZERO, vector2.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, vector2.Capacity(), TEST_LOCATION );
vector2.PushBack( 6 );
vector2.PushBack( 7 );
vector2.PushBack( 8 );
vector2.PushBack( 9 );
vector2.PushBack( 10 );
// Test insert at end
vector.Insert( vector.End(), vector2.Begin(), vector2.Begin() + 1u );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(6), vector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 0 ], 1, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 1 ], 2, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 2 ], 3, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 3 ], 4, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 4 ], 5, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 5 ], 6, TEST_LOCATION );
// Test insert at begin
vector.Insert( vector.Begin(), vector2.Begin()+1, vector2.Begin() + 2u );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(7), vector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 0 ], 7, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 1 ], 1, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 2 ], 2, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 3 ], 3, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 4 ], 4, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 5 ], 5, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 6 ], 6, TEST_LOCATION );
// Test insert in the middle
vector.Insert( vector.Begin() + 3, vector2.Begin()+3, vector2.End() );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(9), vector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 0 ], 7, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 1 ], 1, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 2 ], 2, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 3 ], 9, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 4 ], 10, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 5 ], 3, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 6 ], 4, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 7 ], 5, TEST_LOCATION );
DALI_TEST_EQUALS( vector[ 8 ], 6, TEST_LOCATION );
END_TEST;
}
// fill in the body of loophead. points in the body are those which
// are reachable from loophead over non-backedges, and which themselves
// reach a backedge for loophead. note that in the case of loop nesting,
// a point may be contained in the body of multiple loops.
// if any irreducible edges are found (edges incoming to a body point
// other than loophead whose source is not in the body), those edges
// are added to irreducible_edges
void GetLoopBody(BlockCFG *cfg, PPoint loophead,
Vector<PEdge*> *irreducible_edges)
{
Vector<PPoint> *body_list = body_list_table->Lookup(loophead, true);
Assert(body_list->Empty());
// worklist items are points which reach a loop backedge but whose
// incoming edges have not yet been examined.
Vector<PPoint> worklist;
const Vector<PEdge*> &head_incoming = cfg->GetIncomingEdges(loophead);
for (size_t iind = 0; iind < head_incoming.Size(); iind++) {
PEdge *edge = head_incoming[iind];
PPoint source = edge->GetSource();
if (backedge_table->Lookup(edge)) {
Assert(reach_table->Lookup(PPointPair(loophead, source)));
if (!body_table->Insert(PPointPair(loophead, source))) {
body_list->PushBack(source);
worklist.PushBack(source);
}
}
}
// this should only be called on loops that have actual backedges
Assert(!worklist.Empty());
while (!worklist.Empty()) {
PPoint back = worklist.Back();
worklist.PopBack();
if (back == loophead)
continue;
const Vector<PEdge*> &incoming = cfg->GetIncomingEdges(back);
for (size_t iind = 0; iind < incoming.Size(); iind++) {
PEdge *edge = incoming[iind];
PPoint source = edge->GetSource();
if (reach_table->Lookup(PPointPair(loophead, source))) {
if (!body_table->Insert(PPointPair(loophead, source))) {
body_list->PushBack(source);
worklist.PushBack(source);
}
}
else if (entry_reach_table->Lookup(source)) {
// the source is not reachable from the loophead.
// this is an irreducible edge.
irreducible_edges->PushBack(edge);
}
}
}
}
TEST(Vector, PushBack) {
Vector<int> v;
v.PushBack(12345);
EXPECT_FALSE(v.IsEmpty());
EXPECT_EQ(1U, v.GetCount());
EXPECT_EQ(12345, v[0]);
}
void PrepassStage::OITInitPass(RenderingCamera * Camera, Spatial * spatial, RenderQueue* renderQueue, WorkQueue * Queue, Vector<OsEvent*>& Events) {
RenderView * renderview = RenderView::Create();
RenderViews.PushBack(renderview);
renderview->Camera = Camera;
renderview->Type = R_STAGE_OIT;
renderview->Index = 0;
renderview->Queue = renderQueue;
renderview->Parameters.Clear();
// set render target
renderview->TargetCount = 0;
renderview->Targets[0] = -1; // Context->GetRenderTarget("gPostBuffer");
renderview->Depth = Depth;
renderview->ClearDepth = 0;
renderview->ClearTargets = 0;
// 4. submit to workqueue
int count = 1;
while (count--) {
CullingTask * task = CullingTask::Create();
task->renderview = renderview;
task->spatial = spatial;
task->Context = Context;
task->ObjectType = Node::TRANS;
Queue->QueueTask(task);
}
Events.PushBack(renderview->Event);
}
void PrepassStage::PrePass(RenderingCamera * Camera, Spatial * spatial, RenderQueue* renderQueue, WorkQueue * Queue, Vector<OsEvent*>& Events) {
RenderView * renderview = RenderView::Create();
RenderViews.PushBack(renderview);
renderview->Camera = Camera;
renderview->Depth = 0;
renderview->Type = R_STAGE_PREPASSS;
renderview->Index = 0;
renderview->Queue = renderQueue;
// set render target
renderview->TargetCount = 4;
renderview->Targets[0] = Targets[0];
renderview->Targets[1] = Targets[1];
renderview->Targets[2] = Targets[3];
renderview->Targets[3] = Targets[4];
renderview->Depth = Depth;
renderview->Parameters.Clear();
renderview->ClearDepth = 1;
renderview->ClearTargets = 1;
// 4. submit to workqueue
int count = 1;
while (count--) {
CullingTask * task = CullingTask::Create();
task->renderview = renderview;
task->spatial = spatial;
task->Context = Context;
task->ObjectType = Node::RENDEROBJECT;
Queue->QueueTask(task);
}
Events.PushBack(renderview->Event);
}
XdbInfo& GetDatabaseInfo(const uint8_t *name, bool do_create)
{
Assert(!cleared_databases);
String *name_str = String::Make((const char*)name);
for (size_t dind = 0; dind < databases.Size(); dind++) {
if (databases[dind].name == name_str) {
XdbInfo &info = databases[dind];
// create the database if we previously did a non-create access.
if (do_create && !info.xdb->Exists()) {
info.xdb->Create();
if (info.xdb->HasError()) {
logout << "ERROR: Corrupt database " << (const char*) name << endl;
info.xdb->Truncate();
}
}
return info;
}
}
Xdb *xdb = new Xdb((const char*) name, do_create, false, false);
if (xdb->HasError()) {
logout << "ERROR: Corrupt database " << (const char*) name << endl;
xdb->Truncate();
}
XdbInfo info;
info.name = name_str;
info.xdb = xdb;
databases.PushBack(info);
return databases.Back();
}
O3DGCErrorCode LoadUIntAC(Vector<long> & data,
const unsigned long M,
const BinaryStream & bstream,
unsigned long & iterator)
{
unsigned long sizeSize = bstream.ReadUInt32Bin(iterator) - 12;
unsigned long size = bstream.ReadUInt32Bin(iterator);
if (size == 0)
{
return O3DGC_OK;
}
long minValue = bstream.ReadUInt32Bin(iterator);
unsigned char * buffer = 0;
bstream.GetBuffer(iterator, buffer);
iterator += sizeSize;
data.Allocate(size);
Arithmetic_Codec acd;
acd.set_buffer(sizeSize, buffer);
acd.start_decoder();
Adaptive_Data_Model mModelValues(M+1);
#ifdef DEBUG_VERBOSE
printf("-----------\nsize %i\n", size);
fprintf(g_fileDebugTF, "size %i\n", size);
#endif //DEBUG_VERBOSE
for(unsigned long i = 0; i < size; ++i)
{
data.PushBack(acd.decode(mModelValues)+minValue);
#ifdef DEBUG_VERBOSE
printf("%i\t%i\n", i, data[i]);
fprintf(g_fileDebugTF, "%i\t%i\n", i, data[i]);
#endif //DEBUG_VERBOSE
}
return O3DGC_OK;
}
O3DGCErrorCode LoadBinAC(Vector<long> & data,
const BinaryStream & bstream,
unsigned long & iterator)
{
size_t sizeSize = bstream.ReadUInt32Bin(iterator) - 8;
size_t size = bstream.ReadUInt32Bin(iterator);
if (size == 0)
{
return O3DGC_OK;
}
unsigned char * buffer = 0;
bstream.GetBuffer(iterator, buffer);
iterator += sizeSize;
data.Allocate(size);
Arithmetic_Codec acd;
acd.set_buffer(sizeSize, buffer);
acd.start_decoder();
Adaptive_Bit_Model bModel;
#ifdef DEBUG_VERBOSE
printf("-----------\nsize %i\n", size);
fprintf(g_fileDebugTF, "size %i\n", size);
#endif //DEBUG_VERBOSE
for(size_t i = 0; i < size; ++i)
{
data.PushBack(acd.decode(bModel));
#ifdef DEBUG_VERBOSE
printf("%i\t%i\n", i, data[i]);
fprintf(g_fileDebugTF, "%i\t%i\n", i, data[i]);
#endif //DEBUG_VERBOSE
}
return O3DGC_OK;
}
void handle_connect(int sockfd, short, void*)
{
logout << "Received connection." << endl << flush;
int newfd = accept(sockfd, NULL, 0);
if (newfd == -1) {
logout << "ERROR: accept() failure: " << errno << endl;
return;
}
ConnectData *cdata = new ConnectData();
connections.PushBack(cdata);
cdata->live = true;
cdata->fd = newfd;
event_set(&cdata->ev, newfd, EV_READ | EV_PERSIST,
handle_event, (void*) (connections.Size() - 1));
int ret = event_add(&cdata->ev, NULL);
if (ret == -1) {
logout << "ERROR: event_add() failure: " << errno << endl;
delete cdata;
return;
}
}
Geometry BubbleEmitter::CreateGeometry( unsigned int numOfPatch )
{
unsigned int numVertex = numOfPatch*4u;
std::vector<Vertex> vertexData;
vertexData.reserve( numVertex );
unsigned int numIndex = numOfPatch*6u;
Vector<unsigned int> indexData;
indexData.Reserve( numIndex );
for(unsigned int i = 0; i < numOfPatch; i++)
{
float curSize = RandomRange(mBubbleSizeRange.x, mBubbleSizeRange.y, mRandomSeed);
float index = static_cast<float>( i );
vertexData.push_back( Vertex( index, Vector2(0.f,0.f), Vector2(0.f,0.f) ) );
vertexData.push_back( Vertex( index, Vector2(0.f,curSize), Vector2(0.f,1.f) ) );
vertexData.push_back( Vertex( index, Vector2(curSize,curSize), Vector2(1.f,1.f) ) );
vertexData.push_back( Vertex( index, Vector2(curSize,0.f), Vector2(1.f,0.f) ) );
unsigned int idx = index * 4;
indexData.PushBack( idx );
indexData.PushBack( idx+1 );
indexData.PushBack( idx+2 );
indexData.PushBack( idx );
indexData.PushBack( idx+2 );
indexData.PushBack( idx+3 );
}
Property::Map vertexFormat;
vertexFormat["aIndex"] = Property::FLOAT;
vertexFormat["aPosition"] = Property::VECTOR2;
vertexFormat["aTexCoord"] = Property::VECTOR2;
PropertyBuffer vertices = PropertyBuffer::New( vertexFormat, numVertex );
vertices.SetData( &vertexData[0] );
Property::Map indexFormat;
indexFormat["indices"] = Property::INTEGER;
PropertyBuffer indices = PropertyBuffer::New( indexFormat, numIndex );
indices.SetData( &indexData[0] );
Geometry geometry = Geometry::New();
geometry.AddVertexBuffer( vertices );
geometry.SetIndexBuffer( indices );
return geometry;
}
TEST(Vector, PushBack2) {
const int kMaxCount = 500;
Vector<int> v;
for (int n = 0; n < kMaxCount; ++n)
v.PushBack(n * 100);
EXPECT_FALSE(v.IsEmpty());
EXPECT_EQ(static_cast<size_t>(kMaxCount), v.GetCount());
}
int UtcDaliVectorIntCopy(void)
{
tet_infoline("Testing Dali::Vector<int>::Copy");
Vector< int > intvector;
DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
intvector.PushBack( 99 );
intvector.PushBack( 11 );
intvector.PushBack( 34 );
// copy construct
Vector< int > intvector2( intvector );
DALI_TEST_EQUALS( intvector2.Count(), intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( intvector2.Capacity(), intvector.Capacity(), TEST_LOCATION );
DALI_TEST_EQUALS( intvector2[ 0 ], intvector[ 0 ], TEST_LOCATION );
DALI_TEST_EQUALS( intvector2[ 1 ], intvector[ 1 ], TEST_LOCATION );
DALI_TEST_EQUALS( intvector2[ 2 ], intvector[ 2 ], TEST_LOCATION );
// assign
Vector< int > intvector3;
DALI_TEST_EQUALS( ZERO, intvector3.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, intvector3.Capacity(), TEST_LOCATION );
intvector2 = intvector3;
DALI_TEST_EQUALS( intvector2.Count(), intvector3.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( intvector2.Capacity(), intvector3.Capacity(), TEST_LOCATION );
// copy empty
Vector< int > intvector4;
intvector4.Reserve( 100 );
DALI_TEST_EQUALS( ZERO, intvector4.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(100), intvector4.Capacity(), TEST_LOCATION );
intvector3 = intvector4;
DALI_TEST_EQUALS( ZERO, intvector3.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(100), intvector3.Capacity(), TEST_LOCATION );
// self copy
intvector4 = intvector4;
DALI_TEST_EQUALS( ZERO, intvector4.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(100), intvector4.Capacity(), TEST_LOCATION );
END_TEST;
}
int UtcDaliVectorIntSwap(void)
{
tet_infoline("Testing Dali::Vector<int>::Swap");
Vector< int > intvector;
DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
intvector.PushBack( 11 );
intvector.PushBack( 22 );
intvector.PushBack( 33 );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), intvector.Count(), TEST_LOCATION );
Vector< int > intvector2;
DALI_TEST_EQUALS( ZERO, intvector2.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, intvector2.Capacity(), TEST_LOCATION );
intvector2.Swap( intvector );
DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), intvector2.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( 11, intvector2[ 0 ], TEST_LOCATION );
DALI_TEST_EQUALS( 22, intvector2[ 1 ], TEST_LOCATION );
DALI_TEST_EQUALS( 33, intvector2[ 2 ], TEST_LOCATION );
intvector.PushBack( 99 );
intvector.PushBack( 88 );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), intvector.Count(), TEST_LOCATION );
intvector.Swap( intvector2 );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), intvector2.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( 99, intvector2[ 0 ], TEST_LOCATION );
DALI_TEST_EQUALS( 88, intvector2[ 1 ], TEST_LOCATION );
DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( 11, intvector[ 0 ], TEST_LOCATION );
DALI_TEST_EQUALS( 22, intvector[ 1 ], TEST_LOCATION );
DALI_TEST_EQUALS( 33, intvector[ 2 ], TEST_LOCATION );
Vector< int > empty;
intvector.Swap( empty );
DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
END_TEST;
}
TEST(Vector, IndexOf) {
const int kMaxCount = 500;
Vector<int> v;
for (int n = 0; n < kMaxCount; ++n)
v.PushBack(n * 100);
for (int n = 0; n < kMaxCount; ++n) {
TEST_TEXT << "Checking v.IndexOf(" << n * 100 << ")";
EXPECT_EQ(n, v.IndexOf(n * 100));
}
}
TEST(Vector, At) {
const int kMaxCount = 500;
Vector<int> v;
for (int n = 0; n < kMaxCount; ++n)
v.PushBack(n * 100);
for (int n = 0; n < kMaxCount; ++n) {
TEST_TEXT << "Checking v[" << n << "]";
EXPECT_EQ(n * 100, v[n]);
}
}
// get the set of points reachable from loophead over paths
// that do not go through a backedge. if loophead itself is
// reachable, it is irreducible and those new edges to it are added
// as backedges. return value is true iff the loop is irreducible.
bool GetLoopReachable(BlockCFG *cfg, PPoint loophead)
{
// worklist items are points in reach_table whose outgoing edges
// have not been examined
Vector<PPoint> worklist;
if (!entry_reach_table->Lookup(loophead))
return false;
reach_table->Insert(PPointPair(loophead, loophead));
worklist.PushBack(loophead);
bool found_irreducible = false;
while (!worklist.Empty()) {
PPoint back = worklist.Back();
worklist.PopBack();
const Vector<PEdge*>& outgoing = cfg->GetOutgoingEdges(back);
for (size_t oind = 0; oind < outgoing.Size(); oind++) {
PEdge *edge = outgoing[oind];
PPoint next = edge->GetTarget();
if (backedge_table->Lookup(edge))
continue;
if (next == loophead) {
// we're in an irreducible loop. add the new edge to backedge_table.
backedge_table->Insert(edge);
found_irreducible = true;
continue;
}
if (!reach_table->Insert(PPointPair(loophead, next)))
worklist.PushBack(next);
}
}
return found_irreducible;
}
int UtcDaliVectorVector3P(void)
{
tet_infoline("Testing Dali::Vector< Vector3 >");
Vector< Vector3 > classvector;
DALI_TEST_EQUALS( ZERO, classvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, classvector.Capacity(), TEST_LOCATION );
classvector.PushBack( Vector3() );
DALI_TEST_EQUALS( 1u, classvector.Count(), TEST_LOCATION );
DALI_TEST_GREATER( classvector.Capacity(), ZERO, TEST_LOCATION );
classvector.PushBack( Vector3( 0.1f, 0.2f, 0.3f ) );
DALI_TEST_EQUALS( 2u, classvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( Vector3(), classvector[ 0 ], TEST_LOCATION );
DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), classvector[ 1 ], TEST_LOCATION );
tet_result(TET_PASS); // for now
END_TEST;
}
O3DGCErrorCode LoadIntData(Vector<long> & data,
const BinaryStream & bstream,
unsigned long & iterator)
{
bstream.ReadUInt32ASCII(iterator);
const unsigned long size = bstream.ReadUInt32ASCII(iterator);
data.Allocate(size);
data.Clear();
for(size_t i = 0; i < size; ++i)
{
data.PushBack(bstream.ReadIntASCII(iterator));
}
return O3DGC_OK;
}
int UtcDaliVectorMatrixP(void)
{
tet_infoline("Testing Dali::Vector< Matrix >");
Vector< Matrix > classvector;
DALI_TEST_EQUALS( ZERO, classvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( ZERO, classvector.Capacity(), TEST_LOCATION );
classvector.PushBack( Matrix() );
DALI_TEST_EQUALS( 1u, classvector.Count(), TEST_LOCATION );
DALI_TEST_GREATER( classvector.Capacity(), ZERO, TEST_LOCATION );
classvector.PushBack( Matrix::IDENTITY );
DALI_TEST_EQUALS( 2u, classvector.Count(), TEST_LOCATION );
DALI_TEST_EQUALS( Matrix(), classvector[ 0 ], TEST_LOCATION );
DALI_TEST_EQUALS( Matrix::IDENTITY, classvector[ 1 ], TEST_LOCATION );
tet_result(TET_PASS); // for now
END_TEST;
}
void ProximityComponent::UpdateContainment(Vector<uint64_t> &sceneNodesEntered, Vector<uint64_t> &sceneNodesLeft)
{
SortedVector<uint64_t> sceneNodesLeaving(this->sceneNodesInsideVolume);
ProximityComponent::Iterator i(*this);
while (i)
{
if (i.otherNode != &this->GetNode())
{
assert(i.otherNode != nullptr);
{
auto otherNodeID = i.otherNode->GetID();
if (!this->sceneNodesInsideVolume.Exists(otherNodeID))
{
this->sceneNodesInsideVolume.Insert(otherNodeID);
sceneNodesEntered.PushBack(otherNodeID);
}
else
{
sceneNodesLeaving.RemoveFirstOccuranceOf(otherNodeID);
}
}
}
++i;
}
// At this point we'll have a list of nodes that have left the volume. We need to copies these over to 'sceneNodesLeft'.
for (size_t j = 0; j < sceneNodesLeaving.count; ++j)
{
sceneNodesLeft.PushBack(sceneNodesLeaving[j]);
this->sceneNodesInsideVolume.RemoveFirstOccuranceOf(sceneNodesLeaving[j]);
}
}
TEST(Vector, PopFirst) {
const int kMaxCount = 500;
Vector<int> v;
for (int n = 0; n < kMaxCount; ++n)
v.PushBack(n * 100);
for (int n = 0; n < kMaxCount; ++n) {
int first = v.PopFirst();
TEST_TEXT << "Checking " << n << "-th PopFirst()";
EXPECT_EQ(n * 100, first);
EXPECT_EQ(kMaxCount - 1 - n, v.GetCount());
}
EXPECT_EQ(0u, v.GetCount());
EXPECT_TRUE(v.IsEmpty());
}
O3DGCErrorCode LoadIntACEGC(Vector<long> & data,
const unsigned long M,
const BinaryStream & bstream,
unsigned long & iterator)
{
size_t sizeSize = bstream.ReadUInt32Bin(iterator) - 12;
size_t size = bstream.ReadUInt32Bin(iterator);
if (size == 0)
{
return O3DGC_OK;
}
long minValue = bstream.ReadUInt32Bin(iterator) - O3DGC_MAX_LONG;
unsigned char * buffer = 0;
bstream.GetBuffer(iterator, buffer);
iterator += sizeSize;
data.Allocate(size);
Arithmetic_Codec acd;
acd.set_buffer(sizeSize, buffer);
acd.start_decoder();
Adaptive_Data_Model mModelValues(M+2);
Static_Bit_Model bModel0;
Adaptive_Bit_Model bModel1;
unsigned long value;
#ifdef DEBUG_VERBOSE
printf("-----------\nsize %i\n", size);
fprintf(g_fileDebugTF, "size %i\n", size);
#endif //DEBUG_VERBOSE
for(size_t i = 0; i < size; ++i)
{
value = acd.decode(mModelValues);
if ( value == M)
{
value += acd.ExpGolombDecode(0, bModel0, bModel1);
}
data.PushBack(value + minValue);
#ifdef DEBUG_VERBOSE
printf("%i\t%i\n", i, data[i]);
fprintf(g_fileDebugTF, "%i\t%i\n", i, data[i]);
#endif //DEBUG_VERBOSE
}
#ifdef DEBUG_VERBOSE
fflush(g_fileDebugTF);
#endif //DEBUG_VERBOSE
return O3DGC_OK;
}
TEST(Vector, RemoveAt) {
const int kMaxCount = 500;
for (size_t k = 0; k < kMaxCount; ++k) {
Vector<int> v;
for (int n = 0; n < kMaxCount; ++n)
v.PushBack(n * 100);
v.RemoveAt(k);
EXPECT_EQ(kMaxCount - 1, v.GetCount());
for (int n = 0; n < kMaxCount - 1; ++n) {
TEST_TEXT << "Checking v[" << n << "]";
int expected = (n < k) ? (n * 100) : ((n + 1) * 100);
EXPECT_EQ(expected, v[n]);
}
}
}
