std::pair<int, std::string> test_simple_path(std::ostream& strm,int argc, const char *argv[])
{
sparse_graph_t s10(10, graph_type_t::UNDIRECTED);
// fig 17.23 p 67
s10.insert(simple_edge_t(0,1,1));
s10.insert(simple_edge_t(0,2,1));
s10.insert(simple_edge_t(0,6,1));
s10.insert(simple_edge_t(0,5,1));
s10.insert(simple_edge_t(1,2,1));
s10.insert(simple_edge_t(2,3,1));
s10.insert(simple_edge_t(3,4,1));
s10.insert(simple_edge_t(5,4,1));
s10.insert(simple_edge_t(2,4,1));
s10.insert(simple_edge_t(4,6,1));
s10.insert(simple_edge_t(7,8,1));
s10.insert(simple_edge_t(9,10,1));
s10.insert(simple_edge_t(9,11,1));
s10.insert(simple_edge_t(9,12,1));
s10.insert(simple_edge_t(11,12,1));
std::string dn = test_path("simple_path.dot");
s10.graphviz(dn);
simple_edge_path_t sp(s10);
simple_path_t p = sp(0, 5);
ASSERT_CONDITION("there is a path from 0 to 5", p == true);
ASSERT_CONDITION("there is a path no path from 0 to 9", sp(0,9) == false);
return DONE;
}
void sphericalHarmonics::drawSHFunction(const SHFunction& func) const
{
int n = 64;
double du = PI / (n+1);
double dv = 2 * PI/ (n+1);
//float r;
XYZ col;
glBegin(GL_QUADS);
for (double v = 0; v < 2 * PI; v += dv)
{
for (double u = 0; u < PI; u += du)
{
XYZ p[4] =
{
func.getVector(u, v),
func.getVector(u + du, v),
func.getVector(u + du, v + dv),
func.getVector(u, v + dv)
};
SHSample s00(u,v);
SHSample s10(u+du,v);
SHSample s01(u,v+dv);
SHSample s11(u+du,v+dv);
#ifdef SH_DEBUG
s00.calcCoe();
s10.calcCoe();
s01.calcCoe();
s11.calcCoe();
#endif
//r = func.getFloat(s01);
col = func.getColor(s01);
glColor3f(col.x, col.y, col.z);
glVertex3f(p[3].x, p[3].y, p[3].z);
//r = func.getFloat(s11);
col = func.getColor(s11);
glColor3f(col.x, col.y, col.z);
glVertex3f(p[2].x, p[2].y, p[2].z);
//r = func.getFloat(s10);
col = func.getColor(s10);
glColor3f(col.x, col.y, col.z);
glVertex3f(p[1].x, p[1].y, p[1].z);
//r = func.getFloat(s00);
col = func.getColor(s00);
glColor3f(col.x, col.y, col.z);
glVertex3f(p[0].x, p[0].y, p[0].z);
}
}
glEnd();
}
int main()
{
// Step(a) - construct a triangular face.
Arrangement_2 arr;
Segment_2 s1(Point_2(667, 1000), Point_2(4000, 5000));
Segment_2 s2(Point_2(4000, 0), Point_2(4000, 5000));
Segment_2 s3(Point_2(667, 1000), Point_2(4000, 0));
Halfedge_handle e1 = arr.insert_in_face_interior(s1, arr.unbounded_face());
Vertex_handle v1 = e1->source();
Vertex_handle v2 = e1->target();
Halfedge_handle e2 = arr.insert_from_right_vertex(s2, v2);
Vertex_handle v3 = e2->target();
arr.insert_at_vertices(s3, v3, v1);
// Step (b) - create additional two faces inside the triangle.
Point_2 p1(4000, 3666), p2(4000, 1000);
Segment_2 s4(Point_2(4000, 5000), p1);
Segment_2 s5(p1, p2);
Segment_2 s6(Point_2(4000, 0), p2);
Halfedge_handle e4 = arr.split_edge(e2, s4, Segment_2(Point_2(4000, 0), p1));
Vertex_handle w1 = e4->target();
Halfedge_handle e5 = arr.split_edge(e4->next(), s5, s6);
Vertex_handle w2 = e5->target();
Halfedge_handle e6 = e5->next();
Segment_2 s7(p1, Point_2(3000, 2666));
Segment_2 s8(p2, Point_2(3000, 1333));
Segment_2 s9(Point_2(3000, 2666), Point_2(2000, 1666));
Segment_2 s10(Point_2(3000, 1333), Point_2(2000, 1666));
Segment_2 s11(Point_2(3000, 1333), Point_2(3000, 2666));
Halfedge_handle e7 = arr.insert_from_right_vertex(s7, w1);
Vertex_handle v4 = e7->target();
Halfedge_handle e8 = arr.insert_from_right_vertex(s8, w2);
Vertex_handle v5 = e8->target();
Vertex_handle v6 =
arr.insert_in_face_interior(Point_2(2000, 1666), e8->face());
arr.insert_at_vertices(s9, v4, v6);
arr.insert_at_vertices(s10, v5, v6);
arr.insert_at_vertices(s11, v4, v5);
// Step(c) - remove and merge faces to form a single hole in the traingle.
arr.remove_edge(e7);
arr.remove_edge(e8);
e5 = arr.merge_edge(e5, e6, Segment_2(e5->source()->point(),
e6->target()->point()));
e2 = arr.merge_edge(e4, e5, s2);
print_arrangement(arr);
return 0;
}
void Engine::LoadScores()
{
iHiScore[0]= 10000;
iHiScore[1]= 9000;
iHiScore[2]= 8000;
iHiScore[3]= 7000;
iHiScore[4]= 6000;
iHiScore[5]= 5000;
iHiScore[6]= 4000;
iHiScore[7]= 3000;
iHiScore[8]= 2000;
iHiScore[9]= 1000;
string s1("HOLD");
string s2("DOWN");
string s3("KEYS");
string s4("MARY");
string s5("ON");
string s6("MAIN");
string s7("PAGE");
string s8("FOR");
string s9("CHEAT");
string s10("*****");
gSerializer.ReadVariable("score.dat","1a",iHiScore[0]);
gSerializer.ReadVariable("score.dat","1b",s1);
gSerializer.ReadVariable("score.dat","2a",iHiScore[1]);
gSerializer.ReadVariable("score.dat","2b",s2);
gSerializer.ReadVariable("score.dat","3a",iHiScore[2]);
gSerializer.ReadVariable("score.dat","3b",s3);
gSerializer.ReadVariable("score.dat","4a",iHiScore[3]);
gSerializer.ReadVariable("score.dat","4b",s4);
gSerializer.ReadVariable("score.dat","5a",iHiScore[4]);
gSerializer.ReadVariable("score.dat","5b",s5);
gSerializer.ReadVariable("score.dat","6a",iHiScore[5]);
gSerializer.ReadVariable("score.dat","6b",s6);
gSerializer.ReadVariable("score.dat","7a",iHiScore[6]);
gSerializer.ReadVariable("score.dat","7b",s7);
gSerializer.ReadVariable("score.dat","8a",iHiScore[7]);
gSerializer.ReadVariable("score.dat","8b",s8);
gSerializer.ReadVariable("score.dat","9a",iHiScore[8]);
gSerializer.ReadVariable("score.dat","9b",s9);
gSerializer.ReadVariable("score.dat","10a",iHiScore[9]);
gSerializer.ReadVariable("score.dat","10b",s10);
strcpy(szHiScore[0],s1.c_str());
strcpy(szHiScore[1],s2.c_str());
strcpy(szHiScore[2],s3.c_str());
strcpy(szHiScore[3],s4.c_str());
strcpy(szHiScore[4],s5.c_str());
strcpy(szHiScore[5],s6.c_str());
strcpy(szHiScore[6],s7.c_str());
strcpy(szHiScore[7],s8.c_str());
strcpy(szHiScore[8],s9.c_str());
strcpy(szHiScore[9],s10.c_str());
}
std::pair<int, std::string> test_transitive_closure_dag(std::ostream& strm,int argc, const char *argv[])
{
std::string fn = test_path("transitive_closure_dag.dot");
size_t size = 50;
sparse_graph_t s10(size, graph_type_t::DIRECTED);
s10.insert(simple_edge_t(0,1,1));
s10.insert(simple_edge_t(0,2,1));
s10.insert(simple_edge_t(0,3,1));
s10.insert(simple_edge_t(0,5,1));
s10.insert(simple_edge_t(0,6,1));
s10.insert(simple_edge_t(2,3,1));
s10.insert(simple_edge_t(3,4,1));
s10.insert(simple_edge_t(3,5,1));
s10.insert(simple_edge_t(4,9,1));
s10.insert(simple_edge_t(6,4,1));
s10.insert(simple_edge_t(6,9,1));
s10.insert(simple_edge_t(7,6,1));
s10.insert(simple_edge_t(8,7,1));
s10.insert(simple_edge_t(9,10,1));
s10.insert(simple_edge_t(9,11,1));
s10.insert(simple_edge_t(9,12,1));
s10.insert(simple_edge_t(11,12,1));
is_dag<simple_edge_t> is_dag(s10);
ASSERT_CONDITION("graph is a DAG", is_dag());
s10.graphviz(fn);
transitive_closure<sparse_graph_t, tc_dag<simple_edge_t>> tc(s10);
std::string wts = test_path("transitive_closure_dag_results.dot");
(*tc).graphviz(wts);
ASSERT(tc(simple_edge_t(0,1,1)));
ASSERT(tc(simple_edge_t(0,12,1)))
ASSERT(tc(simple_edge_t(0,11,1)));
ASSERT(tc(simple_edge_t(8,12,1)))
ASSERT(tc(simple_edge_t(0,10,1)));
ASSERT(tc(simple_edge_t(3,4,1)))
ASSERT(!tc(simple_edge_t(1,4,1)));
ASSERT(!tc(simple_edge_t(4,1,1)))
ASSERT(tc(simple_edge_t(0,2,1)));
ASSERT(!tc(simple_edge_t(2,0,1)))
ASSERT(tc(simple_edge_t(2,4,1)));
return DONE;
}
std::pair<int, std::string> test_transitive_closure_warshall(std::ostream& strm,int argc, const char *argv[])
{
size_t size = 50;
sparse_graph_t s10(size, graph_type_t::DIRECTED);
s10.insert(simple_edge_t(0,5,1));
s10.insert(simple_edge_t(0,2,1));
s10.insert(simple_edge_t(2,1,1));
s10.insert(simple_edge_t(1,0,1));
s10.insert(simple_edge_t(5,4,1));
s10.insert(simple_edge_t(4,5,1));
s10.insert(simple_edge_t(3,4,1));
s10.insert(simple_edge_t(3,2,1));
std::string dn = test_path("transitive_closure_graph_warshall.dot");
s10.graphviz(dn);
transitive_closure<sparse_graph_t, tc_warshall<simple_edge_t>> tc(s10);
std::string wts = test_path("transitive_closure_graph_warshall_result.dot");
(*tc).graphviz(wts);
ASSERT(tc(simple_edge_t(1,2,1)));
ASSERT(tc(simple_edge_t(2,1,1)))
ASSERT(!tc(simple_edge_t(2,3,1)));
ASSERT(tc(simple_edge_t(3,2,1)))
ASSERT(tc(simple_edge_t(0,5,1)));
ASSERT(tc(simple_edge_t(5,4,1)))
ASSERT(tc(simple_edge_t(1,4,1)));
ASSERT(!tc(simple_edge_t(4,1,1)))
ASSERT(tc(simple_edge_t(0,2,1)));
ASSERT(tc(simple_edge_t(2,0,1)))
ASSERT(tc(simple_edge_t(2,4,1)));
return DONE;
}
std::pair<int, std::string> test_dag_shortest_path(std::ostream& strm,int argc, const char *argv[])
{
sparse_graph_t s10(15, graph_type_t::DIRECTED);
s10.insert(simple_edge_t(0,1,0.41));//1
s10.insert(simple_edge_t(0,7,0.41));//2
s10.insert(simple_edge_t(0,9,0.41));//3
s10.insert(simple_edge_t(1,2,0.51));//4
s10.insert(simple_edge_t(7,8,0.32));//5
s10.insert(simple_edge_t(8,2,0.32));//6
s10.insert(simple_edge_t(7,3,0.32));//7
s10.insert(simple_edge_t(6,8,0.21));//8
s10.insert(simple_edge_t(6,3,0.21));//9
s10.insert(simple_edge_t(9,4,0.29));//10
s10.insert(simple_edge_t(9,6,0.29));//11
s10.insert(simple_edge_t(5,5,0));//12
dag_all_shortest_paths<simple_edge_t> LP(s10);
LP.pp(strm);
strm << std::endl;
return DONE;
}
std::pair<int, std::string> test_dag_longest_path(std::ostream& strm,int argc, const char *argv[])
{
sparse_graph_t s10(15, graph_type_t::DIRECTED);
s10.insert(simple_edge_t(0,1,0.41));//1
s10.insert(simple_edge_t(0,7,0.41));//2
s10.insert(simple_edge_t(0,9,0.41));//3
s10.insert(simple_edge_t(1,2,0.51));//4
s10.insert(simple_edge_t(7,8,0.32));//5
s10.insert(simple_edge_t(8,2,0.32));//6
s10.insert(simple_edge_t(7,3,0.32));//7
s10.insert(simple_edge_t(6,8,0.21));//8
s10.insert(simple_edge_t(6,3,0.21));//9
s10.insert(simple_edge_t(9,4,0.29));//10
s10.insert(simple_edge_t(9,6,0.29));//11
s10.insert(simple_edge_t(5,5,0));//12
dag_all_longest_paths<simple_edge_t> LP(s10);
LP.pp(strm);
strm << "------------- distance ----------" << std::endl;
std::vector<double> expected_dist= {0, 0.41, 1.23, 0.91, 0.70,0,0.70, 0.41, 0.91,0.41};
size_t index = expected_dist.size();
while (index-- > 0 ) {
strm << "index : " << index << " expected : " << expected_dist[index] << " found : " << LP.dist(index) << std::endl;
ASSERT(LP.dist(index).second && abs(LP.dist(index).first - expected_dist[index]) < 0.0001);
}
strm << "------------ predecessor ---------" << std::endl;
std::vector<typename simple_edge_t::label_value_type> expected_pred = {0, 0, 8, 6, 9, 5, 9, 0, 6, 0};
index = expected_pred.size();
while (index-- > 0 ) {
strm << "index : " << index << " expected : " << expected_pred[index] << " found : " << LP.pred(index) << std::endl;
ASSERT(LP.pred(index).second && LP.pred(index).first == expected_pred[index]);
}
strm << std::endl;
return DONE;
}
/*----------------------------------------------------------------
main
-----------------------------------------------------------------*/
void test1() {
const char *j = "jag";
cout << "length of j = " << strlen(j) << endl;
str s1('U', verbose);
str s2("jag", verbose);
cout << s2 << endl;
s2.reverse();
cout << s2 << endl;
str s3(s2);
cout << s1 << endl;
cout << s2 << endl;
cout << s3 << endl;
s2 = s1;
cout << s2 << endl;
cout << s1 << endl;
if (s1 == s2) {
cout << "s1 == s2" << endl;
}
if (s1 != s3) {
cout << "s1 != s3" << endl;
}
str s10("abcd", verbose);
str s11("abc", verbose);
int x = string_compare(s10, s11);
s3 = 'a' + s1;
cout << "s1 = " << s1 << endl;
cout << "s3 = " << s3 << endl;
s3 = s1 + 'p';
cout << "s3 = " << s3 << endl;
//s3 = "abc" + "123" ;
// You cannot do this. At least one in RHS must be str
s3 = str("abc") + "123";
cout << "s3 = " << s3 << endl;
s1 = "++";
s2 = "Claaaa";
cout << "Jag " << 'C' + s1 + '+' + '+' + ' ' << s2 << "s" << endl;
}
std::pair<int, std::string> test_transitive_closure_kernel_dag(std::ostream& strm,int argc, const char *argv[])
{
size_t size = 50;
sparse_graph_t s10(size, graph_type_t::DIRECTED);
s10.insert(simple_edge_t(0,5,1));
s10.insert(simple_edge_t(0,2,1));
s10.insert(simple_edge_t(2,1,1));
s10.insert(simple_edge_t(1,0,1));
s10.insert(simple_edge_t(5,4,1));
s10.insert(simple_edge_t(4,5,1));
s10.insert(simple_edge_t(3,4,1));
s10.insert(simple_edge_t(3,2,1));
std::string dn = test_path("transitive_closure_kernel_dag.dot");
s10.graphviz(dn);
tc_kernel_dag<simple_edge_t> tc(s10);
//tc.pp(strm);
ASSERT(tc(simple_edge_t(1,2,1)));
ASSERT(tc(simple_edge_t(2,1,1)))
ASSERT(!tc(simple_edge_t(2,3,1)));
ASSERT(tc(simple_edge_t(3,2,1)))
ASSERT(tc(simple_edge_t(0,5,1)));
ASSERT(tc(simple_edge_t(5,4,1)))
ASSERT(tc(simple_edge_t(1,4,1)));
ASSERT(!tc(simple_edge_t(4,1,1)))
ASSERT(tc(simple_edge_t(0,2,1)));
ASSERT(tc(simple_edge_t(2,0,1)))
ASSERT(tc(simple_edge_t(2,4,1)));
return DONE;
}
String AirDC::OutputSerial(int mode)
{
String StreamOut;
switch(mode)
{
case 1: //Measurements output
{
//_p,_T,_RH,_qc,AOA,AOS
String s1(_p, 6);
String s2(_T, 6);
String s3(_RH, 6);
String s4(_qc, 6);
String s5(_AOA, 6);
String s6(_AOS, 6);
StreamOut="$TMO,"+s1+','+s2+','+s3+','+s4+','+s5+','+s6;
//To read string on the other side
/*
if (Serial.find("$TMO,")) {
_p = Serial.parseFloat(); //
_T = Serial.parseFloat();//
_RH = Serial.parseFloat();//
_qc = Serial.parseFloat();//
*/
break;
}
case 2: //Air data output
//_Rho,_IAS,_CAS,_TAS,_TASPCorrected,_M,_TAT,_h,_mu,_Re
{
String s1(_Rho, 6);
String s2(_IAS, 6);
String s3(_CAS, 6);
String s4(_TAS, 6);
String s5(_TASPCorrected, 6);
String s6(_M, 6);
String s7(_TAT, 6);
String s8(_h, 6);
String s9(_mu, 8);
String s10(_Re, 6);
StreamOut="$TAD,"+s1+','+s2+','+s3+','+s4+','+s5+','+s6+','+s7+','+s8+','+s9+','+s10;
break;
}
case 3: //Measurements uncertainty output
//_up,_uT,_uRH,_uqc
{
String s1(_up, 6);
String s2(_uT, 6);
String s3(_uRH, 6);
String s4(_uqc, 6);
StreamOut="$TMU,"+s1+','+s2+','+s3+','+s4;
break;
}
case 4: //Air data uncertainty output
//_uRho,_uIAS,_uCAS,_uTAS,_uTAT,_uh;
{
String s1(_uRho, 6);
String s2(_uIAS, 6);
String s3(_uCAS, 6);
String s4(_uTAS, 6);
String s5(_uTAT, 6);
String s6(_uh, 6);
StreamOut="$TAU,"+s1+','+s2+','+s3+','+s4+','+s5+','+s6;
break;
}
case 51: //Output for Temperature Logger Example
{
String s1(_Rho, 6);
String s2(_TAT, 2);
String s3(_TAT-273.15, 2);
String s4(_uTAT, 2);
String s5(_p, 2);
String s6(_mu, 6);
String s7(hour());
String s8(minute());
String s9(second());
String s10(month());
String s11(day());
String s12(year());
String s13(millis());
StreamOut="$TEX,"+s1+','+s2+','+s3+','+s4+','+s5+','+s6+','+s7+','+s8+','+s9+','+s10+','+s11+','+s12+','+s13;
break;
}
return StreamOut;
}
}
void V3TSP::selfTestStates() {
// Linear test -- coords all along the x-axis
{
V3TSP::StateVec states;
TspTestState s10(10,0);
TspTestState s60(60,0);
TspTestState s20(20,0);
TspTestState s100(100,0);
TspTestState s5(5,0);
states.push_back(&s10);
states.push_back(&s60);
states.push_back(&s20);
states.push_back(&s100);
states.push_back(&s5);
V3TSP::StateVec result;
tspSort(states, &result);
V3TSP::StateVec expect;
expect.push_back(&s100);
expect.push_back(&s60);
expect.push_back(&s20);
expect.push_back(&s10);
expect.push_back(&s5);
if (expect != result) {
for (V3TSP::StateVec::iterator it = result.begin();
it != result.end(); ++it) {
const TspTestState* statep = dynamic_cast<const TspTestState*>(*it);
cout<<statep->xpos()<<" ";
}
cout<<endl;
v3fatalSrc("TSP linear self-test fail. Result (above) did not match expectation.");
}
}
// Second test. Coords are distributed in 2D space.
// Test that tspSort() will rotate the list for minimum cost.
{
V3TSP::StateVec states;
TspTestState a(0,0);
TspTestState b(100,0);
TspTestState c(200,0);
TspTestState d(200,100);
TspTestState e(150,150);
TspTestState f(0,150);
TspTestState g(0,100);
states.push_back(&a);
states.push_back(&b);
states.push_back(&c);
states.push_back(&d);
states.push_back(&e);
states.push_back(&f);
states.push_back(&g);
V3TSP::StateVec result;
tspSort(states, &result);
V3TSP::StateVec expect;
expect.push_back(&f);
expect.push_back(&g);
expect.push_back(&a);
expect.push_back(&b);
expect.push_back(&c);
expect.push_back(&d);
expect.push_back(&e);
if (expect != result) {
for (V3TSP::StateVec::iterator it = result.begin();
it != result.end(); ++it) {
const TspTestState* statep = dynamic_cast<const TspTestState*>(*it);
cout<<statep->xpos()<<","<<statep->ypos()<<" ";
}
cout<<endl;
v3fatalSrc("TSP 2d cycle=false self-test fail. Result (above) did not match expectation.");
}
}
}
bool append_test( )
{
bool rc = true;
// The sizes of the test strings used here are intended to explore
// both appending without reallocation and appending with re-
// allocation. A string can not be reused between tests because
// an enlarged capacity is never reduced.
std::string s1( "123456" );
std::string s2( "x" );
s1 += s2;
if( s1 != "123456x" || s1.size( ) != 7 || INSANE( s1 ) ) FAIL
s1 += s2;
if( s1 != "123456xx" || s1.size( ) != 8 || INSANE( s1 ) ) FAIL
std::string s3( "123456" );
s3 += "x";
if( s3 != "123456x" || s3.size( ) != 7 || INSANE( s3 ) ) FAIL
s3 += "y";
if( s3 != "123456xy" || s3.size( ) != 8 || INSANE( s3 ) ) FAIL
std::string s4( "123456" );
s4 += 'x';
if( s4 != "123456x" || s4.size( ) != 7 || INSANE( s4 ) ) FAIL
s4 += 'z';
if( s4 != "123456xz" || s4.size( ) != 8 || INSANE( s4 ) ) FAIL
std::string s5( "123456" );
std::string s6( "Hello, World!" );
s5.append( s6, 12, 1 );
if( s5 != "123456!" || s5.size( ) != 7 || INSANE( s5 ) ) FAIL
s5.append( s6, 0, 3 );
if( s5 != "123456!Hel" || s5.size( ) != 10 || INSANE( s5 ) ) FAIL
std::string s7( "123456" );
s7.append( "fizzle", 1 );
if( s7 != "123456f" || s7.size( ) != 7 || INSANE( s7 ) ) FAIL
s7.append( "fizzle", 3 );
if( s7 != "123456ffiz" || s7.size( ) != 10 || INSANE( s7 ) ) FAIL
std::string s8( "123456" );
s8.append( "x" );
if( s8 != "123456x" || s8.size( ) != 7 || INSANE( s8 ) ) FAIL
s8.append( "abc" );
if( s8 != "123456xabc" || s8.size( ) != 10 || INSANE( s8 ) ) FAIL
std::string s9( "123456" );
s9.append( 1, 'x' );
if( s9 != "123456x" || s9.size( ) != 7 || INSANE( s9 ) ) FAIL
s9.append( 3, 'y' );
if( s9 != "123456xyyy" || s9.size( ) != 10 || INSANE( s9 ) ) FAIL
std::string s10( "123456" );
s10.push_back( 'z' );
if( s10 != "123456z" || s10.size( ) != 7 || INSANE( s10 ) ) FAIL
s10.push_back( 'a' );
if( s10 != "123456za" || s10.size( ) != 8 || INSANE( s10 ) ) FAIL
return( rc );
}
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("SString_Test"));
{
/* Set #1 */
ACE_CString s0 ("hello");
ACE_CString s1 ("hello");
ACE_CString s2 ("world");
ACE_CString s3 ("ll");
ACE_CString s4 ("ello");
ACE_CString s5 = s1 + " " + s2;
char single_character = 'z';
ACE_CString single_character_string (single_character);
ACE_CString empty_string;
ACE_CString zero_size_string (s1.c_str (), 0, 0, 1);
if (ACE_CString::npos == 0)
ACE_ERROR((LM_ERROR,"Set #1: npos is incorrect.\n"));
// Not equal comparisons. Error if they are equal
if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1 == s5){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
// Equal comparisons. Error if they are not equal
if (s1 != s1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1 != s0){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
// Substring match. Error if they are not equal
if (s1.strstr (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1.strstr (s3) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s3.strstr (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1.strstr (s4) != 1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
// Substring creation. Error if they are not equal
if (s1.substring (0) != s1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1.substring (1) != s4){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1.substring (2, 2) != s3){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1.substring (0, 0) != empty_string){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1.substring (4, 10).length () != 1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
// Forward search. Error if they are not equal
if (s1.find (s3) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s3.find (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1.find (s3, 2) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s3.find (s1, 1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1.find (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1.find ('o') != 4){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
// Reverse search. Error if they are not equal
if (s1.rfind ('l') != 3){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
if (s1.rfind ('l', 3) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
// Assignment. Error if they are not equal
ACE_CString s6;
s6 = s0;
if (s6 != s0){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
s6 = s4;
if (s4 != s6){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
s6 = s5;
if (s6 != s5){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
}
{
/* Set #2 */
ACE_CString s0 = "hello";
ACE_CString s1 ("hello", 0, false);
ACE_CString s2 ("world", 0, false);
ACE_CString s3 ("ll", 0, false);
ACE_CString s4 ("ello", 0, false);
ACE_CString s5 = s1 + " " + s2;
char single_character = 'z';
ACE_CString single_character_string (single_character);
ACE_CString empty_string (0, 0, false);
ACE_CString zero_size_string (s1.c_str (), 0, 0, false);
// Not equal comparisons. Error if they are equal
if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1 == s5){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
// Equal comparisons. Error if they are not equal
if (s1 != s1){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1 != s0){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
// Substring match. Error if they are not equal
if (s1.strstr (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1.strstr (s3) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s3.strstr (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1.strstr (s4) != 1){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
// Substring creation. Error if they are not equal
if (s1.substring (0) != s1){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1.substring (1) != s4){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1.substring (2, 2) != s3){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1.substring (0, 0) != empty_string){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
// Forward search. Error if they are not equal
if (s1.find (s3) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s3.find (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1.find (s3, 2) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s3.find (s1, 1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1.find (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1.find ('o') != 4){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
// Reverse search. Error if they are not equal
if (s1.rfind ('l') != 3){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
if (s1.rfind ('l', 3) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
// Assignment. Error if they are not equal
ACE_CString s6;
s6 = s0;
if (s6 != s0){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
s6 = s4;
if (s4 != s6){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
s6 = s5;
if (s6 != s5){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
// Clear. Error if they are not equal
s0.clear();
if (s0.length() != 0){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
// Rep. Error if they are not equal
ACE_Auto_Basic_Array_Ptr<char> s (s1.rep ());
if (ACE_OS::strlen (s.get ()) != s1.length ())
{
ACE_ERROR((LM_ERROR,"Auto_ptr s:\n"));
};
ACE_CString s7 (s.get ());
if (s1 != s7){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
}
{
/* Set #3 */
ACE_NS_WString s0 ("hello");
ACE_NS_WString s1 ("hello");
ACE_NS_WString s2 ("world");
ACE_NS_WString s3 ("ll");
ACE_NS_WString s4 ("ello");
ACE_NS_WString s5 = s1 + " " + s2;
ACE_NS_WString s6 = ("hella"); // Same length as s1, off by one char.
ACE_WCHAR_T single_character = 'z';
ACE_NS_WString single_character_string (single_character);
ACE_NS_WString empty_string;
ACE_NS_WString zero_size_string (s1.c_str (), 0, 0);
// Not equal comparisons. Error if they are equal
if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1 == s5){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1 == s6){ACE_ERROR((LM_ERROR,"Set #3: off-by-one failed\n"));return 1;}
// Equal comparisons. Error if they are not equal
if (s1 != s1){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1 != s0){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
// Substring match. Error if they are not equal
if (s1.strstr (s2) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1.strstr (s3) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s3.strstr (s1) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1.strstr (s4) != 1){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
// Substring creation. Error if they are not equal
if (s1.substring (0) != s1){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1.substring (1) != s4){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1.substring (2, 2) != s3){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1.substring (0, 0) != empty_string){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
// Forward search. Error if they are not equal
if (s1.find (s3) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s3.find (s1) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1.find (s3, 2) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s3.find (s1, 1) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1.find (s2) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1.find ('o') != 4){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
// Reverse search. Error if they are not equal
if (s1.rfind ('l') != 3){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
if (s1.rfind ('l', 3) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
// Assignment. Error if they are not equal
ACE_NS_WString s7;
s7 = s0;
if (s7 != s0){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
s7 = s4;
if (s4 != s7){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
s7 = s5;
if (s7 != s5){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
// Clear. Error if they are not equal
s0.clear();
if (s0.length() != 0){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
}
{
/* Set #4 */
ACE_CString s1("dog");
ACE_CString s2("d");
if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if (!(s1 > s2)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if (s1 < s2){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
ACE_CString s3 ("dog");
ACE_CString s4 ("dogbert");
if (s3 == s4){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if (!(s3 < s4)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if (s3 > s4){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
ACE_CString s5 ("dogbert",3);
ACE_CString s6 ("dogbert",5);
if(s5 == s6){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if(!(s5 < s6)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if(s5 > s6){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
ACE_CString s7 ("dogbert",4);
ACE_CString s8 ("dogbert",2);
if(s7 == s8){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if(!(s7 > s8)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if(s7 < s8){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
ACE_CString s9 ("dogbert",3);
ACE_CString s10 ("dogbert");
if(s9 == s10){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if(!(s9 < s10)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if(s9 > s10){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
ACE_CString s11 ("dogbert",5);
ACE_CString s12 ("dog");
if(s11 == s12){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if(!(s11 > s12)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
if(s11 < s12){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
s11.fast_clear ();
if (s11.length () != 0)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("fast_clear didn't yield 0 length\n")));
}
{
// Set 1 for ACE_SString, which is not tested
ACE_SString sstr;
const char *old = sstr.rep ();
const char *str = "What_a_day_it_has_been";
sstr.rep (const_cast<char *>(str));
ACE_SString tmp =
sstr.substring (2, 300);
if (tmp.length () == 300)
ACE_ERROR ((LM_ERROR, "SString substring\n"));
// Constring an ACE_SString without a character pointer or from an
// existing ACE_SString causes memory to be allocated that will not
// be delete (apparently by design).
ACE_Allocator::instance ()->free (const_cast<char *> (old));
ACE_Allocator::instance ()->free (const_cast<char *> (tmp.rep ()));
}
int err = testConcatenation ();
err += testIterator ();
err += testConstIterator ();
ACE_END_TEST;
return err;
}
std::pair<int, std::string> test_bfs(std::ostream& strm,int argc, const char *argv[])
{
sparse_graph_t s10(20, graph_type_t::UNDIRECTED);
//DIRECTED GRAPH fig. 19.1 p 149
s10.insert(simple_edge_t(0,1,1));//1
s10.insert(simple_edge_t(0,2,1));//2
s10.insert(simple_edge_t(0,3,1));//3
s10.insert(simple_edge_t(0,5,1));//1
s10.insert(simple_edge_t(0,6,1));//2
s10.insert(simple_edge_t(2,3,1));//5
s10.insert(simple_edge_t(3,4,1));//6
s10.insert(simple_edge_t(3,5,1));//7
s10.insert(simple_edge_t(6,4,1));//12
s10.insert(simple_edge_t(6,9,1));//13
s10.insert(simple_edge_t(7,6,1));//16
s10.insert(simple_edge_t(8,7,1));//16
s10.insert(simple_edge_t(4,2,1));//9
s10.insert(simple_edge_t(4,11,1));//10
s10.insert(simple_edge_t(5,4,1));//11
s10.insert(simple_edge_t(9,10,1));//18
s10.insert(simple_edge_t(9,11,1));//19
s10.insert(simple_edge_t(11,12,1));//21
simple_bfs bfs(s10);
bfs();
std::string dn = test_path("bfs_graph.dot");
s10.graphviz(dn);
auto p = bfs.property<parent_t>(3);
strm << "parent of 3 : " << p << std::endl;
p = bfs.property<parent_t>(11);
strm << "parent of 11 : " << p << std::endl;
p = property<simple_edge_t, parent_t>(bfs, 12);
strm << "parent of 12 : " << p << std::endl;
size_t depth = 0;
typename simple_edge_t::label_value_type s = 0;
typename simple_edge_t::label_value_type t = 12;
strm << "start from : " << t << " -> ";
while (t != s) {
t = bfs.property<parent_t>(t);
strm << t;
if (t != s) strm << " -> ";
depth++;
}
ASSERT(depth == 4);
strm << std::endl;
//typename simple_edge_t::label_value_type
t = 8;
depth = 0;
strm << "start from : " << t << " -> ";
while (t != s) {
t = bfs.property<parent_t>(t);
strm << t;
if (t != s) strm << " -> ";
depth++;
}
strm << std::endl;
ASSERT(depth == 3);
ASSERT(bfs.property<parent_t>(12) == 11);
ASSERT(bfs.property<parent_t>(10) == 9);
ASSERT(bfs.property<parent_t>(5) == 0);
if (property<simple_edge_t, parent_t>(bfs,5) != 0) {
ASSERT(1==5);
}
strm << ".........done............." << std::endl;
return DONE;
}
