void TestQgsCoordinateTransform::isShortCircuited()
{
QgsCoordinateTransform tr;
//invalid transform shortcircuits
QVERIFY( tr.isShortCircuited() );
QgsCoordinateReferenceSystem srs1;
srs1.createFromSrid( 3994 );
QgsCoordinateReferenceSystem srs2;
srs2.createFromSrid( 4326 );
// valid source, invalid destination
QgsCoordinateTransform tr2( srs1, QgsCoordinateReferenceSystem() );
QVERIFY( tr2.isShortCircuited() );
// invalid source, valid destination
QgsCoordinateTransform tr3( QgsCoordinateReferenceSystem(), srs2 );
QVERIFY( tr3.isShortCircuited() );
// equal, valid source and destination
QgsCoordinateTransform tr4( srs1, srs1 );
QVERIFY( tr4.isShortCircuited() );
// valid but different source and destination
QgsCoordinateTransform tr5( srs1, srs2 );
QVERIFY( !tr5.isShortCircuited() );
// try to short circuit by changing dest
tr5.setDestinationCrs( srs1 );
QVERIFY( tr5.isShortCircuited() );
}
void TestQgsCoordinateTransform::isValid()
{
QgsCoordinateTransform tr;
QVERIFY( !tr.isValid() );
QgsCoordinateReferenceSystem srs1;
srs1.createFromSrid( 3994 );
QgsCoordinateReferenceSystem srs2;
srs2.createFromSrid( 4326 );
// valid source, invalid destination
QgsCoordinateTransform tr2( srs1, QgsCoordinateReferenceSystem() );
QVERIFY( !tr2.isValid() );
// invalid source, valid destination
QgsCoordinateTransform tr3( QgsCoordinateReferenceSystem(), srs2 );
QVERIFY( !tr3.isValid() );
// valid source, valid destination
QgsCoordinateTransform tr4( srs1, srs2 );
QVERIFY( tr4.isValid() );
// try to invalidate by setting source as invalid
tr4.setSourceCrs( QgsCoordinateReferenceSystem() );
QVERIFY( !tr4.isValid() );
QgsCoordinateTransform tr5( srs1, srs2 );
// try to invalidate by setting destination as invalid
tr5.setDestinationCrs( QgsCoordinateReferenceSystem() );
QVERIFY( !tr5.isValid() );
}
void test_SHARC2() {
SumOfSines vox1(196), vox2(196), vox3(196), vox4(196), vox5(196);
SHARC_Library * lib;
SHARC_Spectrum * sp1, * sp2, * sp3, * sp4, * sp5;
lib = new SHARC_Library("../../../Code/sharc");
// access a spectrum, load it into a SumOfSines, and scale it by a triangle envelope
sp1 = lib->spectrum_named("altoflute_vibrato", "g3");
vox1.add_partials(csl_min(sp1->_num_partials, 20), sp1->_partials);
vox1.create_cache(); // cache the waveform (since it's a harmonic overtone spectrum)
Triangle tr1(3, 0.75);
vox1.set_scale(tr1);
// repeat for 3 other delayed examples
sp2 = lib->spectrum_named("bass_clarinet", "g3");
vox2.add_partials(csl_min(sp2->_num_partials, 20), sp2->_partials);
vox2.create_cache(); // cache the waveform
Triangle tr2(3, 0.75);
vox2.set_scale(tr2);
sp3 = lib->spectrum_named("cello_vibrato", "g3");
vox3.add_partials(csl_min(sp3->_num_partials, 20), sp3->_partials);
vox3.create_cache(); // cache the waveform
Triangle tr3(3, 0.75);
vox3.set_scale(tr3);
sp4 = lib->spectrum_named("trombone", "g3");
vox4.add_partials(csl_min(sp4->_num_partials, 20), sp4->_partials);
vox4.create_cache(); // cache the waveform
Triangle tr4(3, 0.75);
vox4.set_scale(tr4);
sp5 = lib->spectrum_named("violin_martele", "g3");
vox5.add_partials(csl_min(sp4->_num_partials, 20), sp4->_partials);
vox5.create_cache(); // cache the waveform
Triangle tr5(3, 0.75);
vox5.set_scale(tr5);
Mixer mix(2); // create a stereo mixer
mix.add_input(vox1); mix.add_input(vox2);
mix.add_input(vox3); mix.add_input(vox4); mix.add_input(vox5);
logMsg("playing SumOfSines mix..."); // I don't use run_test() here because I need to trigger the envelopes while it's playing
gIO->set_root(mix); // turn it on
tr1.trigger(); // trigger the 1st envelope
usleep(1500000); // wait 1.5 sec
tr2.trigger(); // trigger the 2nd envelope
usleep(1500000); // wait 1.5 sec
tr3.trigger(); // trigger the 3rd envelope
usleep(1500000); // wait 1.5 sec
tr4.trigger(); // trigger the 4th envelope
usleep(1500000); // wait 1.5 sec
tr5.trigger(); // trigger the 5th envelope
usleep(3000000); // wait 3 seconds
gIO->clear_root(); // turn it off
logMsg("SumOfSines done.");
}
void loop() { stateChanged=false;
int pn1=random(0,11);
switch (pn1) {
case 0:
//None
tr2();
break;
case 1:
//None
tr3();
break;
case 2:
//None
tr4();
break;
case 3:
//None
tr5();
break;
case 4:
//None
tr7();
break;
case 5:
//wait 1 milli
tr8();
break;
case 6:
//None
tr9();
break;
case 7:
//None
tr10();
break;
case 8:
//None
tr11();
break;
case 9:
//None
tr6();
break;
case 10:
//None
tr12();
break;
}
if (stateChanged){
outputStatusLine();}
}
void fillPoisson(int nbg, int nsiglike_sideband, int nsideband, TH1 * fill, int prior = JEFFREYS_PRIOR, int N = 10000)
{
TRandom3 tr3(0);
for (int i = 0; i < N; i++)
{
if (prior == FLAT_PRIOR)
{
fill->Fill(tr3.Poisson(gammarnd(nbg+1,1) * gammarnd(nsiglike_sideband+1,1) / gammarnd(nsideband+1,1)));
}
else if (prior == JEFFREYS_PRIOR)
{
fill->Fill(tr3.Poisson(gammarnd(nbg+0.5,1) * gammarnd(nsiglike_sideband+0.5,1) / gammarnd(nsideband+0.5,1)));
}
else
{
fill->Fill(tr3.Poisson(gammarnd(nbg,1) * gammarnd(nsiglike_sideband,1) / gammarnd(nsideband,1)));
}
}
}
void ZShape2dMC(){
double signal_weight = 3531.89/30459500.;//3504
if (!doMG) signal_weight = 1966.7 / 42705454.; //
TH1D* mc_truegen;
vector<TH1D*> mc_truegen_cteq, mc_truegen_fsr_pileup;
GetGen(signal_weight, mc_truegen, mc_truegen_cteq, mc_truegen_fsr_pileup);
cout<<"Get MC distribution"<<endl;
vector<TGraphAsymmErrors*> g_MC_phistar;
TGraphAsymmErrors* g_MC_phistar_temp1=ConvertToTGraph(mc_truegen);
g_MC_phistar.push_back(g_MC_phistar_temp1);
vector<TGraphAsymmErrors*> g_MC_phistar_cteq;
for (size_t u=0; u<mc_truegen_cteq.size(); u++){
TGraphAsymmErrors* g_MC_phistar_temp=ConvertToTGraph(mc_truegen_cteq[u]);
g_MC_phistar_cteq.push_back(g_MC_phistar_temp);
}
vector<TGraphAsymmErrors*> g_MC_phistar_fsr_pileup;
for (size_t u=0; u<mc_truegen_fsr_pileup.size(); u++){
TGraphAsymmErrors* g_MC_phistar_temp=ConvertToTGraph(mc_truegen_fsr_pileup[u]);
g_MC_phistar_fsr_pileup.push_back(g_MC_phistar_temp);
}
vector<TGraphAsymmErrors *> g_MC_norm = CreateCopy(g_MC_phistar);
vector<TGraphAsymmErrors *> g_MC_norm_cteq = CreateCopy(g_MC_phistar_cteq);
vector<TGraphAsymmErrors *> g_MC_norm_fsr_pileup = CreateCopy(g_MC_phistar_fsr_pileup);
NormalizeGraph(g_MC_phistar, 0);
NormalizeGraph(g_MC_phistar_cteq, 0);
NormalizeGraph(g_MC_phistar_fsr_pileup, 0);
NormalizeGraph(g_MC_norm, 1);
NormalizeGraph(g_MC_norm_cteq, 1);
NormalizeGraph(g_MC_norm_fsr_pileup, 1);
TGraphAsymmErrors* g_syst_mc_cteq = CalcTotalSysU_updown(g_MC_phistar_cteq,g_MC_phistar_cteq[0],1,1);
TGraphAsymmErrors* g_syst_mc_fsr = CalcTotalSysU_fsr(g_MC_phistar_fsr_pileup[0],g_MC_phistar[0]);
TGraphAsymmErrors* g_syst_norm_mc_cteq = CalcTotalSysU_updown(g_MC_norm_cteq,g_MC_norm_cteq[0],1,1);
TGraphAsymmErrors* g_syst_norm_mc_fsr = CalcTotalSysU_fsr(g_MC_norm_fsr_pileup[0],g_MC_norm[0]);
vector<TGraphAsymmErrors *> g_mc_syst;
g_mc_syst.push_back(g_MC_phistar[0]);
g_mc_syst.push_back(g_syst_mc_fsr);
if (!doMG) g_mc_syst.push_back(g_syst_mc_cteq);
vector<std::string> syst_mc_list;
syst_mc_list.push_back("unfolding");
syst_mc_list.push_back("fsr");
if (!doMG) syst_mc_list.push_back("cteq");
TGraphAsymmErrors* g_mc_final=GetMCFinal(g_mc_syst, syst_mc_list, 0);
vector<TGraphAsymmErrors *> g_mc_syst_norm;
g_mc_syst_norm.push_back(g_MC_norm[0]);
g_mc_syst_norm.push_back(g_syst_norm_mc_fsr);
if (!doMG) g_mc_syst_norm.push_back(g_syst_norm_mc_cteq);
vector<std::string> syst_mc_list_norm;
syst_mc_list_norm.push_back("unfolding");
syst_mc_list_norm.push_back("fsr");
if (!doMG) syst_mc_list_norm.push_back("cteq");
TGraphAsymmErrors* g_mc_final_norm=GetMCFinal(g_mc_syst_norm, syst_mc_list_norm, 1);
string textn="Output/TESTMC_Graph_Abs_";
if (doMG) textn+="MG_";
else textn+="PH_";
if (elec==0)textn+="Dressed.root";
if (elec==1)textn+="Born.root";
if (elec==2)textn+="Naked.root";
TFile tr2(textn.c_str(),"RECREATE");
g_mc_final->Write();
textn="Output/TESTMC_Graph_Norm_";
if (doMG) textn+="MG_";
else textn+="PH_";
if (elec==0)textn+="Dressed.root";
if (elec==1)textn+="Born.root";
if (elec==2)textn+="Naked.root";
TFile tr3(textn.c_str(),"RECREATE");
g_mc_final_norm->Write();
}
void CTTypes::RunTestCaseL(TInt aCurTestCase)
{
switch(aCurTestCase)
{
case 1:
{
__UHEAP_MARK;
TestRgb tr1(0,0,0, this);
TestRgb tr2(100,100,100, this);
TestRgb tr3(10,20,30, this);
TestRgb tr4(110,160,210, this);
TestRgb tr5(255,255,255, this);
INFO_PRINTF1(_L("TRgb"));
tr1.Test();
tr2.Test();
tr3.Test();
tr4.Test();
tr5.Test();
((CTTypesStep*)iStep)->CloseTMSGraphicsStep();
__UHEAP_MARKEND;
}
break;
case 2:
{
INFO_PRINTF1(_L("TTypeface"));
TestTypeface ttf1(_L(""), 0, this);
TestTypeface ttf2(_L("Font name"), 1, this);
TestTypeface ttf3(_L("Font name"), 2, this);
TestTypeface ttf4(_L("Font name"), 3, this);
TestTypeface ttf5(_L("Font name"), 4, this);
TestTypeface ttf6(_L("Font name"), 5, this);
TestTypeface ttf7(_L("Font name"), 6, this);
TestTypeface ttf8(_L("Another font name"), 7, this);
ttf1.Test();
ttf2.Test();
ttf3.Test();
ttf4.Test();
ttf5.Test();
ttf6.Test();
ttf7.Test();
ttf8.Test();
}
break;
case 3:
{
TestMargins tm1(0,0,0,0, this);
TestMargins tm2(10,20,30,40, this);
TestMargins tm3(-10,-20,-30,-40, this);
INFO_PRINTF1(_L("TMargins"));
tm1.Test();
tm2.Test();
tm3.Test();
}
break;
case 4:
{
TestPageSpec tps1(TPageSpec::EPortrait,TSize(0,0), this);
TestPageSpec tps2(TPageSpec::ELandscape,TSize(0,0), this);
TestPageSpec tps3(TPageSpec::EPortrait,TSize(10,-5), this);
TestPageSpec tps4(TPageSpec::ELandscape,TSize(15,-20), this);
TestPageSpec tps5(TPageSpec::EPortrait,TSize(1000,1500), this);
TestPageSpec tps6(TPageSpec::ELandscape,TSize(2000,500), this);
INFO_PRINTF1(_L("TPageSpec"));
tps1.Test();
tps2.Test();
tps3.Test();
tps4.Test();
tps5.Test();
tps6.Test();
}
break;
case 5:
{
INFO_PRINTF1(_L("FontEffect"));
((CTTypesStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-0002"));
TestFontEffect te(this);
((CTTypesStep*)iStep)->RecordTestResultL();
te.Test();
}
break;
case 6:
{
INFO_PRINTF1(_L("TFontSyle"));
TestTFontStyle ts(this);
ts.Test();
}
break;
case 7:
{
TTypeface typeface;
typeface.iName=_L("Font name");
TFontStyle fontstyle;
TestFontSpec tfspec(typeface,200,fontstyle, this);
INFO_PRINTF1(_L("TFontSpec"));
tfspec.Test();
}
break;
case 8:
{
/*
TestLine tl1(TPoint(10,10),TPoint(90,90), this);
TestLine tl2(TPoint(100,150),TPoint(50,-50), this);
TestLine tl3(TPoint(-50,50),TPoint(60,-40), this);
TestLine tl4(TPoint(-100,0),TPoint(0,200), this);
TestLine tl5(TPoint(150,-50),TPoint(50,75), this);
TestLine tl6(TPoint(0,-100),TPoint(-50,-150), this);
TestLine tl7(TPoint(-1000,-1000),TPoint(1000,1000), this);
TestLine tl8(TPoint(1000,-1000),TPoint(-1000,1000), this);
TestLine tl9(TPoint(500,-1000),TPoint(-500,1000), this);
TestLine tl10(TPoint(-500,-1000),TPoint(500,1000), this);
TestLine tl11(TPoint(1000,-500),TPoint(-1000,500), this);
TestLine tl12(TPoint(1000,500),TPoint(-1000,-500), this);
INFO_PRINTF1(_L("TLinearDDA"));
tl1.Test();
tl2.Test();
tl3.Test();
tl4.Test();
tl5.Test();
tl6.Test();
tl7.Test();
tl8.Test();
tl9.Test();
tl10.Test();
tl11.Test();
tl12.Test();
*/
INFO_PRINTF1(_L("TLinearDDA is only for Graphics team. Removed."));
}
break;
case 9:
{
INFO_PRINTF1(_L("CTypefaceStore"));
TestTFStore ttfs(this);
ttfs.Test();
}
break;
case 10:
{
INFO_PRINTF1(_L("CFontCache"));
TestFontCache tfc(this);
tfc.Test();
}
break;
case 11:
{
/*
INFO_PRINTF1(_L("CScaleCropPicture"));
TestPicture tp(this);
tp.Test();
*/
INFO_PRINTF1(_L("CScaleCropPicture is only for Graphics team. Removed."));
}
break;
case 12:
{
/*
INFO_PRINTF1(_L("CPalette"));
TestPalette tpal(this);
tpal.Test();
*/
INFO_PRINTF1(_L("CPalette is only for Graphics team. Removed."));
}
break;
case 13:
{
INFO_PRINTF1(_L("TDisplayModeUtils"));
TestDisplayModeUtils tdmu(this);
tdmu.Test();
}
break;
case 14:
((CTTypesStep*)iStep)->SetOverallTestStepID(_L("GRAPHICS-GDI-0001"));
((CTTypesStep*)iStep)->RecordTestResultL();
((CTTypesStep*)iStep)->CloseTMSGraphicsStep();
TestComplete();
break;
}
}
int main_test_tree(int argc, char **argv) {
unsigned int maxloop = 1;
if (argc > 1)
maxloop = atoi(argv[1]);
for (unsigned int j = 0; j < maxloop; ++j) {
tree<std::string> tr9;
tr9.set_head("hi");
tr9.insert(tr9.begin().begin(), "0");
tr9.insert(tr9.begin().begin(), "1");
print_tree(tr9, tr9.begin(), tr9.end());
tree<std::string> tr;
tree<std::string>::pre_order_iterator html, body, h1, h3, bh1, mv1;
std::cout << "empty tree to begin with:" << std::endl;
print_tree(tr, tr.begin(), tr.end());
html = tr.insert(tr.begin(), "html");
tr.insert(html, "extra");
// tr.insert(html,"zextra2");
body = tr.append_child(html, "body");
h1 = tr.append_child(body, "h1");
std::cout << tr.index(h1) << std::endl;
bh1 = tr.insert(h1, "before h1");
tr.append_child(h1, "some text");
tree<std::string>::sibling_iterator more_text = tr.append_child(body,
"more text");
std::cout << " 'more text' is sibling " << tr.index(more_text)
<< " in its sibling range" << std::endl;
std::cout << "filled tree:" << std::endl;
print_tree(tr, tr.begin(), tr.end());
std::cout << "filled tree, post-order traversal:" << std::endl;
print_tree_post(tr, tr.begin_post(), tr.end_post());
tr.swap(bh1);
std::cout << "swapped elements:" << std::endl;
print_tree(tr, tr.begin(), tr.end());
tr.swap(h1);
std::cout << "swapped back:" << std::endl;
print_tree(tr, tr.begin(), tr.end());
tree<std::string> copytree(h1);
std::cout << "copied tree:" << std::endl;
print_tree(copytree, copytree.begin(), copytree.end());
// Now test the STL algorithms
std::cout << "result of search for h1 and kasper:" << std::endl;
tree<std::string>::pre_order_iterator it;
it = std::find(tr.begin(), tr.end(), std::string("h1"));
if (it != tr.end())
print_tree(tr, it, tr.next_sibling(it));
else
std::cout << "h1 not found" << std::endl;
it = std::find(tr.begin(), tr.end(), std::string("kasper"));
if (it != tr.end())
print_tree(tr, it, tr.next_sibling(it));
else
std::cout << "kasper not found" << std::endl;
std::cout << std::endl;
// remove the h1, replace it with new subtree
tree<std::string> replacement;
h3 = replacement.insert(replacement.begin(), "h3");
replacement.append_child(h3, "text in h3");
std::cout << "replacement tree:" << std::endl;
print_tree(replacement, replacement.begin(), replacement.end());
print_tree(tr, tr.begin(), tr.end());
h1 = tr.replace(tree<std::string>::sibling_iterator(h1),
tr.next_sibling(h1), tree<std::string>::sibling_iterator(h3),
tr.next_sibling(h3));
std::cout << "filled tree with replacement done:" << std::endl;
print_tree(tr, tr.begin(), tr.end());
// replace h3 node while keeping children
h1 = tr.replace(h1, "<foobar>");
print_tree(tr, tr.begin(), tr.end());
// add a sibling to the head
tr.insert_after(h1, "more");
// Copy object.
tree<std::string> tr2 = tr;
print_tree(tr2, tr2.begin(), tr2.end());
tree<std::string> tr3(tr);
// reparent "before h1" to h3 node
tr.reparent(h1, bh1, tr.next_sibling(bh1));
std::cout << "moved content:" << std::endl;
print_tree(tr, tr.begin(), tr.end());
// iterate over children only
tree<std::string>::sibling_iterator ch = tr.begin(h1);
std::cout << "children of h1:" << std::endl;
while (ch != tr.end(h1)) {
std::cout << (*ch) << std::endl;
++ch;
}
std::cout << std::endl;
// flatten the h3 node
tr.flatten(h1);
std::cout << "flattened (at h3) tree:" << std::endl;
print_tree(tr, tr.begin(), tr.end());
// Erase the subtree of tr below body.
tr.erase_children(body);
std::cout << "children of body erased:" << std::endl;
print_tree(tr, tr.begin(), tr.end());
it = std::find(tr.begin(), tr.end(), "h1");
if (it != tr.end())
print_tree(tr, it, tr.next_sibling(it));
else
std::cout << "h1 not found" << std::endl;
// Erase everything
tr.erase(tr.begin());
std::cout << "erased tree:" << std::endl;
print_tree(tr, tr.begin(), tr.end());
// The copies are deep, ie. all nodes have been copied.
std::cout << "copies still exist:" << std::endl;
print_tree(tr2, tr2.begin(), tr2.end());
print_tree(tr3, tr3.begin(), tr3.end());
// Test comparison
std::cout << "testing comparison functions:" << std::endl;
std::cout
<< std::equal(tr2.begin(), tr2.end(), tr3.begin(),
std::equal_to<std::string>()) << " (should be 1)"
<< std::endl;
// modify content but not structure
tree<std::string>::pre_order_iterator fl3 = tr3.begin();
fl3 += 4; // pointing to "<foobar>" node
std::cout << (*fl3) << std::endl;
std::string tmpfl3 = (*fl3);
(*fl3) = "modified";
std::cout
<< std::equal(tr2.begin(), tr2.end(), tr3.begin(),
std::equal_to<std::string>()) << " (should be 0)"
<< std::endl;
std::cout
<< tr2.equal(tr2.begin(), tr2.end(), tr3.begin(),
std::equal_to<std::string>()) << " (should be 0)"
<< std::endl;
std::cout << tr2.equal(tr2.begin(), tr2.end(), tr3.begin(), truefunc)
<< " (should be 1)" << std::endl;
// modify tr3 structure (but not content)
(*fl3) = tmpfl3;
tr3.flatten(fl3);
std::cout << "tree flattened, test again" << std::endl;
print_tree(tr3, tr3.begin(), tr3.end());
// Test comparison again
std::cout
<< tr2.equal(tr2.begin(), tr2.end(), tr3.begin(),
std::equal_to<std::string>()) << " (should be 0)"
<< std::endl;
std::cout
<< std::equal(tr2.begin(), tr2.end(), tr3.begin(),
std::equal_to<std::string>()) << " (should be 1)"
<< std::endl;
// Change content
(*fl3) = "modified";
// Test comparison again
std::cout
<< std::equal(tr2.begin(), tr2.end(), tr3.begin(),
std::equal_to<std::string>()) << " (should be 0)"
<< std::endl;
std::cout
<< tr2.equal(tr2.begin(), tr2.end(), tr3.begin(),
std::equal_to<std::string>()) << " (should be 0)"
<< std::endl;
// Testing sort. First add a subtree to one leaf
tree<std::string>::pre_order_iterator txx3 = tr3.begin();
txx3 += 5;
tr3.append_child(txx3, "ccc");
tr3.append_child(txx3, "bbb");
tr3.append_child(txx3, "bbb");
tr3.append_child(txx3, "aaa");
std::less<std::string> comp;
tree<std::string>::pre_order_iterator bdy = tr3.begin();
bdy += 2;
assert(tr.is_valid(bdy));
std::cout << "unsorted subtree:" << std::endl;
print_tree(tr3, tr3.begin(), tr3.end());
tree<std::string>::sibling_iterator sortit1 = tr3.begin(bdy), sortit2 =
tr3.begin(bdy);
sortit1 += 2;
sortit2 += 4;
assert(tr.is_valid(sortit1));
assert(tr.is_valid(sortit2));
std::cout << "partially sorted subtree: (" << "sorted from "
<< (*sortit1) << " to " << (*sortit2)
<< ", excluding the last element)" << std::endl;
mv1 = tr3.begin();
++mv1;
tr3.sort(sortit1, sortit2);
print_tree(tr3, tr3.begin(), tr3.end());
tr3.sort(tr3.begin(bdy), tr3.end(bdy), comp, true); // false: no sorting of subtrees
// Sorting the entire tree, level by level, is much simpler:
// tr3.sort(tr3.begin(), tr3.end(), true);
std::cout << "sorted subtree:" << std::endl;
print_tree(tr3, tr3.begin(), tr3.end());
// Michael's problem
// std::cout << mv1.node << ", " << tr3.feet << ", " << tr3.feet->prev_sibling << std::endl;
// std::cout << mv1.node->next_sibling << ", " << tr3.feet->prev_sibling << ", " << tr3.end().node << std::endl;
// tr3.sort(tr3.begin(), tr3.end(), true);
// std::cout << mv1.node << ", " << tr3.feet << ", " << tr3.feet->prev_sibling << std::endl;
// std::cout << mv1.node->next_sibling << ", " << tr3.feet->prev_sibling << ", " << tr3.end().node << std::endl;
// print_tree(tr3, tr3.begin(), tr3.end());
// tr3.sort(tr3.begin(), tr3.end(), true);
// std::cout << mv1.node << ", " << tr3.feet << ", " << tr3.feet->prev_sibling << std::endl;
// std::cout << mv1.node->next_sibling << ", " << tr3.feet->prev_sibling << ", " << tr3.end().node << std::endl;
// print_tree(tr3, tr3.begin(), tr3.end());
// return 1;
// Test merge algorithm.
std::cout << "test merge" << std::endl;
tree<std::string> mtree;
tree<std::string>::pre_order_iterator mt1, mt2, mt3;
mt1 = mtree.insert(mtree.begin(), "html");
mt2 = mtree.append_child(mt1, "head");
mt3 = mtree.append_child(mt1, "body");
// Adding it without head having any children tests whether we can
// insert at the end of an empty list of children.
mtree.append_child(mt2, "title");
mtree.append_child(mt3, "h1");
mtree.append_child(mt3, "h1");
tree<std::string> mtBree;
tree<std::string>::pre_order_iterator mtB1, mtB2;
mtB1 = mtBree.insert(mtBree.begin(), "head");
mtB2 = mtBree.append_child(mtB1, "another title");
print_tree(mtree, mtree.begin(), mtree.end());
print_tree(mtBree, mtBree.begin(), mtBree.end());
mtree.merge(mtree.begin(), mtree.end(), mtBree.begin(), mtBree.end(),
true);
print_tree(mtree, mtree.begin(), mtree.end());
mtree.merge(mtree.begin(mtree.begin()), mtree.end(mtree.begin()),
mtBree.begin(), mtBree.end(), true);
print_tree(mtree, mtree.begin(), mtree.end());
// Print tree in reverse (test operator--)
print_tree_rev(mtree, mtree.end(), mtree.begin());
print_tree_rev_post(mtree, mtree.end_post(), mtree.begin_post());
// Breadth-first
tree<std::string> bft;
tree<std::string>::iterator bfB, bfC, bfD;
bft.set_head("A");
bfB = bft.append_child(bft.begin(), "B");
bfC = bft.append_child(bft.begin(), "C");
bfD = bft.append_child(bft.begin(), "D");
bft.append_child(bfB, "E");
bft.append_child(bfB, "F");
bft.append_child(bfC, "G");
bft.append_child(bfC, "H");
bft.append_child(bfD, "I");
tree<std::string>::breadth_first_queued_iterator bfq =
bft.begin_breadth_first();
while (bfq != bft.end_breadth_first()) {
std::cout << *bfq << std::endl;
++bfq;
}
print_tree(bft, bft.begin(), bft.end());
bft.wrap(bfD, "wrap");
print_tree(bft, bft.begin(), bft.end());
tree<std::string>::leaf_iterator li = tr.begin_leaf(bfC);
while (li != tr.end_leaf(bfC)) {
std::cout << *li << std::endl;
++li;
}
// test_move_constructor();
}
return 0;
}
int testTriangle() {
int numErr = 0;
logMessage(_T("TESTING - class GM_3dTriangle ...\n\n"));
// Default constructor, triangle must be invalid
GM_3dTriangle tr;
if (tr.isValid()) {
logMessage(_T("\tERROR - Default constructor creates valid triangle\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Default constructor creates invalid triangle\n"));
}
// Get/Set
GM_3dPoint v1(getRandomDouble(), getRandomDouble(), getRandomDouble());
GM_3dPoint v2(getRandomDouble(), getRandomDouble(), getRandomDouble());
GM_3dPoint v3(getRandomDouble(), getRandomDouble(), getRandomDouble());
tr[0] = GM_3dLine(v1, v2);
tr[1] = GM_3dLine(v2, v3);
tr[2] = GM_3dLine(v3, v1);
if (!tr.isValid() || tr[0].begin() != v1 || tr[0].end() != v2 || tr[1].begin() != v2 || tr[1].end() != v3
|| tr[2].begin() != v3 || tr[2].end() != v1) {
logMessage(_T("\tERROR - Get/Set not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Get/Set working\n"));
}
// Copy constructor
GM_3dTriangle tr1(tr);
if (!tr1.isValid() || tr[0] != tr1[0] || tr[1] != tr1[1] || tr[2] != tr1[2]) {
logMessage(_T("\tERROR - Copy constructor not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Copy constructor working\n"));
}
// Constructor (points)
GM_3dTriangle tr2(v1, v2, v3);
if (!tr1.isValid() || tr[0] != tr2[0] || tr[1] != tr2[1] || tr[2] != tr2[2]) {
logMessage(_T("\tERROR - Constructor (points) not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Constructor (points) working\n"));
}
// Constructor (lines)
GM_3dTriangle tr3(tr[0], tr[1], tr[2]);
if (!tr1.isValid() || tr[0] != tr3[0] || tr[1] != tr3[1] || tr[2] != tr3[2]) {
logMessage(_T("\tERROR - Constructor (lines) not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Constructor (lines) working\n"));
}
// Inversion
tr1.invert();
if (!tr1.isValid() || tr1[0].begin() != tr[0].end() || tr1[0].end() != tr[0].begin() || tr1[1].begin() != tr[1].end() || tr1[1].end() != tr[1].begin() ||
tr1[2].begin() != tr[2].end() || tr1[2].end() != tr[2].begin()) {
logMessage(_T("\tERROR - Triangle inversion not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Triangle inversion working\n"));
}
// Vertical check
GM_3dPoint vPoint = GM_3dLine(v1, v2).center();
vPoint.z(vPoint.z() + getRandomDouble());
GM_3dTriangle VTr(v1, v2, vPoint);
if (!VTr.isValid() || !VTr.isVertical()) {
logMessage(_T("\tERROR - Vertical check not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Vertical check working\n"));
}
// Horizontal check
GM_3dTriangle HTr(tr);
double z = getRandomDouble();
for (unsigned int i = 0 ; i < 3 ; i++) {
HTr[i].begin().z(z);
HTr[i].end().z(z);
}
if (!HTr.isValid() || !HTr.isHorizontal()) {
logMessage(_T("\tERROR - Horizontal check not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Horizontal check working\n"));
}
// Connection check
GM_3dTriangle discTr(tr);
discTr[0].begin().x(discTr[0].begin().x() + 2.0 * GM_DIFF_TOLERANCE);
if (!discTr.isValid() || discTr.isConnected() || !tr.isConnected()) {
logMessage(_T("\tERROR - Connection check not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Connection check working\n"));
}
// Max/Min z
double maxZ = tr.maxZ();
double minZ = tr.minZ();
double checkMaxZ = -DBL_MAX;
double checkMinZ = DBL_MAX;
for (unsigned int i = 0 ; i < 3 ; i++) {
if (tr[i].begin().z() > checkMaxZ) checkMaxZ = tr[i].begin().z();
if (tr[i].begin().z() < checkMinZ) checkMinZ = tr[i].begin().z();
if (tr[i].end().z() > checkMaxZ) checkMaxZ = tr[i].end().z();
if (tr[i].end().z() < checkMinZ) checkMinZ = tr[i].end().z();
}
if (checkMinZ != minZ || checkMaxZ != maxZ) {
logMessage(_T("\tERROR - Min/Max z not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Min/Max z working\n"));
}
return numErr;
}
