/* * node20(20) * / \ * node10(10) node30(30) */ void test_setNode_given_10_20_30_node20_as_root_should_return_expected_tree(void) { setNode(0, 10, NULL, NULL, &node10); setNode(0, 30, NULL, NULL, &node30); setNode(0, 20, &node10, &node30, &node20); TEST_ASSERT_EQUAL_TREE(0, 20, &node10, &node30, &node20); }
OSGTextNode::OSGTextNode(QObject *parent) : osgQtQuick::OSGNode(parent), h(new Hidden) { osg::ref_ptr<osgText::Font> textFont = createFont(QFont("Times")); h->text = createText(osg::Vec3(-100, 20, 0), "The osgQtQuick :-)\n" "И даже по русски!", 20.0f, textFont.get()); osg::ref_ptr<osg::Geode> textGeode = new osg::Geode(); h->text->setColor(osg::Vec4(0.0f, 1.0f, 0.0f, 1.0f)); textGeode->addDrawable(h->text.get()); #if 0 h->text->setAutoRotateToScreen(true); setNode(textGeode.get()); #else osg::Camera *camera = createHUDCamera(-100, 100, -100, 100); camera->addChild(textGeode.get()); camera->getOrCreateStateSet()->setMode( GL_LIGHTING, osg::StateAttribute::OFF); setNode(camera); #endif }
/** Encounter case 3 on the left child after remove successor (with case 1a appear after rotate) * * parent's left parent's left parent's left parent's left * | | | | * v v v v * 10(b) 10(b) 10(b) 10(b) * / \ successor 1 / \ / \ / \ * 4(b) 15(b) ------------> 4(b) 15(b) ------------> 7(b) 15(b) ------------> 7(b) 15(b) * / \ / \ // \ / \ / \ / \ / \ / \ * 1(b) 7(r) 13(b) 20(b) NULL 7(r) 13(b) 20(b) 4(r) 8(b) 13(b) 20(b) 5(r) 8(b) 13(b) 20(b) * / \ / \ // \ / \ * 5(b) 8(b) 5(b) 8(b) NULL 5(b) 4(b) 6(b) * \ \ \ * 6(r) 6(r) 6(r) */ void test_removeNextLargerSuccessor_given_nodes_1_4_5_6_7_8_10_13_15_20_should_remove_successor_1(void) { setNode(&node6, NULL, NULL, 'r'); setNode(&node5, NULL, &node6, 'b'); setNode(&node8, NULL, NULL, 'b'); setNode(&node7, &node5, &node8, 'r'); setNode(&node13, NULL, NULL, 'b'); setNode(&node20, NULL, NULL, 'b'); setNode(&node1, NULL, NULL, 'b'); setNode(&node4, &node1, &node7, 'b'); setNode(&node15, &node13, &node20, 'b'); setNode(&node10, &node4, &node15, 'b'); Node *parent = &node10, *removeNode; removeNode = removeNextLargerSuccessor(&parent); TEST_ASSERT_EQUAL_PTR(&node10, parent); TEST_ASSERT_EQUAL_PTR(&node1, removeNode); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node4); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node6); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node8); TEST_ASSERT_EQUAL_NODE(&node4, &node6, 'r', &node5); TEST_ASSERT_EQUAL_NODE(&node5, &node8, 'b', &node7); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node13); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node20); TEST_ASSERT_EQUAL_NODE(&node13, &node20, 'b', &node15); TEST_ASSERT_EQUAL_NODE(&node7, &node15, 'b', &node10); }
bool SelectionParser::parse(vespalib::stringref s) { bool retval(false); IdSpecParser id(_bucketIdFactory); if (id.parse(s)) { OperatorParser op; if (op.parse(id.getRemaining())) { if (id.isUserSpec()) { IntegerParser v; if (v.parse(op.getRemaining())) { setNode(Node::UP(new Compare(id.stealValue(), *op.getOperator(), v.stealValue(), _bucketIdFactory))); retval = true; } setRemaining(v.getRemaining()); } else { StringParser v; if (v.parse(op.getRemaining())) { setNode(Node::UP(new Compare(id.stealValue(), *op.getOperator(), v.stealValue(), _bucketIdFactory))); retval = true; } setRemaining(v.getRemaining()); } } else { setRemaining(op.getRemaining()); } } else { setRemaining(id.getRemaining()); } return retval; }
//存储待查找点 void Storage_Demand(T_Node Head, //链表节点 Info_Node& info, map<short,char>& demMap, //中间节点 const string str,const string dela,const string delb){//待分割串 分割符1,分隔符2 string dema = str+delb; //扩展字符串 | int size = dema.size(); //得到数据的大小 int sdela = dela.size(); //分割串a大小 , int sdelb = delb.size(); //分割串b大小 | int pos = 0; //起始点 pos = dema.find(dela,0); //逗号分割起始位置 info.startNode = atoi(dema.substr(0,pos).c_str()); //转换成整数 setNode(Head,info.startNode,NODE_TYPE_START,NODE_TYPE); //设置节点类型 int index = pos+sdela-1; pos = dema.find(dela,index+1); info.endNode = atoi(dema.substr(index+1,pos).c_str()); setNode(Head,info.endNode,NODE_TYPE_END,NODE_TYPE); //设置节点类型 info.mustNumber = 0; //初始化必经点计数器 for(int i = pos+1;i<size;i++){//分割数据 pos = dema.find(delb,i); if(pos < size){ index = atoi(dema.substr(i,pos-i).c_str()); info.mustData[info.mustNumber++] = index; //添加必经点到Info_Node setNode(Head,index,NODE_TYPE_MID,NODE_TYPE); //设置节点类型 i = pos+sdelb-1; } } }
// 1-2 void test_getNumNodes_Vine_has_2_Nodes_should_return_2(void){ setNode(&node1, NULL, &node2, 'b'); setNode(&node2, NULL, NULL, 'b'); Node *vine = &node1; int num = getNumNodes(vine); TEST_ASSERT_EQUAL(2,num); }
//初始化头节点 Topo_Node* Node_Init(const int num){ Topo_Node* Head = (Topo_Node*)malloc(sizeof(Topo_Node)*num); //创建头节点索引 for(int i = 0;i<num;i++){ (Head+i)->node = NULL; //初始化尾节点索引; setNode(Head,i,0,NODE_NUMBER); //初始化节点个数 setNode(Head,i,NODE_TYPE_COMM,NODE_TYPE); //初始化类型为通用类型 } return Head; }
BinaryTree* switchNode(int val1, int val2, BinaryTree* tree) { //on utilise 3 fois la fonction setNode pour faire l'échange de valeurs int intoval2=1000;//valeur intermédiaire de remplacement d'un noeud setNode(val1, intoval2, tree); setNode(val2, val1, tree); setNode(intoval2, val2, tree); return tree; }
/** n = 2, m = 2^[Floor(log2 (2+1))] - 1 * = 1 * * c1(1) * 1(R) 2 * \ --> / * 2 1 */ void test_rightVineToTree_given_Vine_has_2_node_should_do_c1(void){ setNode(&node1, NULL, &node2, 'b'); setNode(&node2, NULL, NULL, 'b'); Node *vine = &node1; rightVineToTree(&vine); TEST_ASSERT_EQUAL_PTR(&node2, vine); TEST_ASSERT_EQUAL_NODE(&node1, NULL, 'b', &node2); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node1); }
/** Root-> 2 * \ * 6 */ void test_treeToRightVine_given_root_is_rightVine_with_2_node_should_do_nothing(void){ setNode(&node2, NULL, &node6, 'b'); setNode(&node6, NULL, NULL, 'b'); Node *root = &node2; treeToRightVine(&root); TEST_ASSERT_EQUAL_PTR(&node2, root); TEST_ASSERT_EQUAL_NODE(NULL, &node6, 'b', &node2); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node6); }
/** 2-node case * root root * | | * v remove 2 v * 1(b) ------------> 1(b) * \ * 2(r) */ void test_delRedBlackTree_remove_2_from_tree_with_1_2_nodes(void) { setNode(&node2, NULL, NULL, 'r'); setNode(&node1, NULL, &node2, 'b'); Node *root = &node1; delRedBlackTree(&root, &node2); TEST_ASSERT_EQUAL_PTR(root, &node1); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node1); }
void test_isNodeRed_should_return_0_if_the_node_is_not_red_color(void){ setNode(&node5,NULL,NULL,'b'); setNode(&node30,NULL,NULL,'b'); setNode(&node20,&node5,&node30,'d'); Node *nodeA = &node5; Node *nodeB = &node30; Node *nodeC = &node20; TEST_ASSERT_EQUAL(0,isNodeRed(&nodeA)); TEST_ASSERT_EQUAL(0,isNodeRed(&nodeB)); TEST_ASSERT_EQUAL(0,isNodeRed(&nodeC)); }
void test_isNodeBlack_should_return_1_if_the_node_is_black_color(void){ setNode(&node5,NULL,NULL,'b'); setNode(&node30,NULL,NULL,'b'); setNode(&node20,&node5,&node30,'b'); Node *nodeA = &node5; Node *nodeB = &node30; Node *nodeC = &node20; TEST_ASSERT_EQUAL(1,isNodeBlack(&nodeA)); TEST_ASSERT_EQUAL(1,isNodeBlack(&nodeB)); TEST_ASSERT_EQUAL(1,isNodeBlack(&nodeC)); }
void test_isDoubleBlack_given_a_node_with_black_color_should_return_0(void) { int result; setNode(&node4, NULL, NULL, 'b'); setNode(&node3, NULL, NULL, 'r'); Node *root = &node4; Node *removeNode = &node3; result = isDoubleBlack(&root, removeNode); TEST_ASSERT_EQUAL(0, result); }
/** 2-node case * * root -> 2(b) remove 1 * / ----------> 2(b) <- root * 1(r) */ void test_genericDelRedBlackTree_remove_node1_from_tree_with_node_1_2(void) { setNode(&node1, NULL, NULL, 'r'); setNode(&node2, &node1, NULL, 'b'); Node *root = &node2, *removeNode; removeNode = genericDelRedBlackTree(&root, &node1, compareEventInfo); TEST_ASSERT_EQUAL_PTR(&node2, root); TEST_ASSERT_EQUAL_PTR(&node1, removeNode); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node2); }
/** 2-node case * add 4 2(b) * root -> 2(b) --------> \ * 4(r) */ void test_genericAddRedBlackTree_add_node4_to_tree_with_only_node2(void) { setNode(&node4, NULL, NULL, 'r'); setNode(&node2, NULL, NULL, 'b'); Node *root = &node2; genericAddRedBlackTree(&root, &node4, compareEventInfo); TEST_ASSERT_EQUAL_PTR(&node2, root); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'r', &node4); TEST_ASSERT_EQUAL_NODE(NULL, &node4, 'b', &node2); }
void test_restructureBlackLeftWithOneRedChild_case_1b(void){ setNode(&node9,NULL,NULL,'r'); setNode(&node8,NULL,&node9,'b'); setNode(&node10,&node8,NULL,'b'); Node *root=&node10; restructureBlackLeftWithOneRedChild(&root); TEST_ASSERT_EQUAL_PTR(root,&node9); TEST_ASSERT_EQUAL_NODE(NULL,NULL,'b',&node8); TEST_ASSERT_EQUAL_NODE(NULL,NULL,'b',&node10); TEST_ASSERT_EQUAL_NODE(&node8,&node10,'b',&node9); }
void test_restructureBlackRightWithOneRedChild_case_1a_parent_is_black(void){ setNode(&node30,NULL,NULL,'r'); setNode(&node20,NULL,&node30,'b'); setNode(&node10,NULL,&node20,'b'); Node *root=&node10; restructureBlackRightWithOneRedChild(&root); TEST_ASSERT_EQUAL_PTR(root,&node20); TEST_ASSERT_EQUAL_NODE(NULL,NULL,'b',&node10); TEST_ASSERT_EQUAL_NODE(NULL,NULL,'b',&node30); TEST_ASSERT_EQUAL_NODE(&node10,&node30,'b',&node20); }
/** 2-node case * add A B(b) * root -> B(b) --------> / * A(r) */ void test_genericAddRedBlackTree_add_nodeA_to_tree_with_only_nodeB(void) { setNode(&nodeA, NULL, NULL, 'r'); setNode(&nodeB, NULL, NULL, 'b'); Node *root = &nodeB; genericAddRedBlackTree(&root, &nodeA, compareModuleAndPin); TEST_ASSERT_EQUAL_PTR(&nodeB, root); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'r', &nodeA); TEST_ASSERT_EQUAL_NODE(&nodeA, NULL, 'b', &nodeB); }
/** * parent parent * | | * v successor v * 2(b) 2 3(b) * \ --------------> * 3(r) */ void test_removeNextLargerSuccessor_remove_3_from_the_tree_with_2_3_nodes(void) { setNode(&node3, NULL, NULL, 'r'); setNode(&node2, NULL, &node3, 'b'); Node *parent = &node2; Node *removeNode; removeNode = removeNextLargerSuccessor(&parent); TEST_ASSERT_EQUAL_PTR(&node2, removeNode); TEST_ASSERT_EQUAL_PTR(parent, &node3); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node3); }
/** n = 3, m = 2^[Floor(log2 (3+1))] - 1 c2(3/2) = c2(1) * = 3 * * c2(1) * 1(R) 2 * \ / \ * 2 ----> 1 3 * \ * 3 * */ void test_rightVineToTree_given_Vine_has_3_node_should_do_c2_but_not_c1_because_n_and_m_are_equal(void){ setNode(&node1, NULL, &node2, 'b'); setNode(&node2, NULL, &node3, 'b'); setNode(&node3, NULL, NULL, 'b'); Node *vine = &node1; rightVineToTree(&vine); TEST_ASSERT_EQUAL_PTR(&node2, vine); TEST_ASSERT_EQUAL_NODE(&node1, &node3, 'b', &node2); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node1); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node3); }
void test_restructureBlackRightWithBlackChildren_case_2b(void){ setNode(&node15,NULL,NULL,'b'); setNode(&node30,NULL,NULL,'b'); setNode(&node20,&node15,&node30,'b'); setNode(&node10,NULL,&node20,'r'); Node *root=&node10; restructureBlackRightWithBlackChildren(&root); TEST_ASSERT_EQUAL_PTR(root,&node10); TEST_ASSERT_EQUAL_NODE(NULL,NULL,'b',&node15); TEST_ASSERT_EQUAL_NODE(NULL,NULL,'b',&node30); TEST_ASSERT_EQUAL_NODE(&node15,&node30,'r',&node20); TEST_ASSERT_EQUAL_NODE(NULL,&node20,'b',&node10); }
void test_restructureBlackLeftWithBlackChildren_case_2b(void){ setNode(&node5,NULL,NULL,'b'); setNode(&node9,NULL,NULL,'b'); setNode(&node8,&node5,&node9,'b'); setNode(&node10,&node8,NULL,'r'); Node *root=&node10; restructureBlackLeftWithBlackChildren(&root); TEST_ASSERT_EQUAL_PTR(root,&node10); TEST_ASSERT_EQUAL_NODE(NULL,NULL,'b',&node5); TEST_ASSERT_EQUAL_NODE(NULL,NULL,'b',&node9); TEST_ASSERT_EQUAL_NODE(&node5,&node9,'r',&node8); TEST_ASSERT_EQUAL_NODE(&node8,NULL,'b',&node10); }
/** n = 4, m = 2^[Floor(log2 (4+1))] - 1 * = 3 * * c1(1) c2(1) * 1(R) 2(R) 3 * \ / \ / \ * 2 ----> 1 3 ----> 2 4 * \ \ / * 3 4 1 * \ * 4 */ void test_rightVineToTree_given_Vine_has_4_node_should_form_do_c1_and_c2(void){ setNode(&node1, NULL, &node2, 'b'); setNode(&node2, NULL, &node3, 'b'); setNode(&node3, NULL, &node4, 'b'); setNode(&node4, NULL, NULL, 'b'); Node *vine = &node1; rightVineToTree(&vine); TEST_ASSERT_EQUAL_PTR(&node3, vine); TEST_ASSERT_EQUAL_NODE(&node2, &node4, 'b', &node3); TEST_ASSERT_EQUAL_NODE(&node1, NULL, 'b', &node2); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node1); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node4); }
/* * Root -> 1 2 <- Root * \ / \ * 2 ---> 1 3 * \ * 3 */ void test_leftRotate_3_elements(void){ setNode(&node3, NULL, NULL, 'b'); setNode(&node2, NULL, &node3, 'b'); setNode(&node1, NULL, &node2, 'b'); Node *root = &node1; leftRotate(&root); TEST_ASSERT_EQUAL_PTR(node1.left , NULL); TEST_ASSERT_EQUAL_PTR(node1.right, NULL); TEST_ASSERT_EQUAL_PTR(node3.left , NULL); TEST_ASSERT_EQUAL_PTR(node3.right, NULL); TEST_ASSERT_EQUAL_PTR(node2.left , &node1); TEST_ASSERT_EQUAL_PTR(node2.right, &node3); TEST_ASSERT_EQUAL_PTR(root, &node2); }
/* * Root-> 10 * / 5 <-Root * 5 ---> / \ * / 1 10 * 1 */ void test_rightRotate_3_elements(void) { setNode(&node1, NULL, NULL, 'b'); setNode(&node5, &node1, NULL, 'b'); setNode(&node10, &node5, NULL, 'b'); Node *root = &node10; rightRotate(&root); TEST_ASSERT_EQUAL_PTR(node1.left , NULL); TEST_ASSERT_EQUAL_PTR(node1.right , NULL); TEST_ASSERT_EQUAL_PTR(node10.left , NULL); TEST_ASSERT_EQUAL_PTR(node10.right, NULL); TEST_ASSERT_EQUAL_PTR(node5.left , &node1); TEST_ASSERT_EQUAL_PTR(node5.right , &node10); TEST_ASSERT_EQUAL_PTR(root, &node5); }
/** * root root * | | * v v * 2(b) remove 1 2(b) * / \ ------------> \ * 1(b) 3(b) 3(r) */ void test__delRedBlackTree_remove_one_from_tree_with_1_2_3_nodes(void) { setNode(&node1, NULL, NULL, 'b'); setNode(&node3, NULL, NULL, 'b'); setNode(&node2, &node1, &node3, 'r'); Node *root = &node2; Node *result; result = _delRedBlackTree(&root, &node1); TEST_ASSERT_EQUAL_PTR(root, &node2); TEST_ASSERT_EQUAL_PTR(result, &node1); TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'r', &node3); TEST_ASSERT_EQUAL_NODE(NULL, &node3, 'b', &node2); }
/** 2-node case * remove 2 * root -> 1(b) ---------> Throw ERR_NODE_UNAVAILABLE */ void test_genericDelRedBlackTree_remove_node2_from_tree_with_only_node1_should_throw_ERR_NODE_UNAVAILABLE(void) { setNode(&node2, NULL, NULL, 'r'); setNode(&node1, NULL, NULL, 'b'); Node *root = &node1; CEXCEPTION_T err; Try{ genericDelRedBlackTree(&root, &node2, compareEventInfo); TEST_FAIL_MESSAGE("Expected ERR_NODE_UNAVAILABLE to be thrown. But receive none"); } Catch(err) { TEST_ASSERT_EQUAL_MESSAGE(ERR_NODE_UNAVAILABLE, err, "Expected ERR_NODE_UNAVAILABLE exception"); } }
void test_pipeEvent_given_pipe_with_AND_and_OR_module_data_should_register_event_for_all_pipe_data(void) { Module *AND, *OR; ModuleAndPin *andData, *orData; Pipe *pipe; Node *andRootNode, *orNode; int inputType = QUAD_2_INPUT; AND = createdAndModule(inputType); OR = createdOrModule(inputType); pipe = createdPipeModule(); pipe->stateToFire = HIGH; andData = createdModuleAndPin(AND, (AND->pin[0]).pinNumber); orData = createdModuleAndPin(OR, (OR->pin[1]).pinNumber); andRootNode = createdNewPipeDataNode(andData); orNode = createdNewPipeDataNode(orData); setNode(andRootNode, orNode, NULL, 'b'); pipe->data = andRootNode; registerEvent_Expect(orData, NULL, ONE_NANO_SEC + OR_PROPAGATION_DELAY); registerEvent_Expect(andData, NULL, ONE_NANO_SEC + AND_PROPAGATION_DELAY); pipe->event((void *)pipe, (void *)pipe->data, ONE_NANO_SEC); TEST_ASSERT_EQUAL(HIGH, (AND->pin[0]).state); TEST_ASSERT_EQUAL(HIGH, (OR->pin[1]).state); destroyModule(OR); destroyModule(AND); destroyPipeData(pipe); }
void LinearSVM::classifyInternal(const InstancePtr &instance, Classification &classification) { setNode(instance,svmInst); //scaleInstance(node); double label = liblinear::predict(model,svmInst); unsigned int intLabel = (int)(label + 0.5); classification[intLabel] = 1.0; }