MS-504 Update node_test in scheduler

Former-commit-id: 2477838780d6c2e6403bd1972faa24a0c850f40c

cpp/CHANGELOG.md

@@ -88,6 +88,7 @@ Please mark all change in change log and use the ticket from JIRA.
 - MS-487 - Define metric type in CreateTable
 - MS-488 - Improve code format in scheduler
 - MS-502 - Update tasktable_test in scheduler
+- MS-504 - Update node_test in scheduler
 
 ## New Feature
 - MS-343 - Implement ResourceMgr

cpp/src/scheduler/resource/Node.cpp

@@ -17,27 +17,6 @@ Node::Node() {
     id_ = counter++;
 }
 
-void Node::DelNeighbour(const NeighbourNodePtr &neighbour_ptr) {
-    std::lock_guard<std::mutex> lk(mutex_);
-    if (auto s = neighbour_ptr.lock()) {
-        auto search = neighbours_.find(s->id_);
-        if (search != neighbours_.end()) {
-            neighbours_.erase(search);
-        }
-    }
-}
-
-bool Node::IsNeighbour(const NeighbourNodePtr &neighbour_ptr) {
-    std::lock_guard<std::mutex> lk(mutex_);
-    if (auto s = neighbour_ptr.lock()) {
-        auto search = neighbours_.find(s->id_);
-        if (search != neighbours_.end()) {
-            return true;
-        }
-    }
-    return false;
-}
-
 std::vector<Neighbour> Node::GetNeighbours() {
     std::lock_guard<std::mutex> lk(mutex_);
     std::vector<Neighbour> ret;
@@ -48,8 +27,13 @@ std::vector<Neighbour> Node::GetNeighbours() {
 }
 
 std::string Node::Dump() {
-    // TODO(linxj): what's that?
-    return std::__cxx11::string();
+    std::stringstream ss;
+    ss << "<Node, id=" << std::to_string(id_) << ">::neighbours:" << std::endl;
+    for (auto &neighbour : neighbours_) {
+        ss << "\t<Neighbour, id=" << std::to_string(neighbour.first);
+        ss << ", connection: " << neighbour.second.connection.Dump() << ">" << std::endl;
+    }
+    return ss.str();
 }
 
 void Node::AddNeighbour(const NeighbourNodePtr &neighbour_node, Connection &connection) {

cpp/src/scheduler/resource/Node.h

@@ -37,12 +37,6 @@ public:
     void
     AddNeighbour(const NeighbourNodePtr &neighbour_node, Connection &connection);
 
-    void
-    DelNeighbour(const NeighbourNodePtr &neighbour_ptr);
-
-    bool
-    IsNeighbour(const NeighbourNodePtr& neighbour_ptr);
-
     std::vector<Neighbour>
     GetNeighbours();
 

cpp/unittest/scheduler/node_test.cpp

@@ -11,58 +11,71 @@ protected:
         node1_ = std::make_shared<Node>();
         node2_ = std::make_shared<Node>();
         node3_ = std::make_shared<Node>();
-        node4_ = std::make_shared<Node>();
+        isolated_node1_ = std::make_shared<Node>();
+        isolated_node2_ = std::make_shared<Node>();
 
         auto pcie = Connection("PCIe", 11.0);
 
         node1_->AddNeighbour(node2_, pcie);
+        node1_->AddNeighbour(node3_, pcie);
         node2_->AddNeighbour(node1_, pcie);
     }
 
     NodePtr node1_;
     NodePtr node2_;
     NodePtr node3_;
-    NodePtr node4_;
+    NodePtr isolated_node1_;
+    NodePtr isolated_node2_;
 };
 
 TEST_F(NodeTest, add_neighbour) {
-    ASSERT_EQ(node3_->GetNeighbours().size(), 0);
-    ASSERT_EQ(node4_->GetNeighbours().size(), 0);
+    ASSERT_EQ(isolated_node1_->GetNeighbours().size(), 0);
+    ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
     auto pcie = Connection("PCIe", 11.0);
-    node3_->AddNeighbour(node4_, pcie);
-    node4_->AddNeighbour(node3_, pcie);
-    ASSERT_EQ(node3_->GetNeighbours().size(), 1);
-    ASSERT_EQ(node4_->GetNeighbours().size(), 1);
+    isolated_node1_->AddNeighbour(isolated_node2_, pcie);
+    ASSERT_EQ(isolated_node1_->GetNeighbours().size(), 1);
+    ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
 }
 
-TEST_F(NodeTest, del_neighbour) {
-    ASSERT_EQ(node1_->GetNeighbours().size(), 1);
-    ASSERT_EQ(node2_->GetNeighbours().size(), 1);
-    ASSERT_EQ(node3_->GetNeighbours().size(), 0);
-    node1_->DelNeighbour(node2_);
-    node2_->DelNeighbour(node2_);
-    node3_->DelNeighbour(node2_);
-    ASSERT_EQ(node1_->GetNeighbours().size(), 0);
-    ASSERT_EQ(node2_->GetNeighbours().size(), 1);
-    ASSERT_EQ(node3_->GetNeighbours().size(), 0);
+TEST_F(NodeTest, repeat_add_neighbour) {
+    ASSERT_EQ(isolated_node1_->GetNeighbours().size(), 0);
+    ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
+    auto pcie = Connection("PCIe", 11.0);
+    isolated_node1_->AddNeighbour(isolated_node2_, pcie);
+    isolated_node1_->AddNeighbour(isolated_node2_, pcie);
+    ASSERT_EQ(isolated_node1_->GetNeighbours().size(), 1);
+    ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
 }
 
-TEST_F(NodeTest, is_neighbour) {
-    ASSERT_TRUE(node1_->IsNeighbour(node2_));
-    ASSERT_TRUE(node2_->IsNeighbour(node1_));
+TEST_F(NodeTest, get_neighbours) {
+    {
+        bool n2 = false, n3 = false;
+        auto node1_neighbours = node1_->GetNeighbours();
+        ASSERT_EQ(node1_neighbours.size(), 2);
+        for (auto &n : node1_neighbours) {
+            if (n.neighbour_node.lock() == node2_) n2 = true;
+            if (n.neighbour_node.lock() == node3_) n3 = true;
+        }
+        ASSERT_TRUE(n2);
+        ASSERT_TRUE(n3);
+    }
 
-    ASSERT_FALSE(node1_->IsNeighbour(node3_));
-    ASSERT_FALSE(node2_->IsNeighbour(node3_));
-    ASSERT_FALSE(node3_->IsNeighbour(node1_));
-    ASSERT_FALSE(node3_->IsNeighbour(node2_));
+    {
+        auto node2_neighbours = node2_->GetNeighbours();
+        ASSERT_EQ(node2_neighbours.size(), 1);
+        ASSERT_EQ(node2_neighbours[0].neighbour_node.lock(), node1_);
+    }
+
+    {
+        auto node3_neighbours = node3_->GetNeighbours();
+        ASSERT_EQ(node3_neighbours.size(), 0);
+    }
 }
 
-TEST_F(NodeTest, get_neighbours) {
-    auto node1_neighbours = node1_->GetNeighbours();
-    ASSERT_EQ(node1_neighbours.size(), 1);
-    ASSERT_EQ(node1_neighbours[0].neighbour_node.lock(), node2_);
+TEST_F(NodeTest, dump) {
+    std::cout << node1_->Dump();
+    ASSERT_FALSE(node1_->Dump().empty());
 
-    auto node2_neighbours = node2_->GetNeighbours();
-    ASSERT_EQ(node2_neighbours.size(), 1);
-    ASSERT_EQ(node2_neighbours[0].neighbour_node.lock(), node1_);
+    std::cout << node2_->Dump();
+    ASSERT_FALSE(node2_->Dump().empty());
 }