main()
{
char s1[100] = "johnny\tate\tlunch\n";
char s2[100] = "johnny\tate\tlunch\n";
char s3[100] = "johnny\tate\tlunch\n";
char s4[100] = "johnny\tate\tlunch\n";
char s5[100] = "johnny\tate\tlunch\n";
detab(s1, 100, 4);
should(s1, "johnny__ate_lunch\n");
detab(s2, 100, 5);
should(s2, "johnny____ate__lunch\n");
detab(s3, 100, 6);
should(s3, "johnny______ate___lunch\n");
detab(s4, 100, 7);
should(s4, "johnny_ate____lunch\n");
detab(s5, 100, 8);
should(s5, "johnny__ate_____lunch\n");
return 0;
}
void test_update_players_from_compress(TestContext* tc)
{
int assertion;
int compress;
PixelUpdate pu;
//Create maze
Maze maze;
maze_build_from_file(&maze,"test.map");
//Initialize a dummy player
Player test_player;
player_init(&test_player);
test_player.cell = &maze.get[0][0];
test_player.id = 0;
test_player.state = PLAYER_FREE;
test_player.team = TEAM_RED;
//Compress Player
compress_player(&test_player,&compress,PLAYER_ADDED);
//Update Maze based on compressed player
update_players(1,&compress,&maze,&pu);
assertion = (maze.get[0][0].player)==(&maze.players[TEAM_RED].at[0]);
should("match the address of the player stored in the cell to the address of the player in the plist",assertion,tc);
assertion = (maze.get[0][0].player->state)==(PLAYER_FREE);
should("match the player's state before the compress",assertion,tc);
}
static void
test(int pristine)
{
struct archive* a = archive_write_new();
int known_option_rv = pristine ? ARCHIVE_FAILED : ARCHIVE_OK;
if (!pristine) {
archive_write_add_filter_gzip(a);
archive_write_set_format_iso9660(a);
}
/* NULL and "" denote `no option', so they're ok no matter
* what, if any, formats are registered */
should(a, ARCHIVE_OK, NULL, NULL, NULL);
should(a, ARCHIVE_OK, "", "", "");
/* unknown modules and options */
should(a, ARCHIVE_FAILED, "fubar", "snafu", NULL);
should(a, ARCHIVE_FAILED, "fubar", "snafu", "betcha");
/* unknown modules and options */
should(a, ARCHIVE_FAILED, NULL, "snafu", NULL);
should(a, ARCHIVE_FAILED, NULL, "snafu", "betcha");
/* ARCHIVE_OK with iso9660 loaded, ARCHIVE_WARN otherwise */
should(a, known_option_rv, "iso9660", "joliet", NULL);
should(a, known_option_rv, "iso9660", "joliet", NULL);
should(a, known_option_rv, NULL, "joliet", NULL);
should(a, known_option_rv, NULL, "joliet", NULL);
archive_write_free(a);
}
Result validate(const File &file) {
return validator({
could(file, &File::isOpen, notFalse(), {
must(file, &File::createdAt, notFalse(), "date is not set!"),
should(file, &File::version, notEmpty(), "version is not set!"),
should(file, &File::format, notEmpty(), "format is not set!"),
should(file, &File::location, notEmpty(), "location is not set!") })
});
}
void client_wait_for_event(Blocking_Helper *bh,TestContext* tc)
{
int assertion;
assertion = client_maze_lock(bh)==0;
should("lock the maze from the waiting thread",assertion,tc);
while (bh->maze->current_game_state !=GAME_STATE_ACTIVE)
{
assertion = client_maze_cond_wait(bh)==0;
should("wait and recieve signal for condition variable",assertion,tc);
}
assertion = client_maze_unlock(bh)==0;
should("unlock client maze from waiting thread",assertion,tc);
pthread_exit(NULL);
}
void client_signal_update(Blocking_Helper *bh,TestContext* tc)
{
int assertion;
assertion = client_maze_lock(bh)==0;
should("lock the maze from signaling thread",assertion,tc);
bh->maze->current_game_state = GAME_STATE_ACTIVE;
assertion = client_maze_signal(bh)==0;
should("signal the other thread for a change in condition",assertion,tc);
assertion = client_maze_unlock(bh)==0;
should("unlock client maze from signaling thread",assertion,tc);
pthread_exit(NULL);
}
void test_get_compress_from_body(TestContext* tc)
{
int ii,assertion;
char buffer[20];
char output[1000];
//Init Client and Map
Client C;
client_init(&C,NULL);
//Compress random things
Proto_Session* s;
Proto_Client *proto_client = C.ph;
s = &(proto_client->rpc_session);
for(ii = 0;ii<20;ii++)
{
//I have to use this function because no function in lib will write
//to the receive buffer
test_marshall_int_read_buffer(s,ii);
}
//Get the compress
int result;
int offset;
offset = 0;
for(ii = 0;ii<20;ii++)
{
offset = get_compress_from_body(C.ph,offset,1,&result);
assertion = ((result)==ii);
sprintf(buffer,"%d",ii);
bzero(output,sizeof(output));
strcat(output,"unmarshall the number: ");
strcat(output,buffer);
should(output,assertion,tc);
}
}
Result validate(const DataArray &data_array) {
Result result_base = validate_entity_with_sources(data_array);
Result result = validator({
must(data_array, &DataArray::dataType, notEqual<DataType>(DataType::Nothing), "data type is not set!"),
must(data_array, &DataArray::dimensionCount, isEqual<size_t>(data_array.dataExtent().size()), "data dimensionality does not match number of defined dimensions!", {
could(data_array, &DataArray::dimensions, notEmpty(), {
must(data_array, &DataArray::dimensions, dimTicksMatchData(data_array), "in some of the Range dimensions the number of ticks differs from the number of data entries along the corresponding data dimension!"),
must(data_array, &DataArray::dimensions, dimLabelsMatchData(data_array), "in some of the Set dimensions the number of labels differs from the number of data entries along the corresponding data dimension!") }) }),
could(data_array, &DataArray::unit, notFalse(), {
should(data_array, &DataArray::unit, isValidUnit(), "Unit is not SI or composite of SI units.") }),
could(data_array, &DataArray::polynomCoefficients, notEmpty(), {
should(data_array, &DataArray::expansionOrigin, notFalse(), "polynomial coefficients for calibration are set, but expansion origin is missing!") }),
could(data_array, &DataArray::expansionOrigin, notFalse(), {
should(data_array, &DataArray::polynomCoefficients, notEmpty(), "expansion origin for calibration is set, but polynomial coefficients are missing!") })
});
return result.concat(result_base);
}
Result validate(const SampledDimension &sampled_dim) {
return validator({
must(sampled_dim, &SampledDimension::index, notSmaller(1), "index is not set to valid value (size_t > 0)!"),
must(sampled_dim, &SampledDimension::samplingInterval, isGreater(0), "samplingInterval is not set to valid value (> 0)!"),
must(sampled_dim, &SampledDimension::dimensionType, isEqual<DimensionType>(DimensionType::Sample), "dimension type is not correct!"),
could(sampled_dim, &SampledDimension::offset, notFalse(), {
should(sampled_dim, &SampledDimension::unit, isAtomicUnit(), "offset is set, but no valid unit set!") }),
could(sampled_dim, &SampledDimension::unit, notFalse(), {
must(sampled_dim, &SampledDimension::unit, isAtomicUnit(), "Unit is set but not an atomic SI. Note: So far composite units are not supported!") })
});
}
Result validate(const Property &property) {
Result result_base = validate_entity(property);
Result result = validator({
must(property, &Property::name, notEmpty(), "name is not set!"),
could(property, &Property::valueCount, notFalse(), {
should(property, &Property::unit, notFalse(), "values are set, but unit is missing!") }),
could(property, &Property::unit, notFalse(), {
must(property, &Property::unit, isValidUnit(), "Unit is not SI or composite of SI units.") })
// TODO: dataType to be tested too?
});
return result.concat(result_base);
}
vector<LPEdge> sampleLRTInverse(vector<ModEdge> lGraph, bool silent)
{
vector<LPEdge> tree;
while (lGraph.size() != 0)
{
ModEdge e = lGraph.back();
double p = prob(lGraph, e);
if (should(p))
{
lGraph = contractEdge(lGraph, e);
tree.push_back(LPEdge(e.orig0, e.orig1, e.weight));
}
else
lGraph.pop_back();
}
return tree;
}
vector<LPEdge> sampleLRTBig(vector<ModEdge> lGraph, bool silent)
{
vector<LPEdge> tree;
while (lGraph.size() != 0)
{
ModEdge e = lGraph.back();
double denom = cofactorLog(wLaplacianNew(lGraph));
vector<ModEdge> cGraph = contractEdgeNew(lGraph, e);
double num = cofactorLog(wLaplacianNew(cGraph));
double prob = e.weight * exp(num - denom);
if (should(prob) || lGraph.size() == 1)
{
lGraph = cGraph;
LPEdge outEdge(e.orig0, e.orig1, e.weight);
tree.push_back(outEdge);
}
else
{
lGraph.pop_back();
}
}
return tree;
}
static void
test(int pristine)
{
struct archive* a = archive_read_new();
if (!pristine)
archive_read_support_filter_all(a);
should(a, ARCHIVE_OK, NULL, NULL, NULL);
should(a, ARCHIVE_OK, "", "", "");
should(a, ARCHIVE_FAILED, NULL, "fubar", NULL);
should(a, ARCHIVE_FAILED, NULL, "fubar", "snafu");
should(a, ARCHIVE_FAILED, "fubar", "snafu", NULL);
should(a, ARCHIVE_FAILED, "fubar", "snafu", "betcha");
archive_read_free(a);
}
static void
test(int pristine)
{
struct archive* a = archive_write_new();
if (!pristine)
archive_write_set_compression_gzip(a);
should(a, ARCHIVE_OK, NULL, NULL, NULL);
should(a, ARCHIVE_OK, "", "", "");
should(a, ARCHIVE_FAILED, NULL, "fubar", NULL);
should(a, ARCHIVE_FAILED, NULL, "fubar", "snafu");
should(a, ARCHIVE_FAILED, "fubar", "snafu", NULL);
should(a, ARCHIVE_FAILED, "fubar", "snafu", "betcha");
archive_write_finish(a);
}
void Refinement ::
ValidateRefinedMesh (Mesh & mesh,
Array<INDEX_2> & parents)
{
// int i, j, k;
// homotopy method
int ne = mesh.GetNE();
int cnttrials = 100;
int wrongels = 0;
for (int i = 1; i <= ne; i++)
if (mesh.VolumeElement(i).CalcJacobianBadness (mesh.Points()) > 1e10)
{
wrongels++;
mesh.VolumeElement(i).flags.badel = 1;
}
else
mesh.VolumeElement(i).flags.badel = 0;
double facok = 0;
double factry;
BitArray illegalels(ne);
illegalels.Clear();
if (wrongels)
{
cout << "WARNING: " << wrongels << " illegal element(s) found" << endl;
int np = mesh.GetNP();
Array<Point<3> > should(np);
Array<Point<3> > can(np);
for (int i = 1; i <= np; i++)
{
should.Elem(i) = can.Elem(i) = mesh.Point(i);
}
for (int i = 1; i <= parents.Size(); i++)
{
if (parents.Get(i).I1())
can.Elem(i) = Center (can.Elem(parents.Get(i).I1()),
can.Elem(parents.Get(i).I2()));
}
BitArray boundp(np);
boundp.Clear();
for (int i = 1; i <= mesh.GetNSE(); i++)
{
const Element2d & sel = mesh.SurfaceElement(i);
for (int j = 1; j <= sel.GetNP(); j++)
boundp.Set(sel.PNum(j));
}
(*testout) << "bpoints:" << endl;
for (int i = 1; i <= np; i++)
if (boundp.Test(i))
(*testout) << i << endl;
double lam = 0.5;
while (facok < 1-1e-8 && cnttrials > 0)
{
lam *= 4;
if (lam > 2) lam = 2;
do
{
// cout << "trials: " << cnttrials << endl;
lam *= 0.5;
cnttrials--;
cout << "lam = " << lam << endl;
factry = lam + (1-lam) * facok;
cout << "trying: " << factry << endl;
for (int i = 1; i <= np; i++)
if (boundp.Test(i))
{
for (int j = 0; j < 3; j++)
mesh.Point(i)(j) =
lam * should.Get(i)(j) +
(1-lam) * can.Get(i)(j);
}
else
mesh.Point(i) = Point<3> (can.Get(i));
// (*testout) << "bad els: " << endl;
wrongels = 0;
for (int i = 1; i <= ne; i++)
{
if (!illegalels.Test(i) &&
mesh.VolumeElement(i).
CalcJacobianBadness(mesh.Points()) > 1e10)
{
wrongels++;
Element & el = mesh.VolumeElement(i);
el.flags.badel = 1;
if (lam < 1e-4)
illegalels.Set(i);
/*
(*testout) << i << ": ";
for (j = 1; j <= el.GetNP(); j++)
(*testout) << el.PNum(j) << " ";
(*testout) << endl;
*/
}
else
mesh.VolumeElement(i).flags.badel = 0;
}
cout << "wrongels = " << wrongels << endl;
}
while (wrongels && cnttrials > 0);
mesh.CalcSurfacesOfNode();
MeshingParameters dummymp;
mesh.ImproveMeshJacobian (dummymp, OPT_WORSTCASE);
facok = factry;
for (int i = 1; i <= np; i++)
can.Elem(i) = mesh.Point(i);
}
}
for (int i = 1; i <= ne; i++)
{
if (illegalels.Test(i))
{
cout << "illegal element: " << i << endl;
mesh.VolumeElement(i).flags.badel = 1;
}
else
mesh.VolumeElement(i).flags.badel = 0;
}
/*
if (cnttrials <= 0)
{
cerr << "ERROR: Sorry, illegal elements:" << endl;
}
*/
}
void RepairBisection(Mesh & mesh, Array<ElementIndex> & bad_elements,
const BitArray & isnewpoint, const Refinement & refinement,
const Array<double> & pure_badness,
double max_worsening, const bool uselocalworsening,
const Array< Array<int,PointIndex::BASE>* > & idmaps)
{
ostringstream ostrstr;
const int maxtrials = 100;
//bool doit;
//cout << "DOIT: " << flush;
//cin >> doit;
int ne = mesh.GetNE();
int np = mesh.GetNP();
int numbadneighbours = 3;
const int numtopimprove = 3;
PrintMessage(1,"repairing");
PushStatus("Repair Bisection");
Array<Point<3>* > should(np);
Array<Point<3>* > can(np);
Array<Vec<3>* > nv(np);
for(int i=0; i<np; i++)
{
nv[i] = new Vec<3>;
should[i] = new Point<3>;
can[i] = new Point<3>;
}
BitArray isboundarypoint(np),isedgepoint(np);
isboundarypoint.Clear();
isedgepoint.Clear();
for(int i = 1; i <= mesh.GetNSeg(); i++)
{
const Segment & seg = mesh.LineSegment(i);
isedgepoint.Set(seg[0]);
isedgepoint.Set(seg[1]);
}
Array<int> surfaceindex(np);
surfaceindex = -1;
for (int i = 1; i <= mesh.GetNSE(); i++)
{
const Element2d & sel = mesh.SurfaceElement(i);
for (int j = 1; j <= sel.GetNP(); j++)
if(!isedgepoint.Test(sel.PNum(j)))
{
isboundarypoint.Set(sel.PNum(j));
surfaceindex[sel.PNum(j) - PointIndex::BASE] =
mesh.GetFaceDescriptor(sel.GetIndex()).SurfNr();
}
}
Validate(mesh,bad_elements,pure_badness,
((uselocalworsening) ? (0.8*(max_worsening-1.) + 1.) : (0.1*(max_worsening-1.) + 1.)),
uselocalworsening); // -> larger working area
BitArray working_elements(ne);
BitArray working_points(np);
GetWorkingArea(working_elements,working_points,mesh,bad_elements,numbadneighbours);
//working_elements.Set();
//working_points.Set();
ostrstr.str("");
ostrstr << "worsening: " <<
Validate(mesh,bad_elements,pure_badness,max_worsening,uselocalworsening);
PrintMessage(4,ostrstr.str());
int auxnum=0;
for(int i=1; i<=np; i++)
if(working_points.Test(i))
auxnum++;
ostrstr.str("");
ostrstr << "Percentage working points: " << 100.*double(auxnum)/np;
PrintMessage(5,ostrstr.str());
BitArray isworkingboundary(np);
for(int i=1; i<=np; i++)
if(working_points.Test(i) && isboundarypoint.Test(i))
isworkingboundary.Set(i);
else
isworkingboundary.Clear(i);
for(int i=0; i<np; i++)
*should[i] = mesh.Point(i+1);
for(int i=0; i<np; i++)
{
if(isnewpoint.Test(i+PointIndex::BASE) &&
//working_points.Test(i+PointIndex::BASE) &&
mesh.mlbetweennodes[i+PointIndex::BASE][0] > 0)
*can[i] = Center(*can[mesh.mlbetweennodes[i+PointIndex::BASE][0]-PointIndex::BASE],
*can[mesh.mlbetweennodes[i+PointIndex::BASE][1]-PointIndex::BASE]);
else
*can[i] = mesh.Point(i+1);
}
int cnttrials = 1;
double lamedge = 0.5;
double lamface = 0.5;
double facokedge = 0;
double facokface = 0;
double factryedge;
double factryface = 0;
double oldlamedge,oldlamface;
MeshOptimize2d * optimizer2d = refinement.Get2dOptimizer();
if(!optimizer2d)
{
cerr << "No 2D Optimizer!" << endl;
return;
}
while ((facokedge < 1.-1e-8 || facokface < 1.-1e-8) &&
cnttrials < maxtrials &&
multithread.terminate != 1)
{
(*testout) << " facokedge " << facokedge << " facokface " << facokface << " cnttrials " << cnttrials << endl
<< " perc. " << 95. * max2( min2(facokedge,facokface),
double(cnttrials)/double(maxtrials)) << endl;
SetThreadPercent(95. * max2( min2(facokedge,facokface),
double(cnttrials)/double(maxtrials)));
ostrstr.str("");
ostrstr << "max. worsening " << max_worsening;
PrintMessage(5,ostrstr.str());
oldlamedge = lamedge;
lamedge *= 6;
if (lamedge > 2)
lamedge = 2;
if(1==1 || facokedge < 1.-1e-8)
{
for(int i=0; i<nv.Size(); i++)
*nv[i] = Vec<3>(0,0,0);
for (int i = 1; i <= mesh.GetNSE(); i++)
{
const Element2d & sel = mesh.SurfaceElement(i);
Vec<3> auxvec = Cross(mesh.Point(sel.PNum(2))-mesh.Point(sel.PNum(1)),
mesh.Point(sel.PNum(3))-mesh.Point(sel.PNum(1)));
auxvec.Normalize();
for (int j = 1; j <= sel.GetNP(); j++)
if(!isedgepoint.Test(sel.PNum(j)))
*nv[sel.PNum(j) - PointIndex::BASE] += auxvec;
}
for(int i=0; i<nv.Size(); i++)
nv[i]->Normalize();
do // move edges
{
lamedge *= 0.5;
cnttrials++;
if(cnttrials % 10 == 0)
max_worsening *= 1.1;
factryedge = lamedge + (1.-lamedge) * facokedge;
ostrstr.str("");
ostrstr << "lamedge = " << lamedge << ", trying: " << factryedge;
PrintMessage(5,ostrstr.str());
for (int i = 1; i <= np; i++)
{
if (isedgepoint.Test(i))
{
for (int j = 0; j < 3; j++)
mesh.Point(i)(j) =
lamedge * (*should.Get(i))(j) +
(1.-lamedge) * (*can.Get(i))(j);
}
else
mesh.Point(i) = *can.Get(i);
}
if(facokedge < 1.-1e-8)
{
ostrstr.str("");
ostrstr << "worsening: " <<
Validate(mesh,bad_elements,pure_badness,max_worsening,uselocalworsening);
PrintMessage(5,ostrstr.str());
}
else
Validate(mesh,bad_elements,pure_badness,-1,uselocalworsening);
ostrstr.str("");
ostrstr << bad_elements.Size() << " bad elements";
PrintMessage(5,ostrstr.str());
}
while (bad_elements.Size() > 0 &&
cnttrials < maxtrials &&
multithread.terminate != 1);
}
if(cnttrials < maxtrials &&
multithread.terminate != 1)
{
facokedge = factryedge;
// smooth faces
mesh.CalcSurfacesOfNode();
MeshingParameters dummymp;
mesh.ImproveMeshJacobianOnSurface(dummymp,isworkingboundary,nv,OPT_QUALITY, &idmaps);
for (int i = 1; i <= np; i++)
*can.Elem(i) = mesh.Point(i);
if(optimizer2d)
optimizer2d->ProjectBoundaryPoints(surfaceindex,can,should);
}
oldlamface = lamface;
lamface *= 6;
if (lamface > 2)
lamface = 2;
if(cnttrials < maxtrials &&
multithread.terminate != 1)
{
do // move faces
{
lamface *= 0.5;
cnttrials++;
if(cnttrials % 10 == 0)
max_worsening *= 1.1;
factryface = lamface + (1.-lamface) * facokface;
ostrstr.str("");
ostrstr << "lamface = " << lamface << ", trying: " << factryface;
PrintMessage(5,ostrstr.str());
for (int i = 1; i <= np; i++)
{
if (isboundarypoint.Test(i))
{
for (int j = 0; j < 3; j++)
mesh.Point(i)(j) =
lamface * (*should.Get(i))(j) +
(1.-lamface) * (*can.Get(i))(j);
}
else
mesh.Point(i) = *can.Get(i);
}
ostrstr.str("");
ostrstr << "worsening: " <<
Validate(mesh,bad_elements,pure_badness,max_worsening,uselocalworsening);
PrintMessage(5,ostrstr.str());
ostrstr.str("");
ostrstr << bad_elements.Size() << " bad elements";
PrintMessage(5,ostrstr.str());
}
while (bad_elements.Size() > 0 &&
cnttrials < maxtrials &&
multithread.terminate != 1);
}
if(cnttrials < maxtrials &&
multithread.terminate != 1)
{
facokface = factryface;
// smooth interior
mesh.CalcSurfacesOfNode();
MeshingParameters dummymp;
mesh.ImproveMeshJacobian (dummymp, OPT_QUALITY,&working_points);
//mesh.ImproveMeshJacobian (OPT_WORSTCASE,&working_points);
for (int i = 1; i <= np; i++)
*can.Elem(i) = mesh.Point(i);
}
//!
if((facokedge < 1.-1e-8 || facokface < 1.-1e-8) &&
cnttrials < maxtrials &&
multithread.terminate != 1)
{
MeshingParameters dummymp;
MeshOptimize3d optmesh(dummymp);
for(int i=0; i<numtopimprove; i++)
{
optmesh.SwapImproveSurface(mesh,OPT_QUALITY,&working_elements,&idmaps);
optmesh.SwapImprove(mesh,OPT_QUALITY,&working_elements);
}
// mesh.mglevels = 1;
ne = mesh.GetNE();
working_elements.SetSize(ne);
for (int i = 1; i <= np; i++)
mesh.Point(i) = *should.Elem(i);
Validate(mesh,bad_elements,pure_badness,
((uselocalworsening) ? (0.8*(max_worsening-1.) + 1.) : (0.1*(max_worsening-1.) + 1.)),
uselocalworsening);
if(lamedge < oldlamedge || lamface < oldlamface)
numbadneighbours++;
GetWorkingArea(working_elements,working_points,mesh,bad_elements,numbadneighbours);
for(int i=1; i<=np; i++)
if(working_points.Test(i) && isboundarypoint.Test(i))
isworkingboundary.Set(i);
else
isworkingboundary.Clear(i);
auxnum=0;
for(int i=1; i<=np; i++)
if(working_points.Test(i))
auxnum++;
ostrstr.str("");
ostrstr << "Percentage working points: " << 100.*double(auxnum)/np;
PrintMessage(5,ostrstr.str());
for (int i = 1; i <= np; i++)
mesh.Point(i) = *can.Elem(i);
}
//!
}
MeshingParameters dummymp;
MeshOptimize3d optmesh(dummymp);
for(int i=0; i<numtopimprove && multithread.terminate != 1; i++)
{
optmesh.SwapImproveSurface(mesh,OPT_QUALITY,NULL,&idmaps);
optmesh.SwapImprove(mesh,OPT_QUALITY);
//mesh.UpdateTopology();
}
mesh.UpdateTopology();
/*
if(cnttrials < 100)
{
nv = Vec3d(0,0,0);
for (int i = 1; i <= mesh.GetNSE(); i++)
{
const Element2d & sel = mesh.SurfaceElement(i);
Vec3d auxvec = Cross(mesh.Point(sel.PNum(2))-mesh.Point(sel.PNum(1)),
mesh.Point(sel.PNum(3))-mesh.Point(sel.PNum(1)));
auxvec.Normalize();
for (int j = 1; j <= sel.GetNP(); j++)
if(!isedgepoint.Test(sel.PNum(j)))
nv[sel.PNum(j) - PointIndex::BASE] += auxvec;
}
for(int i=0; i<nv.Size(); i++)
nv[i].Normalize();
mesh.ImproveMeshJacobianOnSurface(isboundarypoint,nv,OPT_QUALITY);
mesh.CalcSurfacesOfNode();
// smooth interior
for (int i = 1; i <= np; i++)
if(isboundarypoint.Test(i))
can.Elem(i) = mesh.Point(i);
if(optimizer2d)
optimizer2d->ProjectBoundaryPoints(surfaceindex,can,should);
for (int i = 1; i <= np; i++)
if(isboundarypoint.Test(i))
for(int j=1; j<=3; j++)
mesh.Point(i).X(j) = should.Get(i).X(j);
}
*/
if(cnttrials == maxtrials)
{
for (int i = 1; i <= np; i++)
mesh.Point(i) = *should.Get(i);
Validate(mesh,bad_elements,pure_badness,max_worsening,uselocalworsening);
for(int i=0; i<bad_elements.Size(); i++)
{
ostrstr.str("");
ostrstr << "bad element:" << endl
<< mesh[bad_elements[i]][0] << ": " << mesh.Point(mesh[bad_elements[i]][0]) << endl
<< mesh[bad_elements[i]][1] << ": " << mesh.Point(mesh[bad_elements[i]][1]) << endl
<< mesh[bad_elements[i]][2] << ": " << mesh.Point(mesh[bad_elements[i]][2]) << endl
<< mesh[bad_elements[i]][3] << ": " << mesh.Point(mesh[bad_elements[i]][3]);
PrintMessage(5,ostrstr.str());
}
for (int i = 1; i <= np; i++)
mesh.Point(i) = *can.Get(i);
}
for(int i=0; i<np; i++)
{
delete nv[i];
delete can[i];
delete should[i];
}
PopStatus();
}
static void
test(int pristine)
{
struct archive* a = archive_read_new();
int halfempty_options_rv = pristine ? ARCHIVE_FAILED : ARCHIVE_OK;
int known_option_rv = pristine ? ARCHIVE_FAILED : ARCHIVE_OK;
if (!pristine) {
archive_read_support_filter_all(a);
archive_read_support_format_all(a);
}
/* NULL and "" denote `no option', so they're ok no matter
* what, if any, formats are registered */
should(a, ARCHIVE_OK, NULL);
should(a, ARCHIVE_OK, "");
/* unknown modules and options */
should(a, ARCHIVE_FAILED, "fubar:snafu");
assertEqualString("Unknown module name: `fubar'",
archive_error_string(a));
should(a, ARCHIVE_FAILED, "fubar:snafu=betcha");
assertEqualString("Unknown module name: `fubar'",
archive_error_string(a));
/* unknown modules and options */
should(a, ARCHIVE_FAILED, "snafu");
assertEqualString("Undefined option: `snafu'",
archive_error_string(a));
should(a, ARCHIVE_FAILED, "snafu=betcha");
assertEqualString("Undefined option: `snafu'",
archive_error_string(a));
/* ARCHIVE_OK with iso9660 loaded, ARCHIVE_FAILED otherwise */
should(a, known_option_rv, "iso9660:joliet");
if (pristine) {
assertEqualString("Unknown module name: `iso9660'",
archive_error_string(a));
}
should(a, known_option_rv, "iso9660:joliet");
if (pristine) {
assertEqualString("Unknown module name: `iso9660'",
archive_error_string(a));
}
should(a, known_option_rv, "joliet");
if (pristine) {
assertEqualString("Undefined option: `joliet'",
archive_error_string(a));
}
should(a, known_option_rv, "!joliet");
if (pristine) {
assertEqualString("Undefined option: `joliet'",
archive_error_string(a));
}
should(a, ARCHIVE_OK, ",");
should(a, ARCHIVE_OK, ",,");
should(a, halfempty_options_rv, ",joliet");
if (pristine) {
assertEqualString("Undefined option: `joliet'",
archive_error_string(a));
}
should(a, halfempty_options_rv, "joliet,");
if (pristine) {
assertEqualString("Undefined option: `joliet'",
archive_error_string(a));
}
should(a, ARCHIVE_FAILED, "joliet,snafu");
if (pristine) {
assertEqualString("Undefined option: `joliet'",
archive_error_string(a));
} else {
assertEqualString("Undefined option: `snafu'",
archive_error_string(a));
}
should(a, ARCHIVE_FAILED, "iso9660:snafu");
if (pristine) {
assertEqualString("Unknown module name: `iso9660'",
archive_error_string(a));
} else {
assertEqualString("Undefined option: `iso9660:snafu'",
archive_error_string(a));
}
archive_read_free(a);
}
void test_update_objects_from_compress(TestContext* tc)
{
int assertion;
int red_flag_compress,blue_flag_compress,red_shovel_compress,blue_shovel_compress;
PixelUpdate pu;
//Create maze
Maze maze;
maze_build_from_file(&maze,"test.map");
//Initialize a dummy object
Object* red_flag = object_get(&maze,OBJECT_FLAG,TEAM_RED);
Object* blue_flag = object_get(&maze,OBJECT_FLAG,TEAM_BLUE);
Object* red_shovel = object_get(&maze,OBJECT_SHOVEL,TEAM_RED);
Object* blue_shovel = object_get(&maze,OBJECT_SHOVEL,TEAM_BLUE);
//Position of each object somewhere on the map
red_flag->cell = &maze.get[50][27];
blue_flag->cell = &maze.get[99][20];
red_shovel->cell = &maze.get[34][53];
blue_shovel->cell = &maze.get[79][22];
//Compress Object
compress_object(red_flag,&red_flag_compress);
compress_object(blue_flag,&blue_flag_compress);
compress_object(red_shovel,&red_shovel_compress);
compress_object(blue_shovel,&blue_shovel_compress);
//Update Maze based on compressed object
update_objects(1,&red_flag_compress,&maze,&pu);
update_objects(1,&blue_flag_compress,&maze,&pu);
update_objects(1,&red_shovel_compress,&maze,&pu);
update_objects(1,&blue_shovel_compress,&maze,&pu);
//Check if pointer to object from object list points to same object from the cell it occupies
assertion = (object_get(&maze,OBJECT_FLAG,TEAM_RED)->client_position.x == 50) &&
(object_get(&maze,OBJECT_FLAG,TEAM_RED)->client_position.y == 27);
should("correctly update (50,27): RED FLAG",assertion,tc);
assertion = (object_get(&maze,OBJECT_FLAG,TEAM_BLUE)->client_position.x == 99) &&
(object_get(&maze,OBJECT_FLAG,TEAM_BLUE)->client_position.y == 20);
should("correctly update (99,20): BLUE FLAG",assertion,tc);
assertion = (object_get(&maze,OBJECT_SHOVEL,TEAM_RED)->client_position.x == 34) &&
(object_get(&maze,OBJECT_SHOVEL,TEAM_RED)->client_position.y == 53);
should("correctly update (34,53): RED SHOVEL",assertion,tc);
assertion = (object_get(&maze,OBJECT_SHOVEL,TEAM_BLUE)->client_position.x == 79) &&
(object_get(&maze,OBJECT_SHOVEL,TEAM_BLUE)->client_position.y == 22);
should("correctly update (79,22): BLUE SHOVEL",assertion,tc);
//Position of each object somewhere on the map
red_flag->cell = &maze.get[11][22];
blue_flag->cell = &maze.get[52][61];
red_shovel->cell = &maze.get[20][16];
blue_shovel->cell = &maze.get[12][28];
//Compress Object
compress_object(red_flag,&red_flag_compress);
compress_object(blue_flag,&blue_flag_compress);
compress_object(red_shovel,&red_shovel_compress);
compress_object(blue_shovel,&blue_shovel_compress);
//Update Maze based on compressed object
update_objects(1,&red_flag_compress,&maze,&pu);
update_objects(1,&blue_flag_compress,&maze,&pu);
update_objects(1,&red_shovel_compress,&maze,&pu);
update_objects(1,&blue_shovel_compress,&maze,&pu);
//Check if pointer to object from object list points to same object from the cell it occupies
assertion = (object_get(&maze,OBJECT_FLAG,TEAM_RED)->client_position.x == 11) &&
(object_get(&maze,OBJECT_FLAG,TEAM_RED)->client_position.y == 22);
should("correctly update (11,22): RED FLAG",assertion,tc);
assertion = (object_get(&maze,OBJECT_FLAG,TEAM_BLUE)->client_position.x == 52) &&
(object_get(&maze,OBJECT_FLAG,TEAM_BLUE)->client_position.y == 61);
should("correctly update (52,61): BLUE FLAG",assertion,tc);
assertion = (object_get(&maze,OBJECT_SHOVEL,TEAM_RED)->client_position.x == 20) &&
(object_get(&maze,OBJECT_SHOVEL,TEAM_RED)->client_position.y == 16);
should("correctly update (20,16): RED SHOVEL",assertion,tc);
assertion = (object_get(&maze,OBJECT_SHOVEL,TEAM_BLUE)->client_position.x == 12) &&
(object_get(&maze,OBJECT_SHOVEL,TEAM_BLUE)->client_position.y == 28);
should("correctly update (12,28): BLUE SHOVEL",assertion,tc);
}
