Index: test/all_pairs_shortest_path_test.cc
===================================================================
--- test/all_pairs_shortest_path_test.cc	(revision 2335)
+++ test/all_pairs_shortest_path_test.cc	(revision 2386)
@@ -49,5 +49,5 @@
 
   const int n = argc > 1 ? atoi(argv[1]) : 20;
-  const int e = argc > 2 ? atoi(argv[2]) : (int)(n * log((double)n));
+  const int e = argc > 2 ? atoi(argv[2]) : int(n * log(double(n)));
   const int m = argc > 3 ? atoi(argv[3]) : 100;
 
Index: test/arborescence_test.cc
===================================================================
--- test/arborescence_test.cc	(revision 2242)
+++ test/arborescence_test.cc	(revision 2386)
@@ -20,10 +20,10 @@
 using namespace std;
 
-const int n = 10;
-const int e = 22;
+const int NODES = 10;
+const int EDGES = 22;
 
 int sourceNode = 0;
 
-int sources[e] = {
+int sources[EDGES] = {
   1, 0, 2, 4, 4, 3, 9, 8, 9, 8,
   4, 2, 0, 6, 4, 1, 7, 2, 8, 6,
@@ -31,5 +31,5 @@
 };
 
-int targets[e] = {
+int targets[EDGES] = {
   8, 3, 1, 1, 4, 9, 8, 1, 8, 0,
   3, 2, 1, 3, 1, 1, 2, 6, 3, 9,
@@ -37,5 +37,5 @@
 };
 
-double costs[e] = {
+double costs[EDGES] = {
   107.444, 70.3069, 46.0496, 28.3962, 91.4325,
   76.9443, 61.986, 39.3754, 74.9575, 39.3153,
@@ -57,9 +57,9 @@
   vector<Node> nodes;
   
-  for (int i = 0; i < n; ++i) {
+  for (int i = 0; i < NODES; ++i) {
     nodes.push_back(graph.addNode());
   }
 
-  for (int i = 0; i < e; ++i) {
+  for (int i = 0; i < EDGES; ++i) {
     Edge edge = graph.addEdge(nodes[sources[i]], nodes[targets[i]]);
     cost[edge] = costs[i];
@@ -86,5 +86,5 @@
     if (mca.reached(graph.source(it))) {
       double sum = 0.0;
-      for (int i = 0; i < (int)dualSolution.size(); ++i) {
+      for (int i = 0; i < int(dualSolution.size()); ++i) {
         if (dualSolution[i].second.find(graph.target(it)) 
             != dualSolution[i].second.end() &&
Index: test/bipartite_matching_test.cc
===================================================================
--- test/bipartite_matching_test.cc	(revision 2137)
+++ test/bipartite_matching_test.cc	(revision 2386)
@@ -20,20 +20,20 @@
 BPUGRAPH_TYPEDEFS(Graph);
 
-const int n = 10;
-const int m = 10;
-const int e = 52;
-const int c = 100;
-
-const int sa[e] = { 6, 5, 6, 4, 1, 0, 9, 5, 2, 4, 4, 3, 5,
+const int N = 10;
+const int M = 10;
+const int E = 52;
+const int C = 100;
+
+const int sa[E] = { 6, 5, 6, 4, 1, 0, 9, 5, 2, 4, 4, 3, 5,
                     2, 3, 8, 3, 4, 9, 6, 9, 4, 3, 1, 5, 8,
                     4, 8, 9, 2, 2, 3, 0, 5, 2, 3, 6, 3, 8,
                     8, 4, 0, 9, 9, 6, 2, 1, 2, 7, 1, 9, 4};
 
-const int ta[e] = { 2, 7, 4, 8, 6, 3, 4, 1, 7, 7, 0, 1, 6,
+const int ta[E] = { 2, 7, 4, 8, 6, 3, 4, 1, 7, 7, 0, 1, 6,
                     3, 2, 6, 8, 3, 5, 6, 3, 1, 8, 7, 2, 0,
                     6, 9, 6, 7, 8, 3, 3, 4, 5, 8, 6, 4, 1,
                     4, 3, 3, 8, 7, 7, 3, 7, 7, 3, 5, 1, 6};
 
-const int wa[e] = { 3, 99, 85, 16, 79, 52, 83, 99, 62, 6, 42, 6, 95,
+const int wa[E] = { 3, 99, 85, 16, 79, 52, 83, 99, 62, 6, 42, 6, 95,
                     13, 34, 9, 5, 38, 39, 75, 99, 12, 73, 35, 93, 43,
                     54, 91, 45, 26, 77, 47, 11, 22, 50, 74, 37, 64, 91,
@@ -53,13 +53,13 @@
   int min_cost_matching;
 
-  for (int i = 0; i < n; ++i) {
+  for (int i = 0; i < N; ++i) {
     Node node = graph.addANode();
     aNodes.push_back(node);
   }
-  for (int i = 0; i < m; ++i) {
+  for (int i = 0; i < M; ++i) {
     Node node = graph.addBNode();
     bNodes.push_back(node);
   }
-  for (int i = 0; i < e; ++i) {
+  for (int i = 0; i < E; ++i) {
     Node aNode = aNodes[sa[i]];
     Node bNode = bNodes[ta[i]];
@@ -289,5 +289,5 @@
 
   Graph::UEdgeMap<int> cost(graph);
-  cost = subMap(constMap<UEdge>(c), weight);
+  cost = subMap(constMap<UEdge>(C), weight);
   {
 
@@ -304,5 +304,5 @@
     min_cost_matching = bpmatch.matchingCost();
     check(max_cardinality == bpmatch.matchingSize(), "WRONG SIZE");
-    check(max_cardinality * c - max_cardinality_max_weight 
+    check(max_cardinality * C - max_cardinality_max_weight 
           == bpmatch.matchingCost(), "WRONG SIZE");
 
@@ -327,5 +327,5 @@
     min_cost_matching = bpmatch.matchingCost();
     check(max_cardinality == bpmatch.matchingSize(), "WRONG SIZE");
-    check(max_cardinality * c - max_cardinality_max_weight 
+    check(max_cardinality * C - max_cardinality_max_weight 
           == bpmatch.matchingCost(), "WRONG SIZE");
 
Index: test/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 2369)
+++ test/lp_test.cc	(revision 2386)
@@ -262,7 +262,7 @@
 
   if (stat ==  LpSolverBase::OPTIMAL) {
-    std::ostringstream buf;
-    buf << "Wrong optimal value: the right optimum is " << exp_opt; 
-    check(std::abs(lp.primalValue()-exp_opt) < 1e-3, buf.str());
+    std::ostringstream sbuf;
+    sbuf << "Wrong optimal value: the right optimum is " << exp_opt; 
+    check(std::abs(lp.primalValue()-exp_opt) < 1e-3, sbuf.str());
     //+ecvt(exp_opt,2)
   }
Index: test/map_test.h
===================================================================
--- test/map_test.h	(revision 1956)
+++ test/map_test.h	(revision 2386)
@@ -46,5 +46,5 @@
     typedef typename Graph::template NodeMap<int> IntNodeMap;
     IntNodeMap map(graph, 42);
-    for (int i = 0; i < (int)nodes.size(); ++i) {
+    for (int i = 0; i < int(nodes.size()); ++i) {
       check(map[nodes[i]] == 42, "Wrong map constructor.");      
     }
@@ -54,5 +54,5 @@
     }
     map = constMap<Node>(12);
-    for (int i = 0; i < (int)nodes.size(); ++i) {
+    for (int i = 0; i < int(nodes.size()); ++i) {
       check(map[nodes[i]] == 12, "Wrong map constructor.");      
     }    
@@ -84,5 +84,5 @@
     IntEdgeMap map(graph, 42);
     
-    for (int i = 0; i < (int)edges.size(); ++i) {
+    for (int i = 0; i < int(edges.size()); ++i) {
       check(map[edges[i]] == 42, "Wrong map constructor.");      
     }
@@ -95,5 +95,5 @@
     }
     map = constMap<Edge>(12);
-    for (int i = 0; i < (int)edges.size(); ++i) {
+    for (int i = 0; i < int(edges.size()); ++i) {
       check(map[edges[i]] == 12, "Wrong map constructor.");      
     }    
Index: test/max_matching_test.cc
===================================================================
--- test/max_matching_test.cc	(revision 2116)
+++ test/max_matching_test.cc	(revision 2386)
@@ -75,5 +75,5 @@
     if ( mate[v]!=INVALID ) ++s;
   }
-  int size=(int)s/2;  //size will be used as the size of a maxmatching
+  int size=int(s/2);  //size will be used as the size of a maxmatching
 
   for(NodeIt v(g); v!=INVALID; ++v) {
@@ -93,5 +93,5 @@
     if ( mate[v]!=INVALID ) ++s;
   }
-  check ( (int)s/2 == size, "The size does not equal!" );
+  check ( int(s/2) == size, "The size does not equal!" );
 
   Graph::NodeMap<MaxMatching<Graph>::pos_enum> pos1(g);
@@ -104,5 +104,5 @@
     if ( mate[v]!=INVALID ) ++s;
   }
-  check ( (int)s/2 == size, "The size does not equal!" ); 
+  check ( int(s/2) == size, "The size does not equal!" ); 
   
   Graph::NodeMap<MaxMatching<Graph>::pos_enum> pos2(g);
@@ -116,5 +116,5 @@
     if ( mate[v]!=INVALID ) ++s;
   }
-  check ( (int)s/2 == size, "The size does not equal!" ); 
+  check ( int(s/2) == size, "The size does not equal!" ); 
   
   Graph::NodeMap<MaxMatching<Graph>::pos_enum> pos(g);
@@ -177,5 +177,5 @@
     if ( pos[v]==max_matching.A ) ++barrier;
   }
-  int expected_size=(int)( countNodes(g)-num_comp+barrier)/2;
+  int expected_size=int( countNodes(g)-num_comp+barrier)/2;
   check ( size==expected_size, "The size of the matching is wrong." );
   
Index: test/mip_test.cc
===================================================================
--- test/mip_test.cc	(revision 2369)
+++ test/mip_test.cc	(revision 2386)
@@ -31,7 +31,7 @@
 
   if (stat ==  MipSolverBase::OPTIMAL) {
-    std::ostringstream buf;
+    std::ostringstream sbuf;
     buf << "Wrong optimal value: the right optimum is " << exp_opt; 
-    check(std::abs(lp.primalValue()-exp_opt) < 1e-3, buf.str());
+    check(std::abs(lp.primalValue()-exp_opt) < 1e-3, sbuf.str());
     //+ecvt(exp_opt,2)
   }
Index: test/radix_sort_test.cc
===================================================================
--- test/radix_sort_test.cc	(revision 2242)
+++ test/radix_sort_test.cc	(revision 2386)
@@ -33,4 +33,6 @@
 using namespace lemon;
 
+typedef unsigned char uchar;
+
 void checkRadixSort() {
   {
@@ -49,5 +51,5 @@
     vector<unsigned char> data1(n), data2(n);
     for (int i = 0; i < n; ++i) {
-      data1[i] = data2[i] = rnd[(unsigned char)200];
+      data1[i] = data2[i] = rnd[uchar(200)];
     }
     radixSort(data1.begin(), data1.end());
@@ -76,5 +78,5 @@
     vector<unsigned char> data1(n), data2(n);
     for (int i = 0; i < n; ++i) {
-      data1[i] = data2[i] = rnd[(unsigned char)200];
+      data1[i] = data2[i] = rnd[uchar(200)];
     }
     counterSort(data1.begin(), data1.end());
@@ -97,5 +99,5 @@
 
   const int n = 100;
-  const int e = (int)(n * log((double)n));
+  const int e = int(n * log(double(n)));
 
   Graph graph;
@@ -118,10 +120,10 @@
   Graph::EdgeMap<bool> was(graph, false);
 
-  for (int i = 0; i < (int)edges.size(); ++i) {
+  for (int i = 0; i < int(edges.size()); ++i) {
     check(!was[edges[i]], "Test failed");
     was[edges[i]] = true;
   }
 
-  for (int i = 1; i < (int)edges.size(); ++i) {
+  for (int i = 1; i < int(edges.size()); ++i) {
     check(graph.id(graph.source(edges[i - 1])) <= 
 	  graph.id(graph.source(edges[i])), "Test failed");
@@ -136,5 +138,5 @@
 
   const int n = 100;
-  const int e = (int)(n * log((double)n));
+  const int e = int(n * log(double(n)));
 
   Graph graph;
@@ -161,10 +163,10 @@
   Graph::EdgeMap<bool> was(graph, false);
 
-  for (int i = 0; i < (int)edges.size(); ++i) {
+  for (int i = 0; i < int(edges.size()); ++i) {
     check(!was[edges[i]], "Test failed");
     was[edges[i]] = true;
   }
 
-  for (int i = 1; i < (int)edges.size(); ++i) {
+  for (int i = 1; i < int(edges.size()); ++i) {
     check(graph.id(graph.target(edges[i - 1])) < 
 	  graph.id(graph.target(edges[i])) || 
