Changeset 986:e997802b855c in lemon-0.x for src/test

Timestamp:

11/13/04 13:53:28 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1376

Message:

Naming changes:

• head -> target
• tail -> source

Location:

src/test

Files:

• bfs_test.cc (modified) (2 diffs)
• dfs_test.cc (modified) (1 diff)
• dijkstra_heap_test.cc (modified) (4 diffs)
• dijkstra_test.cc (modified) (2 diffs)
• graph_factory_test.cc (modified) (2 diffs)
• graph_test.h (modified) (3 diffs)
• path_test.cc (modified) (1 diff)
• preflow_test.cc (modified) (1 diff)
• sym_graph_test.cc (modified) (1 diff)
• sym_graph_test.h (modified) (2 diffs)
• test_tools.h (modified) (1 diff)

src/test/bfs_test.cc

@@ -84 +84 @@
 
   for(EdgeIt e(G); e==INVALID; ++e) {
-    Node u=G.tail(e);
-    Node v=G.head(e);
+    Node u=G.source(e);
+    Node v=G.target(e);
     check( !bfs_test.reached(u) ||
            (bfs_test.dist(v) > bfs_test.dist(u)+1),
@@ -95 +95 @@
     if ( bfs_test.pred(v)!=INVALID ) {
       Edge e=bfs_test.pred(v);
-      Node u=G.tail(e);
+      Node u=G.source(e);
       check(u==bfs_test.predNode(v),"Wrong tree.");
       check(bfs_test.dist(v) - bfs_test.dist(u) == 1,

src/test/dfs_test.cc

@@ -84 +84 @@
     if ( dfs_test.pred(v)!=INVALID ) {
       Edge e=dfs_test.pred(v);
-      Node u=G.tail(e);
+      Node u=G.source(e);
       check(u==dfs_test.predNode(v),"Wrong tree.");
       check(dfs_test.dist(v) - dfs_test.dist(u) == 1,

src/test/dijkstra_heap_test.cc

@@ -74 +74 @@
   EdgeIt e;
   for(G.first(e); e!=INVALID; ++e) {
-    Node u=G.tail(e);
-    Node v=G.head(e);
+    Node u=G.source(e);
+    Node v=G.target(e);
     if ( dijkstra_test.dist(v) - dijkstra_test.dist(u) > cap[e] )
       if ( dijkstra_test.reached(u) ) {
-        std::cout<<"Error! dist(head)-dist(tail)- edge_length= " 
+        std::cout<<"Error! dist(target)-dist(source)- edge_length= " 
                  <<dijkstra_test.dist(v) - dijkstra_test.dist(u) 
           - cap[e]<<std::endl;
@@ -89 +89 @@
     if ( dijkstra_test.reached(v) ) {
       Edge e=dijkstra_test.pred(v);
-      Node u=G.tail(e);
+      Node u=G.source(e);
       if ( dijkstra_test.dist(v) - dijkstra_test.dist(u) != cap[e] ) {
         std::cout<<"Error in a shortest path tree edge! Difference: " 
@@ -123 +123 @@
 
   for(G.first(e); e!=INVALID; ++e) {
-    Node u=G.tail(e);
-    Node v=G.head(e);
+    Node u=G.source(e);
+    Node v=G.target(e);
     if ( dijkstra_test2.dist(v) - dijkstra_test2.dist(u) > cap[e] )
       if ( dijkstra_test2.reached(u) ) {
-        std::cout<<"Error! dist(head)-dist(tail)- edge_length= " 
+        std::cout<<"Error! dist(target)-dist(source)- edge_length= " 
                  <<dijkstra_test2.dist(v) - dijkstra_test2.dist(u) 
           - cap[e]<<std::endl;
@@ -137 +137 @@
     if ( dijkstra_test2.reached(v) ) {
       Edge e=dijkstra_test2.pred(v);
-      Node u=G.tail(e);
+      Node u=G.source(e);
       if ( dijkstra_test2.dist(v) - dijkstra_test2.dist(u) != cap[e] ) {
         std::cout<<"Error in a shortest path tree edge! Difference: " 

src/test/dijkstra_test.cc

@@ -94 +94 @@
 
   for(EdgeIt e(G); e!=INVALID; ++e) {
-    Node u=G.tail(e);
-    Node v=G.head(e);
+    Node u=G.source(e);
+    Node v=G.target(e);
     check( !dijkstra_test.reached(u) ||
            (dijkstra_test.dist(v) - dijkstra_test.dist(u) <= cap[e]),
-           "dist(head)-dist(tail)- edge_length= " 
+           "dist(target)-dist(source)- edge_length= " 
            << dijkstra_test.dist(v) - dijkstra_test.dist(u) 
            - cap[e]);
@@ -108 +108 @@
     if ( dijkstra_test.pred(v)!=INVALID ) {
       Edge e=dijkstra_test.pred(v);
-      Node u=G.tail(e);
+      Node u=G.source(e);
       check(u==dijkstra_test.predNode(v),"Wrong tree.");
       check(dijkstra_test.dist(v) - dijkstra_test.dist(u) == cap[e],

src/test/graph_factory_test.cc

@@ -29 +29 @@
 This test makes consistency checks of list graph structures.
 
-G.addNode(), G.addEdge(), G.tail(), G.head()
+G.addNode(), G.addEdge(), G.source(), G.target()
 
 \todo Checks for empty graphs and isolated points.
@@ -49 +49 @@
 
   for(typename std::vector<Edge>::iterator p=ee.begin();p!=ee.end();p++)
-    G.addEdge(G.head(*p),G.tail(*p));
+    G.addEdge(G.target(*p),G.source(*p));
 }
 

src/test/graph_test.h

@@ -54 +54 @@
     for(int i=0;i<nn;i++) {
       check(e!=INVALID,"Wrong OutEdge list linking.");
-      check(n==G.tail(e), "Wrong OutEdge list linking.");
+      check(n==G.source(e), "Wrong OutEdge list linking.");
       ++e;
     }
@@ -66 +66 @@
     for(int i=0;i<nn;i++) {
       check(e!=INVALID,"Wrong InEdge list linking.");
-      check(n==G.head(e), "Wrong InEdge list linking.");
+      check(n==G.target(e), "Wrong InEdge list linking.");
       ++e;
     }
@@ -82 +82 @@
 
   ///\file
-  ///\todo Check head(), tail() as well;
+  ///\todo Check target(), source() as well;
 
   

src/test/path_test.cc

@@ -48 +48 @@
   P.clear();                      //void clear() {}
 
-  gn=P.head();                    //GraphNode/*It*/ head() const {return INVALID;}
-  gn=P.tail();                    //GraphNode/*It*/ tail() const {return INVALID;}
+  gn=P.target();                    //GraphNode/*It*/ target() const {return INVALID;}
+  gn=P.source();                    //GraphNode/*It*/ source() const {return INVALID;}
 
   ei=P.first(ei);                 //It& first(It &i) const { return i=It(*this); }
 
-  ni=P.head(ei);                  //NodeIt head(const EdgeIt& e) const {}
-  ni=P.tail(ei);                  //NodeIt tail(const EdgeIt& e) const {}
+  ni=P.target(ei);                  //NodeIt target(const EdgeIt& e) const {}
+  ni=P.source(ei);                  //NodeIt source(const EdgeIt& e) const {}
 
 

src/test/preflow_test.cc

@@ -68 +68 @@
   int c=0;
   for(SmartGraph::EdgeIt e(g); e!=INVALID; ++e) {
-    if (cut[g.tail(e)] && !cut[g.head(e)]) c+=cap[e];
+    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
   }
   return c;

src/test/sym_graph_test.cc

@@ -31 +31 @@
 This test makes consistency checks of list graph structures.
 
-G.addNode(), G.addEdge(), G.tail(), G.head()
+G.addNode(), G.addEdge(), G.source(), G.target()
 
 \todo Checks for empty graphs and isolated points.

src/test/sym_graph_test.h

@@ -74 +74 @@
         SymEdge se;
         se=INVALID;
-        n=G.tail(se);
-        n=G.head(se);
+        n=G.source(se);
+        n=G.target(se);
       }
       // id tests
@@ -175 +175 @@
 
   ///\file
-  ///\todo Check head(), tail() as well;
+  ///\todo Check target(), source() as well;
 
   

src/test/test_tools.h

@@ -106 +106 @@
 
   for(typename std::vector<Edge>::iterator p=ee.begin();p!=ee.end();p++)
-    G.addEdge(G.head(*p),G.tail(*p));
+    G.addEdge(G.target(*p),G.source(*p));
 }