void FourNodeQuadUP::setPressureLoadAtNodes(void)
{
pressureLoad.Zero();
if (pressure == 0.0)
return;
const Vector &node1 = nd1Ptr->getCrds();
const Vector &node2 = nd2Ptr->getCrds();
const Vector &node3 = nd3Ptr->getCrds();
const Vector &node4 = nd4Ptr->getCrds();
double x1 = node1(0);
double y1 = node1(1);
double x2 = node2(0);
double y2 = node2(1);
double x3 = node3(0);
double y3 = node3(1);
double x4 = node4(0);
double y4 = node4(1);
double dx12 = x2-x1;
double dy12 = y2-y1;
double dx23 = x3-x2;
double dy23 = y3-y2;
double dx34 = x4-x3;
double dy34 = y4-y3;
double dx41 = x1-x4;
double dy41 = y1-y4;
double pressureOver2 = pressure*thickness/2.0;
// Contribution from side 12
pressureLoad(0) += pressureOver2*dy12;
pressureLoad(3) += pressureOver2*dy12;
pressureLoad(1) += pressureOver2*-dx12;
pressureLoad(4) += pressureOver2*-dx12;
// Contribution from side 23
pressureLoad(3) += pressureOver2*dy23;
pressureLoad(6) += pressureOver2*dy23;
pressureLoad(4) += pressureOver2*-dx23;
pressureLoad(7) += pressureOver2*-dx23;
// Contribution from side 34
pressureLoad(6) += pressureOver2*dy34;
pressureLoad(9) += pressureOver2*dy34;
pressureLoad(7) += pressureOver2*-dx34;
pressureLoad(10) += pressureOver2*-dx34;
// Contribution from side 41
pressureLoad(9) += pressureOver2*dy41;
pressureLoad(0) += pressureOver2*dy41;
pressureLoad(10) += pressureOver2*-dx41;
pressureLoad(1) += pressureOver2*-dx41;
//pressureLoad = pressureLoad*thickness;
}
int main()
{
Graph g;
Node node1(1), node2(2), node3(3), node4(4), node5(5), node6(6), node7(7), node8(8), node9(9);
g.insert (Graph::value_type(node1, node3));
g.insert (Graph::value_type(node1, node4));
g.insert (Graph::value_type(node1, node5));
g.insert (Graph::value_type(node2, node6));
g.insert (Graph::value_type(node3, node6));
g.insert (Graph::value_type(node4, node7));
g.insert (Graph::value_type(node5, node7));
g.insert (Graph::value_type(node5, node8));
g.insert (Graph::value_type(node5, node9));
g.insert (Graph::value_type(node9, node5));
Graph::key_compare cmp = g.key_comp();
Graph::const_iterator it = g.begin(), itEnd = g.end(), prev;
while (it != itEnd)
{
std::cout << it->first << ": "; // print vertex
do
{
std::cout << it->second << ", "; // print adjacent vertices
prev = it++;
}
while (it != itEnd && !cmp(prev->first, it->first) && !cmp(it->first, prev->first));
std::cout << std::endl;
}
}
int main()
{
Graph g;
Node node1(1), node2(2), node3(3), node4(4), node5(5), node6(6), node7(7), node8(8), node9(9);
g.insert (Graph::value_type(node1, node3));
g.insert (Graph::value_type(node1, node4));
g.insert (Graph::value_type(node1, node5));
g.insert (Graph::value_type(node2, node6));
g.insert (Graph::value_type(node3, node6));
g.insert (Graph::value_type(node4, node7));
g.insert (Graph::value_type(node5, node7));
g.insert (Graph::value_type(node5, node8));
g.insert (Graph::value_type(node5, node9));
g.insert (Graph::value_type(node9, node5));
Graph::const_iterator it = g.begin();
while (it != g.end())
{
std::pair<Graph::const_iterator, Graph::const_iterator> range = g.equal_range(it->first);
std::cout << it->first << ": "; // print vertex
for (; range.first != range.second; ++range.first)
{
std::cout << range.first->second << ", "; // print adjacent vertices
}
std::cout << std::endl;
it = range.second;
}
}
void TestSortList() {
SortList::ListNode node4(1);
SortList::ListNode node3(2);
node3.next = &node4;
SortList::ListNode node2(3);
node2.next = &node3;
SortList::ListNode node1(4);
node1.next = &node2;
SortList::SolutionSortList so;
SortList::ListNode *newhead = so.sortList(&node1);
node4.next = &node2;
node2.next = &node3;
node3.next = nullptr;
newhead = so.sortList(&node4);//1,3,2
SortList::ListNode n1(1);
SortList::ListNode n2(2);
n2.next = &n1;
SortList::ListNode n3(3);
n3.next = &n2;
SortList::ListNode n4(4);
n4.next = &n3;
SortList::ListNode n5(5);
n5.next = &n4;
newhead = so.sortList(&n5);
}
void main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
r1 = __VERIFIER_nondet_char();
id1 = __VERIFIER_nondet_char();
st1 = __VERIFIER_nondet_char();
send1 = __VERIFIER_nondet_msg_t();
mode1 = __VERIFIER_nondet__Bool();
alive1 = __VERIFIER_nondet__Bool();
id2 = __VERIFIER_nondet_char();
st2 = __VERIFIER_nondet_char();
send2 = __VERIFIER_nondet_msg_t();
mode2 = __VERIFIER_nondet__Bool();
alive2 = __VERIFIER_nondet__Bool();
id3 = __VERIFIER_nondet_char();
st3 = __VERIFIER_nondet_char();
send3 = __VERIFIER_nondet_msg_t();
mode3 = __VERIFIER_nondet__Bool();
alive3 = __VERIFIER_nondet__Bool();
id4 = __VERIFIER_nondet_char();
st4 = __VERIFIER_nondet_char();
send4 = __VERIFIER_nondet_msg_t();
mode4 = __VERIFIER_nondet__Bool();
alive4 = __VERIFIER_nondet__Bool();
i2 = init();
__VERIFIER_assume(i2);
p1_old = nomsg;
p1_new = nomsg;
p2_old = nomsg;
p2_new = nomsg;
p3_old = nomsg;
p3_new = nomsg;
p4_old = nomsg;
p4_new = nomsg;
i2 = 0;
while (i2 < 8) {
{
node1();
node2();
node3();
node4();
p1_old = p1_new;
p1_new = nomsg;
p2_old = p2_new;
p2_new = nomsg;
p3_old = p3_new;
p3_new = nomsg;
p4_old = p4_new;
p4_new = nomsg;
c1 = check();
assert(c1);
i2 ++;
}
}
}
}
void runWayTest()
{
PoiPolygonAddressScoreExtractor uut;
uut.setConfiguration(conf());
OsmMapPtr map(new OsmMap());
NodePtr node1(new Node(Status::Unknown1, -1, Coordinate(0.0, 0.0), 15.0));
node1->getTags().set(TestUtils::HOUSE_NUMBER_TAG_NAME, "123");
node1->getTags().set(TestUtils::STREET_TAG_NAME, "Main Street");
map->addNode(node1);
WayPtr way1(new Way(Status::Unknown2, -1, 15.0));
NodePtr node2(new Node(Status::Unknown1, -2, Coordinate(0.0, 0.0), 15.0));
node2->getTags().set(TestUtils::HOUSE_NUMBER_TAG_NAME, "123");
node2->getTags().set(TestUtils::STREET_TAG_NAME, "main street");
map->addNode(node2);
way1->addNode(node2->getId());
map->addWay(way1);
CPPUNIT_ASSERT_DOUBLES_EQUAL(1.0, uut.extract(*map, node1, way1), 0.0);
NodePtr node3(new Node(Status::Unknown1, -3, Coordinate(0.0, 0.0), 15.0));
node3->getTags().set(TestUtils::HOUSE_NUMBER_TAG_NAME, "123");
node3->getTags().set(TestUtils::STREET_TAG_NAME, "Main Street");
map->addNode(node3);
WayPtr way2(new Way(Status::Unknown2, -2, 15.0));
NodePtr node4(new Node(Status::Unknown2, -4, Coordinate(0.0, 0.0), 15.0));
node4->getTags().set(TestUtils::HOUSE_NUMBER_TAG_NAME, "567");
node4->getTags().set(TestUtils::STREET_TAG_NAME, "first street");
map->addNode(node4);
way2->addNode(node4->getId());
map->addWay(way2);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.0, uut.extract(*map, node3, way2), 0.01);
}
void runAltFormatTest()
{
PoiPolygonAddressScoreExtractor uut;
uut.setConfiguration(conf());
OsmMapPtr map(new OsmMap());
NodePtr node1(new Node(Status::Unknown1, -1, Coordinate(0.0, 0.0), 15.0));
node1->getTags().set(
TestUtils::FULL_ADDRESS_TAG_NAME_2, "Main Street 123 20121 mytown");
map->addNode(node1);
WayPtr way1(new Way(Status::Unknown2, -1, 15.0));
way1->getTags().set(TestUtils::FULL_ADDRESS_TAG_NAME_2, "main street 123");
map->addWay(way1);
CPPUNIT_ASSERT_DOUBLES_EQUAL(1.0, uut.extract(*map, node1, way1), 0.0);
NodePtr node2(new Node(Status::Unknown1, -2, Coordinate(0.0, 0.0), 15.0));
node2->getTags().set(
TestUtils::FULL_ADDRESS_TAG_NAME_2, "Main Street 123 20121 mytown");
map->addNode(node2);
WayPtr way2(new Way(Status::Unknown2, -2, 15.0));
way2->getTags().set(
TestUtils::FULL_ADDRESS_TAG_NAME_2, "first street 567");
map->addWay(way2);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.0, uut.extract(*map, node2, way2), 0.01);
NodePtr node3(new Node(Status::Unknown1, -1, Coordinate(0.0, 0.0), 15.0));
node3->getTags().set(
TestUtils::FULL_ADDRESS_TAG_NAME_2, "ZENTRALLÄNDSTRASSE 40 81379 MÜNCHEN");
map->addNode(node3);
WayPtr way3(new Way(Status::Unknown2, -1, 15.0));
way3->getTags().set(TestUtils::FULL_ADDRESS_TAG_NAME_2, "40 ZENTRALLÄNDSTRASSE");
map->addWay(way3);
CPPUNIT_ASSERT_DOUBLES_EQUAL(1.0, uut.extract(*map, node3, way3), 0.0);
}
void
Tri31::setPressureLoadAtNodes(void)
{
pressureLoad.Zero();
if (pressure == 0.0) return;
const Vector &node1 = theNodes[0]->getCrds();
const Vector &node2 = theNodes[1]->getCrds();
const Vector &node3 = theNodes[2]->getCrds();
double x1 = node1(0);
double y1 = node1(1);
double x2 = node2(0);
double y2 = node2(1);
double x3 = node3(0);
double y3 = node3(1);
double dx12 = x2-x1;
double dy12 = y2-y1;
double dx23 = x3-x2;
double dy23 = y3-y2;
double dx31 = x1-x3;
double dy31 = y1-y3;
double pressureOver2 = pressure/2.0;
// Contribution from side 12
pressureLoad(0) += pressureOver2*dy12;
pressureLoad(2) += pressureOver2*dy12;
pressureLoad(1) += pressureOver2*-dx12;
pressureLoad(3) += pressureOver2*-dx12;
// Contribution from side 23
pressureLoad(2) += pressureOver2*dy23;
pressureLoad(4) += pressureOver2*dy23;
pressureLoad(3) += pressureOver2*-dx23;
pressureLoad(5) += pressureOver2*-dx23;
// Contribution from side 31
pressureLoad(4) += pressureOver2*dy31;
pressureLoad(0) += pressureOver2*dy31;
pressureLoad(5) += pressureOver2*-dx31;
pressureLoad(1) += pressureOver2*-dx31;
//pressureLoad = pressureLoad*thickness;
}
Node *stat3(int a, Node *b, Node *c, Node *d)
{
Node *x;
x = node3(a,b,c,d);
x->ntype = NSTAT;
return(x);
}
Node *op3(int a, Node *b, Node *c, Node *d)
{
Node *x;
x = node3(a,b,c,d);
x->ntype = NEXPR;
return(x);
}
int main()
{
ListNode node1(1); ListNode node2(2); ListNode node3(3);
ListNode node4(4); ListNode node5(5);
node1.next = &node2; node2.next = &node3;
node3.next = &node4; node4.next = &node5;
Solution s;
print(s.rotateRight(&node1, 2));
return 0;
}
TEST(L124, normal)
{
std::shared_ptr<TreeNode> node1(new TreeNode(1));
std::shared_ptr<TreeNode> node2(new TreeNode(2));
std::shared_ptr<TreeNode> node3(new TreeNode(3));
Solution solution;
ASSERT_EQ(1, solution.maxPathSum(node1.get()));
node1->val = -3;
ASSERT_EQ(-3, solution.maxPathSum(node1.get()));
node1->val = 2;
node2->val = -1;
node1->left = node2.get();
node1->right = 0;
ASSERT_EQ(2, solution.maxPathSum(node1.get()));
node1->val = -2;
node3->val = -3;
node1->right = node3.get();
node1->left = 0;
ASSERT_EQ(-2, solution.maxPathSum(node1.get()));
node1->val = 2;
node2->val = -1;
node3->val = 2;
node1->right = node3.get();
node1->left = node2.get();
ASSERT_EQ(4, solution.maxPathSum(node1.get()));
node1->val = 5;
node2->val = 4;
node3->val = 8;
std::shared_ptr<TreeNode> node4(new TreeNode(11));
std::shared_ptr<TreeNode> node5(new TreeNode(13));
std::shared_ptr<TreeNode> node6(new TreeNode(4));
std::shared_ptr<TreeNode> node7(new TreeNode(7));
std::shared_ptr<TreeNode> node8(new TreeNode(2));
std::shared_ptr<TreeNode> node9(new TreeNode(5));
std::shared_ptr<TreeNode> node10(new TreeNode(1));
node2->left = node4.get();
node3->left = node5.get();
node3->right = node6.get();
node4->left = node7.get();
node4->right = node8.get();
node6->left = node9.get();
node6->right = node10.get();
ASSERT_EQ(48, solution.maxPathSum(node1.get()));
}
int main(int argc, char* argv[])
{
Solution solution1;
ListNode node1(1);
ListNode node2(2);
ListNode node3(3);
ListNode node4(4);
node1.next = &node2;
node3.next = &node4;
ListNode* merged_list = solution1.mergeTwoLists(NULL, &node3);
PrintList(merged_list);
return 0;
}
int main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
r1 = __VERIFIER_nondet_uchar();
id1 = __VERIFIER_nondet_char();
st1 = __VERIFIER_nondet_char();
send1 = __VERIFIER_nondet_char();
mode1 = __VERIFIER_nondet_bool();
alive1 = __VERIFIER_nondet_bool();
id2 = __VERIFIER_nondet_char();
st2 = __VERIFIER_nondet_char();
send2 = __VERIFIER_nondet_char();
mode2 = __VERIFIER_nondet_bool();
alive2 = __VERIFIER_nondet_bool();
id3 = __VERIFIER_nondet_char();
st3 = __VERIFIER_nondet_char();
send3 = __VERIFIER_nondet_char();
mode3 = __VERIFIER_nondet_bool();
alive3 = __VERIFIER_nondet_bool();
i2 = init();
__VERIFIER_assume(i2);
p1_old = nomsg;
p1_new = nomsg;
p2_old = nomsg;
p2_new = nomsg;
p3_old = nomsg;
p3_new = nomsg;
i2 = 0;
while (1) {
{
node1();
node2();
node3();
p1_old = p1_new;
p1_new = nomsg;
p2_old = p2_new;
p2_new = nomsg;
p3_old = p3_new;
p3_new = nomsg;
c1 = check();
assert(c1);
}
}
}
return 0;
}
int main(){
TreeLinkNode node1(1);
TreeLinkNode node2(2);
TreeLinkNode node3(3);
TreeLinkNode node4(4);
TreeLinkNode node5(5);
node1.left=&node2;
node1.left->left=&node4;
node1.right=&node3;
node1.right->right=&node5;
Solution so;
so.connect(&node1);
}
int main()
{
Solution s;
{
TreeNode node1(1);
print(s.levelOrder(&node1));
}
{
TreeNode node1(3); TreeNode node2(9); TreeNode node3(20);
TreeNode node4(15); TreeNode node5(7);
node1.left = &node2; node1.right = &node3;
node3.left = &node4; node3.right = &node5;
print(s.levelOrder(&node1));
}
return 0;
}
int node(const char *name)
{
int sock;
if (!strcmp(name, "node0")) {
sock = node0();
} else if (!strcmp(name, "node1")) {
sock = node1();
} else if (!strcmp(name, "node2")) {
sock = node2();
} else if (!strcmp(name, "node3")) {
sock = node3();
} else {
return -1;
}
return bus_on(sock, name);
}
int main(){
jobNode node1(1, 10);
jobNode node2(3, 12);
jobNode node3(2, 11);
std::cout<<"node1: "<<node1<<std::endl;
std::cout<<"node2: "<<node2<<std::endl;
std::cout<<"node3: "<<node3<<std::endl;
std::cout<<"node1 < node2: "<<(node1<node2)<<std::endl;
std::cout<<"node2 < node3: "<<(node2<node3)<<std::endl;
std::cout<<"node1 > node2: "<<(node1>node2)<<std::endl;
std::cout<<"node2 > node3: "<<(node2>node3)<<std::endl;
jobNode node4 = node3;
std::cout<<"node4 = "<<node4<<std::endl;
return 0;
}
//! [3]
void SceneElement::buildGeometry(int divisions, qreal scale)
{
qreal cw = cross_width;
qreal bt = bar_thickness;
qreal ld = logo_depth;
//qreal th = tee_height;
NodeEntity node1(geom, cw, bt, ld);
NodeEntity node2(geom, cw, bt, ld);
NodeEntity node3(geom, cw, bt, ld);
//RectPrism stem(geom, bt, th, ld);
//RectPrism cross1(geom, cw+3, bt+3, ld+3);
//RectPrism stem1(geom, bt+4, th+4, ld+4);
//RectPrism cross2(geom, cw+5, bt+5, ld+5);
//RectPrism stem2(geom, bt+6, th+6, ld+6);
//RectPrism cross3(geom, cw+7, bt+7, ld+7);
//RectPrism stem3(geom, bt, th, ld);
//RectPrism stem_prova(geom,32,30,2);
//QVector3D z(0.0, 1.0, 0.0);
//cross.rotate(0.0, z);
//stem.rotate(0.0, z);
//stem_prova.rotate(0.0, z);
//qreal stem_downshift = (th + bt);
//stem.translate(QVector3D(0.0, -stem_downshift, 0.0));
node1.translate(QVector3D(0.1, 0.2, 0.0));
//node2.translate(QVector3D(0.06, 0.4, 0.5));
//node3.translate(QVector3D(0.01, 0.4, -0.5));
PipeEntity body(geom, 0.005, 0.01, 0.3, 20);
body.translate(QVector3D(0.1, 0.2, 0.05));
parts << body.parts << node1.parts ;//<< node2.parts << node3.parts << body.parts; << stem.parts
geom->finalize();
}
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> output;
if(!root){
return output;
}
int level = 0;
MyTreeNode node(root, level);
queue<MyTreeNode>myQueue;
myQueue.push(node);
vector<int> subVector;
output.push_back(subVector);
while(!myQueue.empty()){
MyTreeNode node = myQueue.front();
if(node.getLevel() + 1 > output.size()){
vector<int> subVector;
output.push_back(subVector);
}
output[node.getLevel()].push_back(node.getNode()->val);
myQueue.pop();
if(node.getNode()->left != NULL){
MyTreeNode node2(node.getNode()->left, node.getLevel() + 1);
myQueue.push(node2);
}
if(node.getNode()->right != NULL){
MyTreeNode node3(node.getNode()->right, node.getLevel() + 1);
myQueue.push(node3);
}
}
return output;
}
int main()
{
Solution solution;
ListNode node1(1);
ListNode node2(2);
ListNode node3(3);
ListNode node4(4);
ListNode node5(5);
node1.next = &node2;
node2.next = &node3;
node3.next = &node4;
node4.next = &node5;
ListNode* head = solution.removeNthFromEnd(&node1, 2);
while (head)
{
std::cout << head->val << std::endl;
head = head->next;
}
return 0;
}
int main()
{
Graph g;
Node node1(1), node2(2), node3(3), node4(4), node5(5), node6(6);
g.insert (Graph::value_type(node1, node3));
g.insert (Graph::value_type(node1, node4));
g.insert (Graph::value_type(node1, node5));
g.insert (Graph::value_type(node2, node6));
g.insert (Graph::value_type(node3, node6));
Graph::iterator it = g.begin();
for (; it != g.end(); it = g.upper_bound(it->first))
{
std::pair<Graph::iterator, Graph::iterator> range = g.equal_range(it->first);
std::cout << it->first << ": ";
for (; range.first != range.second; ++range.first)
{
std::cout << range.first->second << ", ";
}
std::cout << std::endl;
}
}
void TreeNodeTest::test_child()
{
/*
The tree we will work with:
Root
|----> Node1
| |----> Node11
| |----> Node12
|
|----> Node2
| |----> Node21
| |----> Node22
| |----> Node23
|
|----> Node3
*/
NRoot::Ptr node(new NRoot("Root"));
NGeneric::Ptr node1(new NGeneric("Node1", "MyType"));
NGeneric::Ptr node11(new NGeneric("Node11", "MyType"));
NGeneric::Ptr node12(new NGeneric("Node12", "MyType"));
NGeneric::Ptr node2(new NGeneric("Node2", "MyType"));
NGeneric::Ptr node21(new NGeneric("Node21", "MyType"));
NGeneric::Ptr node22(new NGeneric("Node22", "MyType"));
NGeneric::Ptr node23(new NGeneric("Node23", "MyType"));
NGeneric::Ptr node3(new NGeneric("Node3", "MyType"));
TreeNode * treeNode = nullptr;
TreeNode * treeNode1 = nullptr;
TreeNode * treeNode11 = nullptr;
TreeNode * treeNode12 = nullptr;
TreeNode * treeNode2 = nullptr;
TreeNode * treeNode21 = nullptr;
TreeNode * treeNode22 = nullptr;
TreeNode * treeNode23 = nullptr;
TreeNode * treeNode3 = nullptr;
node->addNode(node1);
node->addNode(node2);
node->addNode(node3);
node1->addNode(node11);
node1->addNode(node12);
node2->addNode(node21);
node2->addNode(node22);
node2->addNode(node23);
treeNode = new TreeNode(node, nullptr, 0);
//
// 1. check the direct children
//
treeNode1 = treeNode->child(0);
treeNode2 = treeNode->child(1);
treeNode3 = treeNode->child(2);
// check that pointer are not null
QVERIFY( treeNode1 != (TreeNode*) nullptr );
QVERIFY( treeNode2 != (TreeNode*) nullptr );
QVERIFY( treeNode3 != (TreeNode*) nullptr );
// their parent should be the root
QCOMPARE( treeNode1->parentNode(), treeNode );
QCOMPARE( treeNode2->parentNode(), treeNode );
QCOMPARE( treeNode3->parentNode(), treeNode );
// check their name
QCOMPARE( treeNode1->nodeName(), QString("Node1") );
QCOMPARE( treeNode2->nodeName(), QString("Node2") );
QCOMPARE( treeNode3->nodeName(), QString("Node3") );
//
// 2. children of Node1
//
treeNode11 = treeNode1->child(0);
treeNode12 = treeNode1->child(1);
// check that pointer are not null
QVERIFY( treeNode11 != (TreeNode*) nullptr );
QVERIFY( treeNode12 != (TreeNode*) nullptr );
// their parent should be the root
QCOMPARE( treeNode11->parentNode(), treeNode1 );
QCOMPARE( treeNode12->parentNode(), treeNode1 );
// check their name
QCOMPARE( treeNode11->nodeName(), QString("Node11") );
QCOMPARE( treeNode12->nodeName(), QString("Node12") );
//
// 3. children of Node2
//
treeNode21 = treeNode2->child(0);
treeNode22 = treeNode2->child(1);
treeNode23 = treeNode2->child(2);
// check that pointer are not null
QVERIFY( treeNode21 != (TreeNode*) nullptr );
QVERIFY( treeNode22 != (TreeNode*) nullptr );
QVERIFY( treeNode23 != (TreeNode*) nullptr );
// their parent should be the root
QCOMPARE( treeNode21->parentNode(), treeNode2 );
QCOMPARE( treeNode22->parentNode(), treeNode2 );
QCOMPARE( treeNode23->parentNode(), treeNode2 );
// check their name
QCOMPARE( treeNode21->nodeName(), QString("Node21") );
QCOMPARE( treeNode22->nodeName(), QString("Node22") );
QCOMPARE( treeNode23->nodeName(), QString("Node23") );
//
// 4. no child for Node3 (should return nullptr)
//
QCOMPARE( treeNode3->child(0), (TreeNode*) nullptr );
delete treeNode; // deletes the children as well
}
void TreeNodeTest::test_childByName()
{
// same tree as for test_child()
NRoot::Ptr node(new NRoot("Root"));
NGeneric::Ptr node1(new NGeneric("Node1", "MyType"));
NGeneric::Ptr node11(new NGeneric("Node11", "MyType"));
NGeneric::Ptr node12(new NGeneric("Node12", "MyType"));
NGeneric::Ptr node2(new NGeneric("Node2", "MyType"));
NGeneric::Ptr node21(new NGeneric("Node21", "MyType"));
NGeneric::Ptr node22(new NGeneric("Node22", "MyType"));
NGeneric::Ptr node23(new NGeneric("Node23", "MyType"));
NGeneric::Ptr node3(new NGeneric("Node3", "MyType"));
TreeNode * treeNode = nullptr;
TreeNode * treeNode1 = nullptr;
TreeNode * treeNode11 = nullptr;
TreeNode * treeNode12 = nullptr;
TreeNode * treeNode2 = nullptr;
TreeNode * treeNode21 = nullptr;
TreeNode * treeNode22 = nullptr;
TreeNode * treeNode23 = nullptr;
TreeNode * treeNode3 = nullptr;
node->addNode(node1);
node->addNode(node2);
node->addNode(node3);
node1->addNode(node11);
node1->addNode(node12);
node2->addNode(node21);
node2->addNode(node22);
node2->addNode(node23);
treeNode = new TreeNode(node, nullptr, 0);
treeNode1 = treeNode->child(0);
treeNode11 = treeNode1->child(0);
treeNode12 = treeNode1->child(1);
treeNode2 = treeNode->child(1);
treeNode21 = treeNode2->child(0);
treeNode22 = treeNode2->child(1);
treeNode23 = treeNode2->child(2);
treeNode3 = treeNode->child(2);
//
// 1. check the direct children
//
treeNode1 = treeNode->childByName("Node1");
treeNode2 = treeNode->childByName("Node2");
treeNode3 = treeNode->childByName("Node3");
// check that pointer are not null
QVERIFY( treeNode1 != (TreeNode*) nullptr );
QVERIFY( treeNode2 != (TreeNode*) nullptr );
QVERIFY( treeNode3 != (TreeNode*) nullptr );
// their parent should be the root
QCOMPARE( treeNode1->parentNode(), treeNode );
QCOMPARE( treeNode2->parentNode(), treeNode );
QCOMPARE( treeNode3->parentNode(), treeNode );
// check their row number
QCOMPARE( treeNode1->rowNumber(), 0 );
QCOMPARE( treeNode2->rowNumber(), 1 );
QCOMPARE( treeNode3->rowNumber(), 2 );
//
// 2. children of Node1
//
treeNode11 = treeNode1->childByName("Node11");
treeNode12 = treeNode1->childByName("Node12");
// check that pointer are not null
QVERIFY( treeNode11 != (TreeNode*) nullptr );
QVERIFY( treeNode12 != (TreeNode*) nullptr );
// their parent should be the root
QCOMPARE( treeNode11->parentNode(), treeNode1 );
QCOMPARE( treeNode12->parentNode(), treeNode1 );
// check their row number
QCOMPARE( treeNode11->rowNumber(), 0 );
QCOMPARE( treeNode12->rowNumber(), 1 );
//
// 3. wrong name
//
QCOMPARE ( treeNode2->childByName("Node"), (TreeNode*) nullptr );
delete treeNode; // deletes the children as well
}
int
run_main (int, ACE_TCHAR *[])
{
int r;
int retval = 0;
unsigned k;
MyNode node (1);
ACE_START_TEST (ACE_TEXT ("Unbounded_Set_Test"));
ACE_Unbounded_Set<MyNode> ubs;
if (ubs.size () != 0)
{
ACE_ERROR ((LM_ERROR, "Error: ubs.size () != 0\n"));
retval = -1;
}
if (!ubs.is_empty ())
{
ACE_ERROR ((LM_ERROR, "Error: !ubs.is_empty ()\n"));
retval = -1;
}
// Insert a value. Immediately remove it.
r = ubs.insert (node);
if (r != 0)
{
ACE_ERROR ((LM_ERROR, "Error: r != 0\n"));
retval = -1;
}
if (ubs.size () != 1)
{
ACE_ERROR ((LM_ERROR, "Error: ubs.size () != 1\n"));
retval = -1;
}
r = ubs.remove (node);
if (r != 0)
{
ACE_ERROR ((LM_ERROR, "Error: r != 0\n"));
retval = -1;
}
if (ubs.size () != 0)
{
ACE_ERROR ((LM_ERROR, "Error: ubs.size () != 0\n"));
retval = -1;
}
// Insert several different values.
for (node.k = 1; node.k <= 5; node.k++)
{
r = ubs.insert (node);
if (r != 0)
{
ACE_ERROR ((LM_ERROR, "Error: r != 0\n"));
retval = -1;
}
if (ubs.size () != node.k)
{
ACE_ERROR ((LM_ERROR, "Error: ubs.size () != node.k\n"));
retval = -1;
}
}
// Test assigment of sets.
// To do that, we also test some of the iterator methods.
typedef ACE_Unbounded_Set<MyNode> MySet;
MySet ubs2 = ubs; // Test a typedef of a set.
if (ubs2.size() != ubs.size())
{
ACE_ERROR ((LM_ERROR, "Error: ubs2.size() != ubs.size()\n"));
retval = -1;
}
{
MySet::ITERATOR it1 (ubs);
MySet::iterator it2 (ubs2);
for (k = 1; k <= 5; k++)
{
if (it1.done ())
{
ACE_ERROR ((LM_ERROR, "Error: it1.done ()\n"));
retval = -1;
}
if (it2.done ())
{
ACE_ERROR ((LM_ERROR, "Error: it2.done ()\n"));
retval = -1;
}
MyNode n1 = *it1;
MyNode n2 = *it2;
if (!(n1 == n2))
{
ACE_ERROR ((LM_ERROR, "Error: !(n1 == n2)\n"));
retval = -1;
}
it1.advance ();
it2.advance ();
}
if (!it1.done ())
{
ACE_ERROR ((LM_ERROR, "Error: !it1.done ()\n"));
retval = -1;
}
if (!it2.done ())
{
ACE_ERROR ((LM_ERROR, "Error: !it2.done ()\n"));
retval = -1;
}
// Verify that a set may be emptied while an iterator on the set is
// in-scope but inactive:
ubs.reset ();
// Restore original set from ubs2
ubs = ubs2;
}
// Selective deletion of elements and element retrieval.
{
MySet::iterator it (ubs2);
int deleted = 0;
while (! it.done ())
{
MyNode n = *it;
it.advance (); /* Being friendly here: Move the iterator on
so that element removal does not interfere
with the current iterator position.
The less friendly case, removal under the
current iterator position, is below. */
if (n.k % 2 == 1)
{
r = ubs2.remove (n);
deleted++;
}
}
if (ubs2.size () + deleted != ubs.size())
{
ACE_ERROR ((LM_ERROR, "Error: ubs2.size () + deleted != ubs.size()\n"));
retval = -1;
}
MyNode node2 (2);
if (ubs2.find (node2) != 0)
{
ACE_ERROR ((LM_ERROR, "Error: ubs2.find (node2) != 0\n"));
retval = -1;
}
MyNode node3 (3);
if (ubs2.find (node3) == 0)
{
ACE_ERROR ((LM_ERROR, "Error: ubs2.find (node3) == 0\n"));
retval = -1;
}
ubs2.insert (node3);
}
size_t s = count_const_set (ubs);
if (s != ubs.size ())
{
ACE_ERROR ((LM_ERROR, "Error: s != ubs.size ()\n"));
retval = -1;
}
ACE_Unbounded_Set<MyNode> ubs_insert;
MyNode node4 (4);
if (ubs_insert.insert (node4) != 0)
{
ACE_ERROR ((LM_ERROR, "Error: insert node4 failed\n"));
retval = -1;
}
if (ubs_insert.insert (node4) != 1)
{
ACE_ERROR ((LM_ERROR, "Error: insert node4 didn't return 1\n"));
retval = -1;
}
// Test iterating through a set and deleting elements.
{
ACE_Unbounded_Set<MyNode*> ubs3;
MyNode *n = 0;
for (int i = 0; i < 10; ++i)
{
n = new MyNode (i);
ubs3.insert (n);
}
MyNode **i_n = 0;
ACE_Unbounded_Set_Iterator<MyNode*> ubs3_iter (ubs3.begin ());
for (; ubs3_iter.next (i_n); ++ubs3_iter)
delete *i_n;
}
ACE_END_TEST;
return retval;
}
void main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
ep12 = __VERIFIER_nondet__Bool();
ep13 = __VERIFIER_nondet__Bool();
ep14 = __VERIFIER_nondet__Bool();
ep21 = __VERIFIER_nondet__Bool();
ep23 = __VERIFIER_nondet__Bool();
ep24 = __VERIFIER_nondet__Bool();
ep31 = __VERIFIER_nondet__Bool();
ep32 = __VERIFIER_nondet__Bool();
ep34 = __VERIFIER_nondet__Bool();
ep41 = __VERIFIER_nondet__Bool();
ep42 = __VERIFIER_nondet__Bool();
ep43 = __VERIFIER_nondet__Bool();
id1 = __VERIFIER_nondet_char();
r1 = __VERIFIER_nondet_char();
st1 = __VERIFIER_nondet_char();
nl1 = __VERIFIER_nondet_char();
m1 = __VERIFIER_nondet_char();
max1 = __VERIFIER_nondet_char();
mode1 = __VERIFIER_nondet__Bool();
newmax1 = __VERIFIER_nondet__Bool();
id2 = __VERIFIER_nondet_char();
r2 = __VERIFIER_nondet_char();
st2 = __VERIFIER_nondet_char();
nl2 = __VERIFIER_nondet_char();
m2 = __VERIFIER_nondet_char();
max2 = __VERIFIER_nondet_char();
mode2 = __VERIFIER_nondet__Bool();
newmax2 = __VERIFIER_nondet__Bool();
id3 = __VERIFIER_nondet_char();
r3 = __VERIFIER_nondet_char();
st3 = __VERIFIER_nondet_char();
nl3 = __VERIFIER_nondet_char();
m3 = __VERIFIER_nondet_char();
max3 = __VERIFIER_nondet_char();
mode3 = __VERIFIER_nondet__Bool();
newmax3 = __VERIFIER_nondet__Bool();
id4 = __VERIFIER_nondet_char();
r4 = __VERIFIER_nondet_char();
st4 = __VERIFIER_nondet_char();
nl4 = __VERIFIER_nondet_char();
m4 = __VERIFIER_nondet_char();
max4 = __VERIFIER_nondet_char();
mode4 = __VERIFIER_nondet__Bool();
newmax4 = __VERIFIER_nondet__Bool();
i2 = init();
__VERIFIER_assume(i2);
p12_old = nomsg;
p12_new = nomsg;
p13_old = nomsg;
p13_new = nomsg;
p14_old = nomsg;
p14_new = nomsg;
p21_old = nomsg;
p21_new = nomsg;
p23_old = nomsg;
p23_new = nomsg;
p24_old = nomsg;
p24_new = nomsg;
p31_old = nomsg;
p31_new = nomsg;
p32_old = nomsg;
p32_new = nomsg;
p34_old = nomsg;
p34_new = nomsg;
p41_old = nomsg;
p41_new = nomsg;
p42_old = nomsg;
p42_new = nomsg;
p43_old = nomsg;
p43_new = nomsg;
i2 = 0;
while (i2 < 8) {
{
node1();
node2();
node3();
node4();
p12_old = p12_new;
p12_new = nomsg;
p13_old = p13_new;
p13_new = nomsg;
p14_old = p14_new;
p14_new = nomsg;
p21_old = p21_new;
p21_new = nomsg;
p23_old = p23_new;
p23_new = nomsg;
p24_old = p24_new;
p24_new = nomsg;
p31_old = p31_new;
p31_new = nomsg;
p32_old = p32_new;
p32_new = nomsg;
p34_old = p34_new;
p34_new = nomsg;
p41_old = p41_new;
p41_new = nomsg;
p42_old = p42_new;
p42_new = nomsg;
p43_old = p43_new;
p43_new = nomsg;
c1 = check();
assert(c1);
i2 ++;
}
}
}
}
int
run_main (int, ACE_TCHAR *[])
{
int r;
unsigned k;
MyNode node (1);
ACE_START_TEST (ACE_TEXT ("Unbounded_Set_Test"));
ACE_Unbounded_Set<MyNode> ubs;
ACE_ASSERT (ubs.size () == 0);
// Insert a value. Immediately remove it.
r = ubs.insert (node);
ACE_ASSERT (r == 0);
ACE_ASSERT (ubs.size () == 1);
r = ubs.remove (node);
ACE_ASSERT (r == 0);
ACE_ASSERT (ubs.size () == 0);
// Insert several different values.
for (node.k = 1; node.k <= 5; node.k++)
{
r = ubs.insert (node);
ACE_ASSERT (r == 0);
ACE_ASSERT (ubs.size () == node.k);
}
// Test assigment of sets.
// To do that, we also test some of the iterator methods.
typedef ACE_Unbounded_Set<MyNode> MySet;
MySet ubs2 = ubs; // Test a typedef of a set.
ACE_ASSERT (ubs2.size() == ubs.size());
{
MySet::ITERATOR it1 (ubs);
MySet::iterator it2 (ubs2);
for (k = 1; k <= 5; k++)
{
ACE_ASSERT (! it1.done ());
ACE_ASSERT (! it2.done ());
MyNode n1 = *it1;
MyNode n2 = *it2;
ACE_ASSERT (n1 == n2);
it1.advance ();
it2.advance ();
}
ACE_ASSERT (it1.done ());
ACE_ASSERT (it2.done ());
// Verify that a set may be emptied while an iterator on the set is
// in-scope but inactive:
ubs.reset ();
// Restore original set from ubs2
ubs = ubs2;
}
// Selective deletion of elements and element retrieval.
{
MySet::iterator it (ubs2);
int deleted = 0;
while (! it.done ())
{
MyNode n = *it;
it.advance (); /* Being friendly here: Move the iterator on
so that element removal does not interfere
with the current iterator position.
The less friendly case, removal under the
current iterator position, is below. */
if (n.k % 2 == 1)
{
r = ubs2.remove (n);
deleted++;
}
}
ACE_ASSERT (ubs2.size () + deleted == ubs.size());
MyNode node2 (2);
ACE_ASSERT (ubs2.find (node2) == 0);
MyNode node3 (3);
ACE_ASSERT (ubs2.find (node3) != 0);
ubs2.insert (node3);
}
size_t s = count_const_set (ubs);
ACE_ASSERT (s == ubs.size ());
// Test deletion under the cursor.
// This is the regression test for Bugzilla bug 1460.
{
MySet::iterator end = ubs2.end ();
for (MySet::iterator i = ubs2.begin (); i != end; i++)
{
r = ubs2.remove (*i);
ACE_ASSERT (r == 0);
}
ACE_ASSERT (ubs2.size () == 0);
}
ACE_ASSERT (ubs2.is_empty ());
ACE_END_TEST;
return 0;
}
struct node *node2(codegen_func codegen, struct node *one, struct node *two)
{
return node3(codegen, one, two, NULL);
}
int main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
ep12 = __VERIFIER_nondet__Bool();
ep13 = __VERIFIER_nondet__Bool();
ep21 = __VERIFIER_nondet__Bool();
ep23 = __VERIFIER_nondet__Bool();
ep31 = __VERIFIER_nondet__Bool();
ep32 = __VERIFIER_nondet__Bool();
id1 = __VERIFIER_nondet_char();
r1 = __VERIFIER_nondet_char();
st1 = __VERIFIER_nondet_char();
nl1 = __VERIFIER_nondet_char();
m1 = __VERIFIER_nondet_char();
max1 = __VERIFIER_nondet_char();
mode1 = __VERIFIER_nondet__Bool();
id2 = __VERIFIER_nondet_char();
r2 = __VERIFIER_nondet_char();
st2 = __VERIFIER_nondet_char();
nl2 = __VERIFIER_nondet_char();
m2 = __VERIFIER_nondet_char();
max2 = __VERIFIER_nondet_char();
mode2 = __VERIFIER_nondet__Bool();
id3 = __VERIFIER_nondet_char();
r3 = __VERIFIER_nondet_char();
st3 = __VERIFIER_nondet_char();
nl3 = __VERIFIER_nondet_char();
m3 = __VERIFIER_nondet_char();
max3 = __VERIFIER_nondet_char();
mode3 = __VERIFIER_nondet__Bool();
i2 = init();
__VERIFIER_assume(i2);
p12_old = nomsg;
p12_new = nomsg;
p13_old = nomsg;
p13_new = nomsg;
p21_old = nomsg;
p21_new = nomsg;
p23_old = nomsg;
p23_new = nomsg;
p31_old = nomsg;
p31_new = nomsg;
p32_old = nomsg;
p32_new = nomsg;
i2 = 0;
while (1) {
{
node1();
node2();
node3();
p12_old = p12_new;
p12_new = nomsg;
p13_old = p13_new;
p13_new = nomsg;
p21_old = p21_new;
p21_new = nomsg;
p23_old = p23_new;
p23_new = nomsg;
p31_old = p31_new;
p31_new = nomsg;
p32_old = p32_new;
p32_new = nomsg;
c1 = check();
assert(c1);
}
}
}
return 0;
}
int main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
r1 = __VERIFIER_nondet_char();
id1 = __VERIFIER_nondet_char();
st1 = __VERIFIER_nondet_char();
send1 = __VERIFIER_nondet_char();
mode1 = __VERIFIER_nondet_bool();
alive1 = __VERIFIER_nondet_bool();
id2 = __VERIFIER_nondet_char();
st2 = __VERIFIER_nondet_char();
send2 = __VERIFIER_nondet_char();
mode2 = __VERIFIER_nondet_bool();
alive2 = __VERIFIER_nondet_bool();
id3 = __VERIFIER_nondet_char();
st3 = __VERIFIER_nondet_char();
send3 = __VERIFIER_nondet_char();
mode3 = __VERIFIER_nondet_bool();
alive3 = __VERIFIER_nondet_bool();
id4 = __VERIFIER_nondet_char();
st4 = __VERIFIER_nondet_char();
send4 = __VERIFIER_nondet_char();
mode4 = __VERIFIER_nondet_bool();
alive4 = __VERIFIER_nondet_bool();
id5 = __VERIFIER_nondet_char();
st5 = __VERIFIER_nondet_char();
send5 = __VERIFIER_nondet_char();
mode5 = __VERIFIER_nondet_bool();
alive5 = __VERIFIER_nondet_bool();
id6 = __VERIFIER_nondet_char();
st6 = __VERIFIER_nondet_char();
send6 = __VERIFIER_nondet_char();
mode6 = __VERIFIER_nondet_bool();
alive6 = __VERIFIER_nondet_bool();
i2 = init();
__VERIFIER_assume(i2);
p1_old = nomsg;
p1_new = nomsg;
p2_old = nomsg;
p2_new = nomsg;
p3_old = nomsg;
p3_new = nomsg;
p4_old = nomsg;
p4_new = nomsg;
p5_old = nomsg;
p5_new = nomsg;
p6_old = nomsg;
p6_new = nomsg;
i2 = 0;
while (i2 < 12) {
{
node1();
node2();
node3();
node4();
node5();
node6();
p1_old = p1_new;
p1_new = nomsg;
p2_old = p2_new;
p2_new = nomsg;
p3_old = p3_new;
p3_new = nomsg;
p4_old = p4_new;
p4_new = nomsg;
p5_old = p5_new;
p5_new = nomsg;
p6_old = p6_new;
p6_new = nomsg;
c1 = check();
assert(c1);
i2 ++;
}
}
}
return 0;
}
